Enter your Sign on user name and password.

Forgot password?
Sign In | Subscribe
Start learning today, and be successful in your academic & professional career. Start Today!

Use Chrome browser to play professor video
Justin Mui

Justin Mui

Classes: Part I

Slide Duration:

Table of Contents

I. Introduction to Ruby
Setting Up Your Environment

22m 8s

Intro
0:00
Installing Ruby
0:06
Ruby-lan.org
0:07
Three Ways of Installing Ruby
2:26
Compiling Ruby-Source Code
3:02
Third Party Tools
3:28
Other Implementations of Ruby
4:48
Windows Installation
5:21
RubyInstaller.org
5:22
Mac OSX and Linux Installation
6:13
Mac OSX and Linux Installation
6:14
Setting Up Debian/Linux
6:42
Setting Up Debian/Linux
6:43
Installing HomeBrew
6:56
HomeBrew for MAC OSX
6:57
HomeBrew Wiki
9:44
Installing HomeBrew
10:02
Setting Up Mac OSX
11:46
HomeBrew, RVM, OSX-GCC Installer, and Install Ruby 1.9.3
11:47
Ruby Version Manager (RVM)
12:11
Ruby Version Manager (RVM) Overview
12:12
Installing Ruby Version Manager (RVM): http://rvm.io
12:35
Install RVM with Ruby
14:20
Install RVM with Ruby
14:21
Install OSX-GCC-Installer
16:18
Download and Install Package for Your OSX
16:19
Install Ruby 1.9.3
17:28
Install Ruby 1.9.3
17:29
Test It Out!
18:09
rvm-help & ruby-v
18:10
Example: rvm gemset create educator
18:52
Set It As Default!
20:47
rvm Use 1.9.3@educator--default
20:48
Intro to Ruby

22m 20s

Intro
0:00
What is Ruby?
0:06
What is Ruby?
0:07
Ruby Standard Library
0:52
Who Created Ruby?
1:22
Yukihiro Matsumoto
1:23
History
2:45
The Name 'Ruby'
2:46
Ruby v0.95
3:10
Ruby v1.0
3:56
English Language Mailing List Rubytalk
4:08
ruby-forum.com & the Mailing Lists
4:27
Ruby In The West
9:51
Ruby on Rails
10:39
The Pragmatic Programmer's Guide to Ruby
11:30
rubyonrails.org
13:34
Current Ruby
14:42
Ruby 1.8.7, Ruby 1.9.3, and Ruby 2.0
14:43
Why Programmers Enjoy Ruby?
15:40
Why Programmers Enjoy Ruby?
15:41
Ruby Is An Interpreted Language
16:21
Ruby Is An Interpreted Language
16:22
What Is It Used For?
16:50
What Is It Used For?
16:51
Ruby is Object-Oriented
18:17
Example: 5.class
18:18
Example: 0.0.class
18:54
Example: true.class
19:03
Example: nil.class
19:12
Object Class
19:19
BasicObject
19:20
Example
19:52
Superclass
20:50
Fixnum → Integer → Numeric → Object
21:32
Basic Tools for Using Ruby

27m 44s

Intro
0:00
Interactive Ruby
0:08
irb: Interactive Command-Line Environment
0:09
Example
0:49
irb-v
0:50
irb-executes terminal
1:02
1.9.3-p125 > 'hi'
1:09
Live Demonstration
1:31
Why Use Interactive Ruby?
2:21
Why Use Interactive Ruby?
2:22
RDoc
3:05
RDoc
3:06
Ruby Core Documentation
3:32
Ruby Core Documentation: Example
5:30
Ruby Core Documentation: Markup
6:12
Ruby Core Documentation: Headings
7:44
Coding Example: RDoc
9:30
Why Use RDoc?
13:02
Learning Core Ruby Functions
13:03
Generating RDoc
15:31
rdoc-help # usage
15:32
Ruby Interpreter
15:57
ruby -- help
15:58
ruby [switches] [-] program [arguments]
16:16
Example: How to Run a Ruby Script
16:28
Rake
18:38
Rake Overview
18:39
Ruby Core Documentation: Rake
19:46
Coding Example: Rake
23:14
Why Was It Created?
24:30
Why Was It Created?
24:31
Lesson Summary
25:13
Lesson Summary
25:14
IDE/script Editors: MacVIM
26:24
Ruby Specifics

20m 45s

Intro
0:00
Ruby Specifics
0:06
Comments
0:51
Hashtags
1:00
Example
1:23
Multi-Line Comment
2:04
Example
3:10
RDoc Comments
4:02
When do you generate an Rdoc?
4:10
Headings and subheadings
4:24
Examples
4:48
Generating an Rdoc - example
4:50
Common Code Conventions
6:28
For every tab use two spaces indentation
7:38
Never use tabs
7:42
Common Code Conventions (Cont.)
8:18
Camel case
8:20
Snake case
9:18
Identifiers
9:44
Constants begin with CAP letter
10:00
Examples
10:10
Identifiers with Different Scoping
10:26
Global
10:34
Instance Variable
10:40
Class Variable
10:46
Examples
10:56
Reserved Keywords
12:22
Do not use reserved keywords in code
12:25
Parentheses are Sometimes Optional
13:04
Functions do not require parentheses
13:16
When in doubt, use parentheses
13:54
Examples
14:10
Newlines Are Statement Terminators
14:20
Examples
15:10
Continuation with a Period
16:20
Period means continue to next line
16:46
Multiple Statements Allowed on a Single Line
17:38
Try not to use semi-colons
17:58
Code Blocks
18:20
Use code blocks for one liners
18:28
Examples
18:40
Recommended for multiple lines
20:16
Ruby Data Types (Part 1)

