Learn Ruby - Object Oriented Programming

"i wish i was surfing"

String is a class and classes are responsible for making "objects". "i wish i was surfing" is referred to as an object. "i wish i was surfing" is also referred to as an instance of the String class, which means that the String class made the "i wish i was surfing" object. We have been making String objects throughout these quizzes. The following two expressions are the same thing:

x = String.new("i wish i was surfing")
x = "i wish i was surfing"

The methods() method returns an array of the methods that the object can use. The String class is built-in to Ruby and provides a lot of methods that are commonly used, so we don't need to define them ourselves.

"HELLO"

The upcase() method capitalizes all the letters of a string object. In this example, the upcase() method is being called on the object "hello".

"SuP dUdE"

swapcase() is a method that is available to string objects. In this example, the swapcase() method is called on the "sUp DuDe" object.

string object, followed by dot, followed by the method name

For this example "hello".upcase(), "hello" is the string object and upcase() is the method name

In the "sUp DuDe".swapcase() example, "sUp DuDe" is the string object and swapcase() is the method name

"road trip"
# OR
String.new("road trip")

For the rest of this tutorial, let's stick with the explicit syntax (String.new("road trip")) since it is better for learning.

The explicit syntax makes it clear we are using the String class to make an instance of the String class (also referred to an object). "road trip" is an example of a string object (an object made by the String class).

[]

Array.new() creates a new array object (the empty array). The empty array is an instance of the Array class, meaning it was created by the Array class. An instance of the Array class is also referred to as an array object or an object.

["nice", "hair"]

my_array is an array object and push() is a method that adds elements to an array object. Notice that the same syntax used to call methods for the String class is used here: object, followed by dot, followed by the method name.

Here is how to interpret this example, line-by-line: my_array = Array.new() # An new array object has been created as is assigned to the variable my_array

my_array.push("nice") # The push() method is called on the my_array object to add the String "nice" to the array

my_array.push("hair") 

puts my_array.inspect() # The inspect() method is called on the array object and it is printed

A class can be thought of as a factory that makes objects.

String and Array are examples of classes.

An object is an instance of a class. Objects have methods that can be called to make the object do stuff. For example, the "hello" string object has the upcase() method. When the upcase() method is called on "hello" (i.e. "hello".upcase()) the "hello" object knows to create another object "HELLO".

"blah" is an example of an object that is created from the String class.

["one", "two"] is an example of an object that is created from the Array class.

String.new("bob") will create the "bob" object. The syntax for creating an object from a class is: class name, followed by dot, followed by the new method and the string name as an argument.

Hash.new()

Creating a Hash object follows the same pattern: class name, followed by dot, followed by the new() method

This code raises an error. The push() method is defined for Array objects, but is not defined for String objects. There are some overlapping methods between classes (i.e. array objects and string objects both respond to the length() method), but other methods do not overlap.

String

The class() method returns the name of the class that created the object. The String class created the a_string object, so the class() method correctly returns String.

Array

an_array is an Array object that was created by the Array class. The class() method returns Array because the an_array object was created by the Array class.

fido = Animal.new()

To create an instance of the Animal class, we use the class name, followed by dot, followed by the new() method. fido is also referred to as an object or an animal object.

spot = Dog.new()
puts spot.speak()

After the spot object is created, the speak() method can be called.

puts Fish.general_overview()

Notice that class methods are called directly on the class itself. An instance of the Fish class (a fish object) does not need to be created to call the general_overview() method. The following code does not work because general_overview() cannot be called on an instance of the Fish class, it can only be called on the Fish class itself:

nemo = Fish.new
puts nemo.general_overview() # doesn't work

The new() method was called on the Person class with the argument "Fred". The new() method automatically calls the initialize() method and passes the "Fred" argument to the initialize() method. The body of the initialize() method sets @name = "Fred". @name is a variable, but is a special type of variable called an instance variable that is used to retain state of the object. The @name instance variable can be used by the instance methods in the Person class, which is incredibly useful.

The return_lions_name() method simply returns the value that is stored in the @name instance variable. The @name instance variable is accessible by all instance methods in the Lion class and return_lions_name() is an instance method of the Lion class. An instance method that returns the value of the @name instance method is typically called name(), so here is how the class looks when following Ruby conventions:

class Lion
  def initialize(name)
    @name = name
  end

  def name
    return(@name)
  end
end