Object Oriented Programming

• I assume everyone is familiar with it
• What are the characteristics of OOP?

Words used in OOP

• Classes
• Methods
• Instance variables
• Class/static variables
• Inheritance
• Composition
• Abstraction

Benefits of OOP

• Polymorphism
• Inheritance
• Abstraction
• Dynamic Dispatch

Non-exclusive benefits

• Static typing
• Code reuse
• Design patterns
• Encapsulation

Instance variable access

• Need to define getters and setters for instance variables

class Pokemon
  ...
  def health
    @health
  end

  def health=(value)
    @health = value
  end
end

pikachu.health = 400
puts pikachu.health

attr_accessor

• Helper methods for defining getter and setter methods
• attr_reader defines getters
• attr_writer defines setters
• attr_accessor defines both

class Pokemon
  attr_accessor :health, :trainer, :level
  ...
end

OOP done right

• Everything in Ruby is an object
• Yes, everything
• We have seen the times method defined on numbers

Literals

• Integer literals are Fixnums
• String literals are Strings

Class methods

• Since each class is an object, classes can have methods defined on them
• We have already seen the Class#new method

class Pokemon
  def self.known?(species)
    ...
  end
end

Pokemon.known? :pikachu

As a side note, Class not only has #new defined but ::new as well

my_class = Class.new do
  def foo
    "bar"
  end

  ...
end

Class variables

• Class variables start with @@
• Class variables are accessible from both class and instances

Inheritance

• Rails does not support multiple inheritance
• Classes inherit from Object by default
• superclass method returns parent class

class Pikachu < Pokemon
  ...
end

Abstract classes

• Classes do not need to be declared as abstract
• They can simply make use of methods assumed to be defined in child classes
• If you call the abstract method on the parent class, you will get an Exception

class Pokemon
  def initialize
    @health = initial_health
  end
end

class Pikachu < Pokemon
  def initial_health
    200 * level
  end
end

Interfaces

• What about interfaces? Don’t we need them?
• Nope, there is no static type checking
• Interfaces are used to specify which objects have a certain method defined on them

Duck typing

• In Ruby, we assume that if a method is implemented on an object, then it does what we want
• If it quacks like a duck, it might as well be a duck

collection = ...
collection.each do |element|
  # We don't know what type of collection we are dealing with
  # But we don't care because we assume #each will iterate over the elements
  ...
end

Code reuse

• What are our options for code reuse between classes?
• Inheritance and composition
• Single inheritance can limit code reuse
• Interfaces (in Java) do not solve this problem

An example

• Think about all iterable collections
• As seen before, we will assume any object with the #each method defined is iterable
• Every iterable collection should have map, filter, and reduce defined on them

class Iterable

  # Abstract #each method

  def map
    results = []
    self.each do |element|
      results << yield element
    end
    results
  end

  def filter
    results = []
    self.each do |element|
      results << element if yield element
    end
    results
  end

  def reduce(initial)
    self.each do |element|
      initial = yield initial, element
    end
    initial
  end
end

Despite being correct, there is no good way to reuse this functionality in classes that have a more logical parent class

Modules

• Let’s define this functionality in a module instead of a class
• Modules are not directly instantiable

module Enumerable
  def map
    ...
  end

  def filter
    ...
  end

  def reduce
    ...
  end
end

Modules

• Let’s include the module in a class with each defined
• Modules used in this way are called mixins

class CollectionOfSomeSort
  include Enumerable

  def each
    ...
  end
end

collection = CollectionOfSomeSort.new
collection.map { |element| [element, element] }

Reopening Classes

• We want a utility to turn the singular form of a word into the plural form
• This is used everywhere in Rails
• What are our options?
  • We can make a StringUtils class
  • But we would really just love if String#pluralize was defined

Reopening Classes

Well, we can do just that

class String
  def pluralize
    if self =~ /s$/
      self
    else
      self + "s"
    end
  end
end

Use this only if you have a very good reason