29m 37s

Intro
0:00
Overview
0:10
Ruby Data Types
0:10
Numbers
0:16
Strings
0:18
Symbols
0:24
Numbers
0:30
Numeric
0:44
Float
0:50
Complex
0:56
BigDecimal
0:58
Rational
1:00
Integer (most popular) - Fixnum and Bignum
1:06
Fixnum stores 31 bits
1:18
Bignum stores larger bits
1:24
All number objects are instances of Numeric
1:28
Integer Literals
2:28
Represent whole-numbers
2:40
Examples - Different bases
2:42
Binary
3:04
Octal
3:30
Hexadecimal
3:44
Examples
4:06
Floating Point Literals
4:45
Examples
4:58
e-value can be capital or lowercase
5:30
Example
5:44
Strings
6:16
Mutable objects
6:18
Used for inserting and deleting text, searching, and replacing
6:26
String Rdoc
6:46
Definition
7:00
String Literals
8:20
Single-Quoted
8:28
Double-Quoted (most used)
8:50
Example
9:32
Escape Sequences
11:10
Newline
11:16
Tab
11:22
Double quote
11:28
Blackslash
11:36
Interpolation
11:50
Sprintf
13:48
Unicode Escaping
14:38
Example
15:50
Delimiters
16:18
Here Documents
17:18
Example
17:25
String Operators
19:58
Concatenation
20:03
Appending
20:40
String Equality
21:04
Example
21:24
Substrings
22:00
Range object (inclusive)
22:22
String Encoding
24:52
Differences between Ruby 1.8 and 1.9
24:56
Symbols
26:02
Definitions
26:04
Examples
26:46
When to use symbols
26:54
Symbols and Strings
27:42
Symbols Rdoc
28:22
Ruby Gems

25m 50s

Intro
0:00
RubyGems
0:08
What are RubyGems?
0:24
RubyGems.org
0:44
How RubyGems are used
2:06
Java's jar utility
2:50
Unix/Linux's tar utility
3:06
What is a Gem?
3:16
Definition of Gem
3:20
Version
3:34
Date
3:44
Author
3:50
Description
5:58
What Are the Uses?
4:18
Uses for Gems
4:22
Installation
5:06
How to install RubyGems
5:30
Updating to the Latest Ruby Gems
5:54
Testing
6:22
Example
6:34
Installing Rake
7:24
Example
7:46
Verifying
9:22
Example
9:56
Structure
10:56
gem.gemspec
11:30
Specification
13:40
What is in the gem?
13:42
Who made it?
13:50
Update gem version
13:58
Example
14:10
Create Our First Gem
17:20
Steps involved
17:28
RubyGems Guides
17:36
Example
20:02
Steps Review
18:56
Create Our First Gem (Cont.)
23:08
Building the gem
19:38
Example
20:00
Installing the gem
22:32
Run it
22:52
Publish it
23:04
Get Some Gems!
25:06
rake
25:14
rails
25:19
fastercsv
25:25
koala
25:37
Ruby Data Types (Part 2)

40m 24s

Intro
0:00
Ruby Data Types
0:15
Boolean
0:21
Arrays
0:27
Hashes
0:33
Range
0:37
Boolean Types
0:42
TrueClass
0:56
FalseClass
1:12
NilClass
1:18
TrueClass Examples
2:48
FalseClass Examples
3:22
Arrays
4:16
Ordered collection of objects
4:22
Can hold different objects
4:32
Starts at index 0
4:50
Array of Strings
5:50
Example
5:52
Arrays (Cont.)
6:20
Can be created using literals
6:22
Can be created using constructors
6:54
Position and indexed value
8:04
Negative Indexed Values
8:56
Shift and Unshift
10:18
Push and Pop
11:38
.delete method
12:38
Addition and Subtraction
13:32
Union and Intersection
14:48
Insert
15:52
Iteration
16:52
Arrays Rdoc
17:48
Hashes
22:08
Maps and Associative Arrays
22:44
Created using the constructor
22:56
Created using a hash literal
24:02
Stored in a hash table
25:26
Example
25:50
Accessing Key-Values
27:46
Deletion
29:48
Iteration
31:04
Hashes Rdoc
32:04
Ranges
36:40
Two dots are inclusive
36:57
Three dots are exclusive
37:16
Example
37:50
Ranges Rdoc
38:24
Objects

1h 5m 46s

