Ruby多态 #

class Duck
  def quack
    "Quack!"
  end
end

class Person
  def quack
    "I'm pretending to be a duck!"
  end
end

def make_it_quack(duck)
  duck.quack
end

make_it_quack(Duck.new)
make_it_quack(Person.new)

def process_wrong(obj)
  raise TypeError unless obj.is_a?(String)
  obj.upcase
end

def process_right(obj)
  obj.upcase
end

process_right("hello")
process_right(:hello)

def safe_quack(obj)
  if obj.respond_to?(:quack)
    obj.quack
  else
    "Cannot quack"
  end
end

class Animal
  def speak
    "Some sound"
  end
end

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

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

def make_sound(animal)
  animal.speak
end

make_sound(Dog.new)
make_sound(Cat.new)

animals = [Dog.new, Cat.new, Animal.new]
animals.map(&:speak)

module Drawable
  def draw
    raise NotImplementedError
  end
end

class Circle
  include Drawable

  def draw
    "Drawing circle"
  end
end

class Square
  include Drawable

  def draw
    "Drawing square"
  end
end

def render(drawable)
  drawable.draw
end

class Shape
  def area
    raise NotImplementedError
  end

  def perimeter
    raise NotImplementedError
  end
end

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

  def area
    @width * @height
  end

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

class PaymentProcessor
  def initialize(strategy)
    @strategy = strategy
  end

  def process(amount)
    @strategy.pay(amount)
  end
end

class CreditCardPayment
  def pay(amount)
    "Paid #{amount} via Credit Card"
  end
end

class PayPalPayment
  def pay(amount)
    "Paid #{amount} via PayPal"
  end
end

processor = PaymentProcessor.new(CreditCardPayment.new)
processor.process(100)

processor = PaymentProcessor.new(PayPalPayment.new)
processor.process(100)

class Calculator
  STRATEGIES = {
    add: ->(a, b) { a + b },
    subtract: ->(a, b) { a - b },
    multiply: ->(a, b) { a * b }
  }

  def calculate(operation, a, b)
    STRATEGIES[operation].call(a, b)
  end
end

calc = Calculator.new
calc.calculate(:add, 5, 3)
calc.calculate(:multiply, 5, 3)

class FileHandler
  def initialize(parser)
    @parser = parser
  end

  def process(file)
    data = read(file)
    @parser.parse(data)
  end

  private

  def read(file)
    File.read(file)
  end
end

class JSONParser
  def parse(data)
    JSON.parse(data)
  end
end

class XMLParser
  def parse(data)
    Nokogiri::XML(data)
  end
end

class CSVParser
  def parse(data)
    CSV.parse(data)
  end
end

class Notifier
  def initialize(channels)
    @channels = channels
  end

  def notify(message)
    @channels.each { |channel| channel.send(message) }
  end
end

class EmailChannel
  def send(message)
    puts "Email: #{message}"
  end
end

class SMSChannel
  def send(message)
    puts "SMS: #{message}"
  end
end

class PushChannel
  def send(message)
    puts "Push: #{message}"
  end
end

notifier = Notifier.new([EmailChannel.new, SMSChannel.new, PushChannel.new])
notifier.notify("Hello!")

class Sorter
  def initialize(strategy)
    @strategy = strategy
  end

  def sort(items)
    items.sort(&@strategy)
  end
end

by_name = Sorter.new(->(a, b) { a[:name] <=> b[:name] })
by_age = Sorter.new(->(a, b) { a[:age] <=> b[:age] })

people = [
  { name: "Bob", age: 30 },
  { name: "Alice", age: 25 },
  { name: "Charlie", age: 35 }
]

by_name.sort(people)
by_age.sort(people)

class DataExporter
  def initialize(formatter)
    @formatter = formatter
  end

  def export(data)
    @formatter.format(data)
  end
end

class JSONFormatter
  def format(data)
    JSON.generate(data)
  end
end

class CSVFormatter
  def format(data)
    data.map(&:to_csv).join("\n")
  end
end

class XMLFormatter
  def format(data)
    data.to_xml
  end
end

def process_wrong(obj)
  raise TypeError unless obj.is_a?(MyClass)
  obj.do_something
end

def process_right(obj)
  obj.do_something
end

def safe_process(obj)
  if obj.respond_to?(:required_method)
    obj.required_method
  else
    handle_missing_method(obj)
  end
end

class ReportGenerator
  def initialize(formatter, exporter)
    @formatter = formatter
    @exporter = exporter
  end

  def generate(data)
    formatted = @formatter.format(data)
    @exporter.export(formatted)
  end
end