and other languages…

 Get out a piece of paper  You’ll be tracing some code (quick exercises) as we go along

 May create subclasses (inheritance)  May include/inherit methods from modules (mix-ins)  Clients of class may also extend: Classes are open; any program can add a method Can add a singleton method to an individual object Modules covered next lecture

 Object is the superclass if none specified  Every class has a single superclass  May have multiple subclasses – a hierarchy  Syntax: class Student < Person End  BasicObject is parent of Object Can create completely separate hierarchy (e.g., BasicObject doesn’t include Kernel… so puts etc.) Few methods, useful for wrapper classes

 We know: Every Ruby object has a set of instance variables These are not defined by the class! Instance variables are created when a value is assigned  But instance variables may be created by other methods! (Since methods are inherited, may still appear to inherit variables… but may not!)  Therefore, instance variables have nothing to do with inheritance.  BUT, if all variables are defined in initialize, inheritance appears to work as expected What are some pros and cons? What about “shadowing”? On your paper: write a few lines of code to show shadowing in Java.

class Person def = name puts "initializing" end class Student < Person def to_s puts "Name: end s = Student.new("Cyndi") puts s  is not inherited  BUT, initialize is called, is created for the Student object  It appears that the variable is inherited  An instance variable created in a parent method that is not called by the child will not exist

class Person def = name puts "initializing" end def = end def lets () puts " ing end class Student < Person def to_s puts "Name: end End p = Person.new("Peter") s.edu") s = Student.new("Cyndi") p.lets s.lets But we can effectively treat them as if they are – by calling the methods TRACE

 Can override methods  Methods are bound dynamically (when executed) not statically (when parsed)  Methods like to_s and initialize are automatically inherited  Caution: if you don’t know all methods of a class you’re subclassing, you may override a private method accidentally!  Caution: class methods can be overridden, so it’s best to invoke class method with name of class that defines it. Compare to Java… what is initialize? Is it inherited?

class Person def = name end def greeting puts "Hi, my name is end class Student < Person def greeting puts "Hi, I'm a student and my name is end me = Person.new("Cyndi") me.greeting you = Student.new("Suzie") you.greeting TRACE

 public. methods are public by default. initialize is implicitly private (called by new)  private. only visible to other methods of the class (or subclass) implicitly invoked on self (but can’t write self.fn)  protected like private, but can be invoked on any instance of the class (e.g., if pass in parameter… allows objects of same type to share state) used infrequently  Applies only to methods!  Variables are automatically encapsulated (private)  Constants are public Compare to Java/C++

class X # public methods def fn #stuff end protected :fn def helper #stuff end private :helper end  can override visibility, e.g., private_class_method :new  private and protected guard against inadvertent use – BUT, with metaprogramming it’s possible to invoke these methods. Compare to Java/C++

class Person def = name puts "initializing" end def = end def lets () puts " ing end private :lets end p = Person.new("Peter") p.lets  Can also put private keyword before function definitions. Will apply to multiple functions.

class AbstractGreeter def greet puts "#{greeting} #{who}" end def say_hi puts "hi" end class WorldGreeter < AbstractGreeter def greeting; "Hello"; end def who; "World"; end end WorldGreeter.new.greet # AbstractGreeter.new.greet (error!) AbstractGreeter.new.say_hi concrete class: defines all abstract methods of ancesters abstract methods TRACE

class Person def = name end def long_greeting puts "Hi, my name is end class Student < Person def initialize(name, major) super(name) # could do just = major end def long_greeting super puts "I am studying end me = Person.new("Cyndi") me.long_greeting you = Student.new("Suzie", "CS") you.long_greeting super is a little different from Java – how? TRACE

 When did we use static (class) variables in Java/C++?  We’ll use class variables in Ruby for similar purposes. But syntax is different.

class Person def = name = 12 end def show puts "Person: end class Student < Person def make_something = 15 end def show puts "Student: and end me = Person.new("Cyndi") you = Student.new("Suzie") # creates class variable something you.make_something you.show who = Student.new("Joe") # both Students can access something who.show # parent cannot access something # me.show # error

 540/difference-between-class-variables- and-class-instance-variables 540/difference-between-class-variables- and-class-instance-variables  rstanding-class-instance-variables-in- ruby rstanding-class-instance-variables-in- ruby Explore on your own