Intro
0:00
Objects
0:10
Object References
1:36
Ruby Core
2:16
Example
4:30
Creating New Objects
6:00
New Method
6:08
Initialize Method
6:31
Example
7:18
Garbage Collection
9:54
Global values always reachable
10:25
Object Identity
11:08
Every object has an object identifier
11:20
Object identifier is constant and unique
11:30
Example
11:54
Object Class
12:58
Class method
13:10
Superclass method
13:28
Object Testing
14:46
is_a?
15:49
respond_to?
16:26
String and Regexp
18:10
Comparing two object instances
20:06
Example
23:30
Object Equality
25:48
Comparing objects
25:54
equal?
25:58
Popular way to test for equality
27:16
Opposite way to test for equality
27:25
Arrays
28:30
Hash
29:42
Case equality operator
30:47
Class tests
31:16
Range tests
31:48
Symbol tests
32:32
Object Conversion
33:14
Explicit conversion
33:54
Implicit conversion
35:00
Example
36:12
Object Conversion: Kernel Module
38:22
Array
38:38
Float
39:26
Integer
39:58
String
40:10
Example
40:34
Object Conversion: Coerce
42:00
Used for mixed type numeric operations
42:08
Example
43:40
Object Conversion: Boolean
47:42
Every object has a boolean value
47:44
Example
48:54
Object Copying
50:52
dup
50:58
clone
51:03
Example
51:42
Object Freezing
57:36
Object Marshaling
58:38
Save state
59:04
Load state
59:27
Example
59:32
Tainted Objects
1:01:50
taint
1:02:08
farm field
1:02:12
Untrusted Objects
1:04:06
trust
1:04:24
untrust
1:04:34
untrusted?
1:04:42
Loops

38m 54s

Intro
0:00
Loops
0:12
while and until
0:48
for and in
0:54
iterators
1:04
enumerable in objects
1:06
While-loop
1:14
Will keep going is condition is true
1:18
Until-loop
2:58
Will keep going until condition becomes true
3:06
Single Expression Loops
4:20
Compact form
4:30
Expressed as a modifier
4:42
Do-While Loop
5:52
Executes body first
6:06
Do-Until Loop
7:54
Similar to do-while loop
7:58
Using Break Inside Loops
8:54
break
8:58
For-In Loop
11:56
for-loop
12:06
var
12:34
collection
12:54
body
13:00
Examples
13:08
Examples (Cont.)
15:54
Nested loops
16:40
Numeric Iterators
18:32
upto
18:40
downto
18:42
times
18:48
Examples
20:28
External Iterators
21:00
Enumerator class
21:04
Rdoc
21:16
Enumerables in Objects
24:35
Enumerable is a mix-in
24:41
RDoc
25:24
Commonly Used Enumerables in Objects
27:01
Array
27:19
Hash
27:51
Range
28:47
Examples
29:29
Enumerables in Objects (Cont.)
31:13
File Processing
31:15
Example
31:45
Enumerables in Objects (Cont.)
33:07
collect
33:23
select
34:11
reject
34:59
inject
35:29
Strings

28m 30s

Intro
0:00
Strings
0:08
Why do you want to get familiar with strings?
1:00
String Creation
1:16
new
1:28
empty?
1:50
length or size
2:10
Example
3:12
String Manipulation
4:40
slice
4:56
square brackets [ ]
5:02
token
5:40
[fixnum]
6:52
offset and length
8:40
chaining
12:42
String Insertion
12:56
insert
12:58
positive or negative index
13:46
String Updates
15:24
[token]
15:36
Examples
16:40
chop or chop!
17:54
chomp!
18:56
gsub
20:28
String Deletion
21:38
delete
21:38
String Reversal
22:46
reverse
22:52
String Manipulation
23:16
split(pattern=$, limit)
23:22
pattern
24:10
limit
24:15
upcase or upcase!
25:28
downcase or downcase!
26:02
swapcase
26:24
Incrementing Strings
27:26
next or next!
27:32
Check Out the Other Lessons
28:00
Ruby Data Types Part 1
28:12
Regular Expressions
28:18
Regular Expressions

33m 27s

Intro
0:00
Regular Expressions
0:10
How to create a regular expression
0:48
What goes inside
1:36
Metacharacters
3:10
Bracket expressions
3:14
Quantifiers
3:18
Anchors
3:20
Metacharacters
3:30
word and non-word characters
4:04
digit and non-digit characters
4:44
hexdigit and non-hexdigit characters
4:56
whitespace and non-whitespace characters
5:08
Examples
5:24
POSIX Bracket Expressions
7:48
Non-POSIX Bracket Expressions
9:48
Bracket Expression Examples
10:58
Quantifiers
12:34
Examples
13:30
Character Properties
17:24
Similar to POSIX bracket classes
18:22
More Character Properties
18:48
Examples
19:32
Anchors
20:08
Examples
21:14
Regular Expression Matching: Regexp Object
22:40
match
22:51
Regular Expression Matching: String Object
24:14
match
24:26
Regular Expression Modifier Characters
25:14
pat
25:38
Example
26:42
Regular Expression Modifier Objects
27:14
Example
28:38
Regexp Rdoc
30:40
Arrays

14m 35s

Intro
0:00
Arrays
0:12
Creating an Array with a Block
0:50
Alternative Ways to Create an Array
3:52
Checking the Class
5:14
Iterate through the array
5:26
Call the class method
5:28
Array Shortcuts
6:38
at(index)
6:44
delete_at(index)
7:28
first(n)
8:28
last(n)
9:28
Removing Duplicates
9:58
uniq or uniq!
10:04
Sorting the Array
10:48
sort or sort!
10:54
Getting the Index
11:35
index
11:56
rindex
12:38
Multidimensional Arrays
12:56
flatten
13:33
Check Out the Earlier Lesson
14:16
Ruby Data Types Part 2
14:26
Hashes

