Ruby继承 #

class Animal
  def initialize(name)
    @name = name
  end

  def speak
    "Some sound"
  end
end

class Dog < Animal
end

dog = Dog.new("Buddy")
dog.speak

class Animal
end

class Mammal < Animal
end

class Dog < Mammal
end

Dog.superclass
Dog.superclass.superclass
Dog.ancestors

class Animal
end

class Dog < Animal
end

dog = Dog.new

dog.is_a?(Dog)
dog.is_a?(Animal)
dog.is_a?(Object)
dog.kind_of?(Dog)

class Animal
  def speak
    "Some sound"
  end
end

class Dog < Animal
  def speak
    "Woof!"
  end
end

class Cat < Animal
  def speak
    "Meow!"
  end
end

Dog.new.speak
Cat.new.speak

class Animal
  def initialize(name)
    @name = name
  end

  def speak
    "#{@name} makes a sound"
  end
end

class Dog < Animal
  def initialize(name, breed)
    super(name)
    @breed = breed
  end

  def speak
    "#{super} - Woof!"
  end
end

dog = Dog.new("Buddy", "Golden Retriever")
dog.speak

class Parent
  def method(a, b)
    puts "Parent: a=#{a}, b=#{b}"
  end
end

class Child < Parent
  def method(a, b)
    super
    super(a, b)
    super(a)
  end
end

class Animal
  def move
    "Animal moves"
  end
end

class Mammal < Animal
  def move
    "Mammal moves"
  end
end

class Dog < Mammal
end

Dog.new.move

class Dog < Mammal
  def move
    "Dog moves"
  end
end

Dog.new.move

class Dynamic
  def method_missing(name, *args)
    if name.to_s.start_with?("find_by_")
      attribute = name.to_s.sub("find_by_", "")
      find_by(attribute, args.first)
    else
      super
    end
  end

  def respond_to_missing?(name, include_private = false)
    name.to_s.start_with?("find_by_") || super
  end

  private

  def find_by(attribute, value)
    puts "Finding by #{attribute}: #{value}"
  end
end

obj = Dynamic.new
obj.find_by_name("Ruby")
obj.respond_to?(:find_by_name)

class Animal
  def initialize(name)
    @name = name
  end
end

class Dog < Animal
end

dog = Dog.new("Buddy")

class Animal
  def initialize(name)
    @name = name
  end
end

class Dog < Animal
  def initialize(name, breed)
    super(name)
    @breed = breed
  end
end

dog = Dog.new("Buddy", "Golden Retriever")

class Animal
  def initialize(name)
    @name = name
  end

  def speak
    raise NotImplementedError, "Subclasses must implement speak"
  end
end

class Dog < Animal
  def speak
    "Woof!"
  end
end

Animal.new("Test").speak
Dog.new("Buddy").speak

module Speakable
  def speak
    raise NotImplementedError
  end
end

class Dog
  include Speakable

  def speak
    "Woof!"
  end
end

class Shape
  def initialize(color)
    @color = color
  end

  def area
    raise NotImplementedError
  end

  def perimeter
    raise NotImplementedError
  end

  def info
    "Color: #{@color}, Area: #{area}, Perimeter: #{perimeter}"
  end
end

class Rectangle < Shape
  def initialize(color, width, height)
    super(color)
    @width = width
    @height = height
  end

  def area
    @width * @height
  end

  def perimeter
    2 * (@width + @height)
  end
end

class Circle < Shape
  def initialize(color, radius)
    super(color)
    @radius = radius
  end

  def area
    Math::PI * @radius ** 2
  end

  def perimeter
    2 * Math::PI * @radius
  end
end

rect = Rectangle.new("red", 5, 3)
circle = Circle.new("blue", 2)

rect.info
circle.info

class Employee
  attr_reader :name, :id

  def initialize(name, id)
    @name = name
    @id = id
  end

  def calculate_pay
    raise NotImplementedError
  end

  def to_s
    "#{name} (#{id})"
  end
end

class SalariedEmployee < Employee
  def initialize(name, id, salary)
    super(name, id)
    @salary = salary
  end

  def calculate_pay
    @salary
  end
end

class HourlyEmployee < Employee
  def initialize(name, id, rate, hours)
    super(name, id)
    @rate = rate
    @hours = hours
  end

  def calculate_pay
    @rate * @hours
  end
end

salaried = SalariedEmployee.new("Alice", 1, 5000)
hourly = HourlyEmployee.new("Bob", 2, 50, 160)

salaried.calculate_pay
hourly.calculate_pay

class BaseModel
  def self.find(id)
    data = database_find(id)
    new(data) if data
  end

  def self.all
    database_all.map { |data| new(data) }
  end

  def initialize(attributes = {})
    attributes.each do |key, value|
      instance_variable_set("@#{key}", value)
    end
  end

  def save
    valid? && persist
  end

  def valid?
    true
  end

  private

  def persist
    raise NotImplementedError
  end

  def self.database_find(id)
  end

  def self.database_all
    []
  end
end

class Engine
  def start
    "Engine started"
  end
end

class Car
  def initialize
    @engine = Engine.new
  end

  def start
    @engine.start
  end
end

class Animal
end

class Mammal < Animal
end

class Carnivore < Mammal
end

class Dog < Carnivore
end

class Animal
end

class Dog < Animal
  include Carnivore
  include Mammal
end