Inheritance

Every class except Object, the hierarchy root, inherits from another class (its superclass). If you don’t specify one it defaults to Reference for classes and Struct for structs.

A class inherits all instance variables and all instance and class methods of a superclass, including its constructors (new and initialize).

  1. class Person
  2.   def initialize(@name : String)
  3.   end
  5.   def greet
  6.     puts "Hi, I'm #{@name}"
  7.   end
  8. end
  10. class Employee < Person
  11. end
  13. employee = Employee.new "John"
  14. employee.greet # "Hi, I'm John"

If a class defines a new or initialize then its superclass constructors are not inherited:

  1. class Person
  2.   def initialize(@name : String)
  3.   end
  4. end
  6. class Employee < Person
  7.   def initialize(@name : String, @company_name : String)
  8.   end
  9. end
  11. Employee.new "John", "Acme" # OK
  12. Employee.new "Peter" # Error: wrong number of arguments
  13.                      # for 'Employee:Class#new' (1 for 2)

You can override methods in a derived class:

  1. class Person
  2.   def greet(msg)
  3.     puts "Hi, #{msg}"
  4.   end
  5. end
  7. class Employee < Person
  8.   def greet(msg)
  9.     puts "Hello, #{msg}"
  10.   end
  11. end
  13. p = Person.new
  14. p.greet "everyone" # "Hi, everyone"
  16. e = Employee.new
  17. e.greet "everyone" # "Hello, everyone"

Instead of overriding you can define specialized methods by using type restrictions:

  1. class Person
  2.   def greet(msg)
  3.     puts "Hi, #{msg}"
  4.   end
  5. end
  7. class Employee < Person
  8.   def greet(msg : Int32)
  9.     puts "Hi, this is a number: #{msg}"
  10.   end
  11. end
  13. e = Employee.new
  14. e.greet "everyone" # "Hi, everyone"
  16. e.greet 1 # "Hi, this is a number: 1"

super

You can invoke a superclass’ method using super:

  1. class Person
  2.   def greet(msg)
  3.     puts "Hello, #{msg}"
  4.   end
  5. end
  7. class Employee < Person
  8.   def greet(msg)
  9.     super # Same as: super(msg)
  10.     super("another message")
  11.   end
  12. end

Without arguments or parentheses, super receives the same arguments as the method’s arguments. Otherwise, it receives the arguments you pass to it.

Covariance and Contravariance

One place inheritance can get a little tricky is with arrays. We have to be careful when declaring an array of objects where inheritance is used. For example, consider the following

  1. class Foo
  2. end
  4. class Bar < Foo
  5. end
  7. foo_arr = [Bar.new] of Foo # => [#<Bar:0x10215bfe0>] : Array(Foo)
  8. bar_arr = [Bar.new] # => [#<Bar:0x10215bfd0>] : Array(Bar)
  9. bar_arr2 = [Foo.new] of Bar # compiler error

A Foo array can hold both Foo’s and Bar’s, but an array of Bar can only hold Bar and its subclasses.

One place this might trip you up is when automatic casting comes into play. For example, the following won’t work:

  1. class Foo
  2. end
  4. class Bar < Foo
  5. end
  7. class Test
  8.   @arr : Array(Foo)
  9.   def initialize
  10.     @arr = [Bar.new]
  11.   end
  12. end

we’ve declared @arr as type Array(Foo) so we may be tempted to think that we can start putting Bars in there. Not quite. In the initialize, the type of the [Bar.new] expression is Array(Bar), period. And Array(Bar) is not assignable to an Array(Foo) instance var.

What’s the right way to do this? Change the expression so that it is of the right type: Array(Foo) (see example above).

  1. class Foo
  2. end
  4. class Bar < Foo
  5. end
  7. class Test
  8.   @arr : Array(Foo)
  9.   def initialize
  10.     @arr = [Bar.new] of Foo
  11.   end
  12. end

This is just one type (Array) and one operation (assignment), the logic of the above will be applied differently for other types and assignments, in general Covariance and Contravariance is not fully supported.