27m 48s

Intro
0:00
Hashes
0:12
Creating Hashes
1:18
Setting a Default Value
2:24
Accessing Hashes
4:16
Accessible by keys or by values
4:28
Keys must be unique
4:36
Creating Hashes
5:16
Comma-separated list
5:42
Hash rocket
8:28
Examples
10:16
Iterating Keys and Values
11:43
each_key
12:04
each_value
14:04
Merging Hashes
16:10
merge(other_hash)
16:20
Sorting Hashes
18:46
Replacing Hashes
20:57
replace(other_hash)
21:18
Converting Hashes to Other Classes
22:04
to_a
22:22
to_s
23:22
Example
24:34
Check Out the Earlier Lesson
27:22
Ruby Data Types Part 2
27:32
Math Operations, Part 1

28m 47s

Intro
0:00
Math Objects
0:12
Numeric
0:26
Integer
0:38
Float
1:02
Fixnum
1:14
Bignum
1:56
Rational
2:04
Math
2:24
Math Operations
2:36
Example
3:14
div(numeric)
4:54
divmod(numeric)
6:30
modulo(numeric)
7:23
quo(numeric)
8:18
remainder(numeric)
9:35
Operation Precedence 1 of 3
10:35
Operation Precedence 2 of 3
13:18
Operation Precedence 3 of 3
14:28
Abbreviated Math Operations
14:54
Move the operator in front of the equal sign
15:52
Numbers
16:36
Numeric Class
17:06
Numeric Methods
18:41
ceil
18:52
floor
19:32
round
19:50
Example with Numbers
20:20
Numeric Methods (Cont.)
22:20
truncate
22:28
num.step(limit, step)
23:02
Numeric Rdoc
25:26
Math Operations, Part 2

28m 51s

Intro
0:00
Math Operations
0:12
Math Module
0:24
Rational Numbers
0:44
Complex Numbers
0:52
Prime Numbers
0:58
Matrices
1:06
Math Module
1:12
PI and E
1:32
Math Module Methods
2:47
atan2(x,y)
2:56
cos(x)
3:14
exp(x)
3:44
Examples
4:38
log(x)
5:44
log(num, base)
6:34
log10(x)
7:04
sin(x)
7:34
sqrt(x)
7:52
tan(x)
8:06
Math Functions: Part 1 of 3
8:12
Math Functions: Part 2 of 3
9:32
Math Functions: Part 3 of 3
10:19
Math Module Rdoc
11:25
Rational Numbers
13:23
How to use
14:06
Example
15:02
Mathematical Ruby Scripts (Mathn)
16:25
Example
17:28
Complex Numbers
18:26
polar
18:56
rect
19:10
Complex Number Examples
19:18
Prime Numbers
20:14
each(ubound=nil)
20:44
prime?
21:22
Example
21:58
Matrices
23:15
build(row_size, column_size=row_size)
23:44
Example
24:44
Matrix Rdoc
24:58
Dates and Times

26m 1s

Intro
0:00
Dates and Times
0:12
Time Class
0:38
Methods of the Time Class
1:43
now
1:44
at(time)
2:10
Epoch & Unix Timestamp Conversion Tools
3:19
Components of a Time
5:07
Convert Time to an Array
5:54
to_a
6:08
Creating a New Time
6:48
Time.local
7:08
Year is required
7:22
Time.utc
8:12
What should be specified
9:30
More Methods of the Time Class
10:16
strftime(string)
11:26
RDoc
12:50
Date Library
16:46
Initializing a New Date
17:08
Parsing Dates
18:28
parse(string)
18:42
Today's Date
19:19
Date.today
19:22
Tomorrow's Date
20:22
Next
20:28
Next week
21:22
Count Down
21:26
Count Up
22:37
Components of a Date
23:20
Converting to Datetime
23:48
to_datetime
24:00
Initializing a Datetime
24:24
Converting to Time
25:23
self.to_time
25:32
Methods: Part 1

31m 24s

Intro
0:00
What is a Method?
0:12
Basic Method
0:58
Return Value
4:37
return
4:46
Factorial Example
6:18
Example
8:46
Return Two Values
10:06
Set the return keyword
10:14
Collected and returned as an array
10:28
Undefining Methods
11:22
undef method_to_undefine
11:44
Example
12:32
Method Names
13:02
Begin with lowercase letter
13:16
Separate longer words with underscores
13:26
Can end with equal sign, question mark, or exclamation point
14:03
Equal sign
14:26
Method Names with Question Mark
14:44
empty?
15:24
Method Names with Exclamation Point
16:01
mutators
16:12
! means use with caution
16:46
Method Aliases
18:05
alias new_method existing_method
18:42
Operator Methods
20:00
Operators
20:02
Array Operators
20:10
Unary Operators
20:32
Binary Operators
20:40
Example
21:28
Methods and Parentheses
25:00
Optional in most cases
25:20
Required in other cases
27:13
Methods and Blocks
27:54
Associated with blocks
28:18
block_given?
28:26
yield
28:36
Example
29:24
Methods: Part 2

20m 11s

