Ruby Language
계승

통사론

• class SubClass <SuperClass

상속을 사용하도록 기존 클래스 리팩토링

Cat 과 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

eat 방법은이 두 클래스에서 똑같습니다. 이 방법이 효과가 있지만 유지하기는 어렵습니다. 같은 eat 방법으로 더 많은 동물이 있으면 문제는 더욱 악화 될 것입니다. 상속은이 문제를 해결할 수 있습니다.

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

우리는 새로운 클래스 Animal 을 만들었고 우리의 eat 방법을 그 클래스로 옮겼습니다. 그런 다음 Cat 과 Dog 를이 새로운 공통 수퍼 클래스에서 상속받습니다. 이렇게하면 반복 코드가 필요하지 않습니다.

다중 상속

다중 상속은 한 클래스가 여러 클래스 (즉, 둘 이상의 부모)로부터 상속받을 수있게 해주는 기능입니다. Ruby는 다중 상속을 지원하지 않습니다. 단일 상속만을 지원합니다 (즉, 클래스는 단 하나의 부모 만 가질 수 있습니다). 그러나 Composition 을 사용하여 모듈을 사용하여보다 복잡한 클래스를 작성할 수 있습니다.

서브 클래스

상속을 통해 클래스는 기존 클래스를 기반으로 특정 동작을 정의 할 수 있습니다.

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!'

이 예에서 :

• Dog 는 Animal 에서 상속 받아 Subclass로 만듭니다.
• Dog 는 say_hello 와 eat 메소드를 Animal 에서 얻습니다.
• Dog 는 다른 기능으로 say_hello 메소드를 대체합니다.

믹스 인

Mixins 는 다중 상속과 비슷한 것을 성취 할 수있는 아름다운 방법입니다. 이 클래스를 사용하면 모듈에서 정의 된 메서드를 상속하거나 오히려 클래스에 포함 할 수 있습니다. 이러한 메소드는 인스턴스 또는 클래스 메소드로 포함될 수 있습니다. 아래의 예는이 디자인을 보여줍니다.

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"

상속 된 것은 무엇입니까?

메소드는 상속됩니다.

class A
  def boo; p 'boo' end
end

class B < A; end

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

클래스 메소드는 상속됩니다.

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

class B < A; end

p B.boo # => 'boo'

상수는 상속됩니다.

class A
  WOO = 1
end

class B < A; end

p B::WOO # => 1

그러나 무시할 수 있습니다.

class B
  WOO = WOO + 1
end

p B::WOO # => 2

인스턴스 변수는 상속됩니다.

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

class B < A; end

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

super 를 호출하지 않고 인스턴스 변수를 초기화하는 메소드를 오버라이드하면주의해야합니다. 위에서 계속 :

class C < A
  def initialize; end
 end

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

클래스 인스턴스 변수는 상속되지 않습니다.

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

클래스 변수는 실제로 상속되지 않습니다.

기본 클래스와 모든 하위 클래스가 1 개의 변수로 공유됩니다.

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

class B < A;end

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

그래서 위에서 계속 :

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

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