Ruby Language
Erbe

Syntax

• Klasse SubClass <SuperClass

Umgestaltung vorhandener Klassen zur Verwendung von Vererbung

Nehmen wir an, wir haben zwei Klassen: Cat und Dog .

class Cat
  def eat
    die unless has_food?
    self.food_amount -= 1
    self.hungry = false
  end
  def sound
    puts "Meow"
  end
end

class Dog
  def eat
    die unless has_food?
    self.food_amount -= 1
    self.hungry = false
  end
  def sound
    puts "Woof"
  end
end

Die eat ist in diesen beiden Klassen genau gleich. Während dies funktioniert, ist es schwer zu warten. Das Problem wird noch schlimmer, wenn es mehr Tiere mit der gleichen eat . Vererbung kann dieses Problem lösen.

class Animal
  def eat
    die unless has_food?
    self.food_amount -= 1
    self.hungry = false
  end
  # No sound method
end

class Cat < Animal
  def sound
    puts "Meow"
  end
end

class Dog < Animal
  def sound
    puts "Woof"
  end
end

Wir haben eine neue Klasse, Animal , erstellt und unsere eat in diese Klasse verschoben. Dann ließen wir Cat und Dog von dieser neuen gemeinsamen Oberklasse erben. Dadurch entfällt die Notwendigkeit, Code zu wiederholen

Mehrfachvererbung

Mehrfachvererbung ist eine Funktion, mit der eine Klasse von mehreren Klassen erben kann (dh mehr als eine übergeordnete Klasse). Ruby unterstützt keine Mehrfachvererbung. Es unterstützt nur die Einzelvererbung (dh die Klasse kann nur ein übergeordnetes Element haben). Sie können die Komposition jedoch verwenden , um mithilfe von Modulen komplexere Klassen zu erstellen .

Unterklassen

Vererbung ermöglicht es Klassen, ein bestimmtes Verhalten basierend auf einer vorhandenen Klasse zu definieren.

class Animal
  def say_hello
    'Meep!'
  end

  def eat
    'Yumm!'
  end
end

class Dog < Animal
  def say_hello
    'Woof!'
  end
end

spot = Dog.new
spot.say_hello # 'Woof!'
spot.eat       # 'Yumm!'

In diesem Beispiel:

• Dog erbt von Animal und macht es zu einer Unterklasse .
• Dog erhält sowohl die say_hello als auch die eat Methode von Animal .
• Dog überschreibt die Methode say_hello mit unterschiedlicher Funktionalität.

Mixins

Mixins sind eine schöne Möglichkeit, etwas zu erreichen, das der Mehrfachvererbung ähnlich ist. Dadurch können in einem Modul definierte Methoden in eine Klasse übernommen werden. Diese Methoden können entweder als Instanz- oder Klassenmethoden enthalten sein. Das folgende Beispiel zeigt diesen Entwurf.

module SampleModule

  def self.included(base)
    base.extend ClassMethods
  end

  module ClassMethods

    def method_static
      puts "This is a static method"
    end

  end

  def insta_method
    puts "This is an instance method"
  end

end

class SampleClass
  include SampleModule
end

sc = SampleClass.new

sc.insta_method

prints "This is an instance method"

sc.class.method_static

prints "This is a static method"

Was ist vererbt?

Methoden werden vererbt

class A
  def boo; p 'boo' end
end

class B < A; end

b = B.new
b.boo # => 'boo'

Klassenmethoden werden geerbt

class A
  def self.boo; p 'boo' end
end

class B < A; end

p B.boo # => 'boo'

Konstanten werden vererbt

class A
  WOO = 1
end

class B < A; end

p B::WOO # => 1

Aber Achtung, sie können außer Kraft gesetzt werden:

class B
  WOO = WOO + 1
end

p B::WOO # => 2

Instanzvariablen werden vererbt:

class A
  attr_accessor :ho
  def initialize
    @ho = 'haha'
  end
end

class B < A; end

b = B.new
p b.ho # => 'haha'

Achtung, wenn Sie die Methoden überschreiben, die Instanzvariablen initialisieren, ohne super aufzurufen, sind sie gleich Null. Weiter von oben:

class C < A
  def initialize; end
 end

c = C.new
p c.ho    # => nil

Klasseninstanzvariablen werden nicht vererbt:

class A
    @foo = 'foo'
    class << self
        attr_accessor :foo
    end
end

class B < A; end

p B.foo # => nil

# The accessor is inherited, since it is a class method
#
B.foo = 'fob' # possible

Klassenvariablen werden nicht wirklich vererbt

Sie werden von der Basisklasse und allen Unterklassen als 1 Variable gemeinsam genutzt:

class A
    @@foo = 0
    def initialize
        @@foo  += 1 
        p @@foo
    end
end

class B < A;end

a = A.new # => 1
b = B.new # => 2

Also weiter von oben:

class C < A
  def initialize
    @@foo = -10
    p @@foo
  end
end

a = C.new # => -10
b = B.new # => -9