Intro
0:00
Methods with the Unary Ampersand Operator
0:14
&
0:34
Block to a Proc
0:56
Example
2:02
Proc object
3:58
Example
5:04
Methods with Default Values
5:54
Example
7:12
Methods with variable-Length Arguments
8:05
How to create it
8:36
Example
11:06
Using Hashes with Arguments
13:02
Multiple arguments
13:08
Solution
13:30
Example
14:56
Rdoc
18:12
Classes: Part I

26m 51s

Intro
0:00
Classes
0:10
Definition of a class
0:14
Class represents a container
0:32
Can be reused
0:46
Creating our First Class
1:00
Keyword class will create new class
1:06
Name must begin with capital letter
1:30
Instantiating Our First Class
2:46
New will create a new instance of class
2:58
Initializing Values
3:58
Definition of def
4:14
Instance method
5:08
Example
7:02
Defining the to_s Method
8:24
Creating a string representation class
8:34
Example
10:54
Self in the Class
12:16
Definition of self
12:26
Example
13:54
Accessor Methods
15:52
getter methods
16:22
Example
17:00
Setter Methods
18:00
Mutator methods
18:02
Example
19:46
Automating Getter and Setter Methods
21:10
Defined in the module class
21:30
attr_reader
21:54
attr_writer
22:48
attr creates getter and setter methods
23:50
Example
24:28
Notes on Ruby's Accessor Methods
25:32
Classes: Part II

26m 42s

Intro
0:00
Defining Operators
0:10
You can define arithmetic operators
0:32
Unary Operators
0:46
Let's define operators in our class!
0:56
Example
2:52
Class Methods
6:24
Examples
6:56
Opening Up the Class
9:38
Adds an additional method
9:54
Examples
11:04
Array and Hash Access Method
15:40
Use square brackets
16:02
Define your own has access method
16:08
Example
16:56
Enumerating The Values
18:40
Define the each iterator
18:40
Testing for Equality
19:36
Class Triplex
19:50
Examples
20:54
Constants
25:00
Usually defined at the top of class
25:24
Classes: Part III

53m 36s

Intro
0:00
Class Variables
0:14
Example
2:16
Ruby Glass Jar Example
8:50
Class Instance Variables
10:20
Instance variables of class objects
10:46
Advantage of class instance variables
11:18
Examples
11:30
Method Visibility
16:16
Three types of method visibility
16:26
Public methods
17:34
Private methods
17:38
Protected methods
18:04
Invoking Method Visibility
19:21
Public , Protected, and Private Visibility
19:22
Invoking Method Visibility With Arguments
21:39
Example: Invoking Method Visibility
22:12
Class Visibility
23:31
Instance and Class Variables are Private
23:32
Constants are Public
24:00
Makes Existing Class Methods Private
24:27
Makes Existing Class Methods Public
25:08
Example: Class Visibility and class GlassJar
25:43
Subclassing
27:08
Subclassing: Subclass and Superclass
27:09
Example: Subclassing
29:43
Inheritance
30:05
Inheritance
30:06
Example: Inheritance
31:25
Subclassing and Inheritance
31:34
Descendants
31:41
Ancestors
31:56
More On Descendants and Ancestors
32:08
Extending a Class
33:27
Extending a Class
33:28
Coding Example: Extending a Class
34:24
Overriding a Method
36:41
Overriding a Method
36:42
Coding Example: Overriding a Method
37:18
Modifying Methods with Chaining
38:52
Modifying Methods with Chaining
38:53
Super
39:25
Coding Example: Modifying Methods with Chaining
39:51
The Singleton Pattern
44:52
Introduction to The Singleton Pattern
44:53
Setting Up Singleton
45:28
The Instance Method
45:58
Rdoc for Singleton: Usage
46:23
Rdoc for Singleton: Implementation
47:45
Coding Example: Singleton
49:38
Modules

24m 19s

Intro
0:00
Modules
0:04
What is Modules?
0:05
Modules Examples
0:40
Modules: Mix-Ins
3:31
What is a Mix-in?
3:32
Modules: Namespace
4:07
What is a Namespace?
4:08
Why Use a Namespace?
5:13
Example of a Namespace Module
5:59
Example of Mixing in The Module Into the Global Scope
6:00
Modules: Creation
7:04
How to Create a New Module?
7:05
Modules: Usage
8:19
How to Use It?
8:20
class Poker & class Bridge
9:13
Creating Our Module as a Mix-In
9:41
Example of a Module Using Instance Methods
9:42
Coding Example
10:20
Creating Our Module as a Namespace
12:11
Implement Class Methods for the Module
12:12
Coding Example
14:56
Loading Our Module
19:46
Loading Our Module Overview
19:47
Require & Load
20:15
Coding Example: Loading Module
20:48
Lesson Summary
23:36
Loading...
This is a quick preview of the lesson. For full access, please Log In or Sign up.
For more information, please see full course syllabus of Introduction to Ruby
  • Discussion

  • Study Guides

  • Download Lecture Slides

  • Table of Contents

  • Transcription

  • Related Services

Start Learning Now

Our free lessons will get you started (Adobe Flash® required).
Get immediate access to our entire library.

Sign up for Educator.com

Membership Overview

  • Unlimited access to our entire library of courses.
  • Search and jump to exactly what you want to learn.
  • *Ask questions and get answers from the community and our teachers!
  • Practice questions with step-by-step solutions.
  • Download lesson files for programming and software training practice.
  • Track your course viewing progress.
  • Download lecture slides for taking notes.
  • Learn at your own pace... anytime, anywhere!

Classes: Part I

  • A class defines a set of methods that an object responds to
  • It is a container that holds properties such as variables, constants, and methods
  • It can be reused through inheritance and extended or subclassed to other classes
  • Every object is an instance of a class
  • The class keyword will create a class in Ruby
  • It is delimited with an end
  • new will create a new instance of a class
  • initialize method is invoked automatically with new is called
  • self is an instance of the class
  • Accessor methods return the value of the variable
  • Setter methods also known as mutator methods sets the field to a value specified by the argument
  • Ruby provides methods to automate getter and setter methods
  • These methods are defined in the Module class and can be invoked inside any class definition

Classes: Part I

Lecture Slides are screen-captured images of important points in the lecture. Students can download and print out these lecture slide images to do practice problems as well as take notes while watching the lecture.

  • Intro 0:00
  • Classes 0:10
    • Definition of a class
    • Class represents a container
    • Can be reused
  • Creating our First Class 1:00
    • Keyword class will create new class
    • Name must begin with capital letter
  • Instantiating Our First Class 2:46
    • New will create a new instance of class
  • Initializing Values 3:58
    • Definition of def
    • Instance method
    • Example
  • Defining the to_s Method 8:24
    • Creating a string representation class
    • Example
  • Self in the Class 12:16
    • Definition of self
    • Example
  • Accessor Methods 15:52
    • getter methods
    • Example
  • Setter Methods 18:00
    • Mutator methods
    • Example
  • Automating Getter and Setter Methods 21:10
    • Defined in the module class
    • attr_reader
    • attr_writer
    • attr creates getter and setter methods
    • Example
  • Notes on Ruby's Accessor Methods 25:32

Transcription: Classes: Part I

Welcome back to Educator.com.0000

Today's lesson is on classes; this is Part 1.0002

First, what is a class? A class defines a set of methods that an object responds to.0008

It represents a container that holds properties, such as variables and constants.0018

We do this to encapsulate a lot of different variables, objects, methods...and that is why we say it represents a container.0025

It can be reused; you can reuse it through inheritance, and you can extend it or subclass other classes.0038

Every object is an instance of a class.0048

First, we want to create our first class.0058

To do this, we use the class keyword; that will create a new class in Ruby.0063

Also, this creates a constant, too; this creates a new constant that refers to that class.0077

Whatever name you give after class is the constant name and the name of the class.0082

The name must begin with a capital letter; that is very important.0089

If you look at this class here--we have HelloWorld--notice that the first letter is capitalized.0093

After that, it doesn't matter what the next letters after it are: they could be lowercase or uppercase.0100

To end that class--we have our class here, HelloWorld--to end it, we just put the end at the end; that is the delimiter.0107

You can also use other things for HelloWorld; notice, we have our capital H here, but we also capitalize the subsequent word.0117

For our second word, we also have it capitalized, but we also have it lowercased, and you can also go wild and put the whole thing as uppercase.0131

Now, the convention is to, every time you have a new word, capitalize that letter, so it uses that to separate everything.0142

That is why you see, for our HelloWorld here, we have the W uppercased, as well.0153

Let's look at instantiating our first class.0161

Here I have HelloWorld.new, and it's creating its new object, and it's going to create that reference into this variable, just called hw.0167

That new will create a new instance of our class.0178

Of course, it's always like this: n-e-w, all lowercase.0183

That will actually create our class into memory.0190

After this, you can do a couple of things: I can call the class method, and it will tell me the class it's part of.0196

If I take my variable hw, and I call a .class on it, it will return to me, "This is part of the HelloWorld class."0204

I can also ask it, "Is it...?" one of these classes; so, using the the is_a? method, I can say, "Is it a class called HelloWorld?"0214

If I do that here, it's going to return true, since that is what we instantiated it as.0226

Next, let's look at initializing values.0237

To do this...instead of using function, which you often see in other languages, they often use what is called define.0242

They use def--all just in lowercase, d-e-f, and this defines an instance method for the class.0252

Like I said, in other languages you might see this as similar to the function, and then you would have your name of it here.0263

The initialize method is invoked automatically when new is called.0275

So, as you saw in that previous class, we called new to it, but you don't actually define any method in your class called new; you actually define it as initialize.0280

Speaking of that in your class, when you are creating it, it would just be def, and then initialize.0293

That creates this method that creates your object.0307

This is an instance method; it is a method that is invoked on an instance of the class.0314

So, whatever subsequent methods you make from this, they will be instance methods that are part of this class.0322

Now, this Initialize class is kind of interesting, because the new is actually a class method, but initialize is an instance method in this case, because you are defining it in this structure.0328

Let's look at an example here.0341

I have this class called HelloWorld; in it, we have our def, which says, "This defines an instance method of the class," so we have our instance method initialize.0344

It takes one parameter; it's taking a name.0359

What you see here is, it says we have this new variable that says @name, which is the instance variable, and this is getting the same value as that parameter.0363

So, as I do here, I created my class here; I instantiated the class.0378

We also initialized the name value.0393

And see here, I have HelloWorld.new, and I pass in the parameter Justin, which is the name value.0409

As I said before, we are initializing these values; what is happening here--first, we have the initialize method; it is automatically made private; if I were to do HelloWorld.new, and then I call the .initialize method, it wouldn't allow me to access it, because it's private.0423

The initialize method is accessible inside the scope of class, and you can call it as initialize, but otherwise--if I call it outside that scope--it's not going to allow me to do it.0445

It's automatically made private; the parameter is stored in local variable name.0456

Here we have this parameter name; that is the local variable.0463

Then, the name is assigned to instance variable @name.0468

We have our instance variable here...this is our instance variable, and this is our local variable.0472

If you look at it, you can tell--why is it an instance variable?--It has this @ sign here.0490

Next, let's look at defining the to_s method.0503

This allows us to have a string representation of that class.0509

I'm going to continue working on that hello_world method.0514

Here, we are going to...we have defined and initialized name, and we're defaulting it, now, to an empty string.0521

It says that, if I don't enter any value, it's going to enter an empty string of "", and it's going to allow me to continue that class, anyway.0536

So, I can call it without passing a parameter in.0551

Then, it goes ahead and declares and instantiates that instance variable from there.0554

Then, I'm going to declare that to_s method for that string representation.0560

It's going to create a new local variable called name inside this scope in that function.0565

That local variable only works in that method.0571

This says, "OK, I'm using this ternary operator, so I'm saying if this instance variable, name, if that is empty, I want you to pass world in there."0575

"But, if it isn't empty, go ahead and just pass name."0588

Here it says "Hello", and it interpolates the value name, so we have two values: this could be either "Hello world!", or it's going to say, "Hello", and then it's going to have whatever this @name value is.0592

This one is if it's empty, and this one is if it's not empty.0618

For example, here I just call HelloWorld.new; since it is empty, it's going to just print out "Hello world!"0633

Let's go ahead and set up some code for this, so you can see it in action.0643

I'm running my Ruby Interpreter.0652

I'm just going to create that class, so I have my HelloWorld; I'm going to initialize it with that default parameter, so it's going to do that empty string; @name=Name...0654

Then, I'm going to declare my to_s method here, so we have if @name is empty...if it is empty, it's going to pass world; else, it's going to pass name.0671

Then, this is what I'm returning; I'm returning that local variable name.0684

There you go: I have our class initialized.0693

Now, if I do HelloWorld.new, you will notice that it prints out "Hello world!"0695

But watch this: if I do HelloWorld.new, and I pass Justin in, you will notice it changes that value to "Hello Justin!"0703

I can pass that to a value, too, and it will still create that new object, hw, but for the to_s, you will notice it still prints out "Hello [world/Justin]!"0711

Plus, I can call hw.to_s, and it will print out that string again.0724

Next, we're going to look at this value called self that is used in the class.0737

Self just means that instance, that object of that class--the instance of the class.0744

When we do this, @name belongs to the object that self refers to, so I can do self.name.0751

For example, in this value, we actually updated this class now; it's going to initialize to a first name and last name.0760

I'll show you how this is done: first, let's just go over the code very quickly.0771

Now, we have first_name and last_name; they both have default values, so if I don't pass it in, it's going to create an empty string for that.0778

It has two instance variables now: @first_name and @last_name.0786

We have a new method called name; when I call this method, name, it's going to give me the full name--first name and last name--very simple.0794

Our to_s method has been updated; notice, now I call self.name.0801

What this does is--notice, when I call self.name, it's just going to call this method up here.0809

It's going to say "Hello" with the first name and last name with it.0817

Let's go ahead and show an example of how this works.0825

Let's just declare that method again.0832

This time, we updated it, though.0836

The first_name, the last_name...and I'm declaring the instance variables now.0843

Here is where I'm going to use a little interpolation; I'm going to say, "Interpolate the first value and then interpolate the last_name value."0859

Then, the last one is--I want to do that to_s method, but this time, I'm using that self keyword.0877

Here you see, that self.name is being used.0887

Let me show you it in action: so I do HelloWorld.new of John Doe; when I press Return, I have the new with the first_name, last_name, and it actually calls that to_s method by default when I declare it.0893

It says, "Hello John Doe!"; I can also do hw.name, and it's going to do the same; it's going to print out the name; and I can also just do hw.to_s, which will call name also, but uses that self method that we created, which is an instance of that object.0913

It gives you all of these properties that you can use while inside that class object, for your own functionality.0932

Next, let's look at accessor methods.0948

The accessor method returns the value of that variable.0953

For example, we're looking, first, at this HelloWorld; we have two accessor methods here.0960

All they do is to tell you what is that value in that instance variable.0974

These are also known as getter methods.0981

The first one will get me that @first_name value; the next one will get me that @last_name value.0995

I can actually show you how these accessor methods work; I have some code I want to show you here.1009

Here we have that same code piece again, but you notice I have two accessor methods here.1020

I'm going to declare that HelloWorld object, HelloWorld.new, and I'm going to call these two methods, hw.first_name, hw.last_name, and then we can see these methods in action--see how they return that value.1032

I'm going to execute that code I just showed you, that HelloWorld; the first one--John is the first name, Doe is the last name, and it's using these accessor methods to get the value back.1055

The next thing we want to look at is setter methods; setter methods, not getter--we just went over getter methods.1077

These are also known as mutator methods.1082

They set the field to a value specified by the argument, so whatever parameter you pass in that method, that is going to be the one that it's setting, and it's going to set it to the instance variable.1088

I updated that HelloWorld class again; so this time in that HelloWorld class, here are my accessor methods, or getter methods.1102

Notice that I have made them one-liners now; I'm using semicolons to shorten it from three lines to one.1116

The reason I did that was just to show you different flexibility you can do with the Ruby code here.1124

Here, we have our setter methods.1132

Here, we have our first_name, our parameter we pass in; that parameter itself is the one that we are setting that value to.1145

Setting that value, it will go to that first_name, that instance variable.1153

Then, we have this method called last_name; it also takes one parameter, and that value will be passed into the instance variable last_name.1158

These are the setter methods; they're very simple, but they do have a convention, and this is the basic convention they follow to set that value.1166

I do have this code in action so you can see it here.1179

In this code, I have my getter methods--my accessors--and then here are the setter methods, just like we said.1185

I want to show you this code in action, so we have the whole class set up here, and I'm going to initialize the HelloWorld object here.1197

First, I'm going to call those getter methods.1208

Then, I'm going to use the setter methods to change the first_name and last_name.1211

Here it says "Jane Smith," and then, when I do puts hw, it's going to call the to_s method, and the first_name and last_name should be updated--let's see what happens.1216

We already called HelloWorld 1, and I'm going to call HelloWorld 2.1235

There you go: so, we have our two methods here; it gets the first values we set with the object; then we updated those values using setters, and it says, "Hello Jane Smith!" now.1241

Now, Ruby allows us to automate the getter and setter methods; we just hand-defined them; we got the basic convention down--what these methods are and what they do--but Ruby has these built in because they're so commonly used.1265

They provide these methods to automate them.1280

These getter and setter methods are actually defined in the Module class.1285

You can invoke these in any class definition, and they are already part of these classes, too, so you already have this library already built in the class.1293

Let's look at a few of these methods.1304

The first one is attribute reader: it's attr_reader.1306

This creates a getter method for the instance variable with the same name.1313

In our previous slide, we had first_name--the method is called first_name--it's going to do the exact same thing here.1320

It's going to have that instance variable with that same name.1329

They make it really, really easy to create these methods: you just pass in the symbol, whatever name you want to use.1334

So here, I have my class HelloWorld; I just call attr_reader, and I use this symbol for first_name and the symbol for last_name, and that is it.1340

It saves my time; it doesn't mess up my code with all these getter and setter methods; it just makes it very simple and easy to put that in your class and define it.1351

Now we have our getter method; do they have a common setter method? Yes, they do!1366

We have this attribute writer here; the attribute writer creates a setter method for the instance variable with the same name.1372

Again, all I do is do the same thing; I can just use attr_writer, and then I just put first_name, and then last_name, and that is it--the same way as the reader method.1381

But, the attribute writer isn't commonly used, because usually, you want to be able to access it and read it out if you're editing it.1416

The more commonly used one is just attribute--attr.1425

This is the real one you want to get used to; it creates both the getter and the setter methods.1429

In Ruby 1.8, you would use attribute accessor, but in 1.9, you don't have to call attribute accessor: they shrunk it down, and you just need to call attr.1439

This works with 1.9, and it's a common way to do it, and it's the popular way; I would recommend you use it.1450

So, how do you automate this getter and setter method?1465

For our example, with our HelloWorld, all I would do is...I want both those methods, so I'm going to call attr and pass my first_name and my last_name.1469

Those are going to get me that symbol value, and it's going to define those two methods for each one of them.1480

What does it give me? Since we didn't make this code, it's kind of magical, because it's using that Module class...it's going to create me a getter method called first_name and last_name.1489

Think of it--if you had just created it yourself, you would have that defined here.1501

Then, the setter method is going to be first_name with that equals sign, so you can think of it like this, too...1506

Now, we have four methods that are magically in this class.1515

That attr already handled all of the magic for us; it already created it and defined it for us.1523

There are some things you need to know about using Ruby's accessor methods.1533

First, one good thing is that they run as fast as if you had hand-coded them yourself, so there is no time penalty for that.1541

The important thing is that these do map the same instance variable name--whatever symbol you give it, it's going to be the same name for that method and that variable.1555

So, if you needed something more complex, like a more complex accessor with a differently-named variable, you would need to define them yourself.1564

If I call method first_name, but I want to tell it to go to a different instance variable, then this wouldn't work in that case, because it has to all be preserved in that same name.1577

I would definitely say to check out Ruby's accessor methods and play around with the class.1593

Other than that, that is the end of the first part of the classes.1600

See you next time at Educator.com, and we will go on to the next class lesson after this.1606

Educator®

Please sign in for full access to this lesson.

Sign-InORCreate Account

Enter your Sign-on user name and password.

Forgot password?

Start Learning Now

Our free lessons will get you started (Adobe Flash® required).
Get immediate access to our entire library.

Sign up for Educator.com

Membership Overview

  • Unlimited access to our entire library of courses.
  • Search and jump to exactly what you want to learn.
  • *Ask questions and get answers from the community and our teachers!
  • Practice questions with step-by-step solutions.
  • Download lesson files for programming and software training practice.
  • Track your course viewing progress.
  • Download lecture slides for taking notes.

Use this form or mail us to .

For support articles click here.