Simple example of composition: Has-A

• Car has an engine
• Car has headlights

Simple example of composition: Has-A

class Engine
  def start
    puts "Starting engine"
  end
end

class HeadLight
  def on
    puts "Turning on headlight"
  end
end

class Car
  def initialize
    @engine = Engine.new
    @headlight= HeadLight.new
  end

  def start_engine
    @engine.start
  end

  def turn_on_headlight
    @headlight.on
  end
end

car = Car.new

car.start_engine
# Starting engine

car.turn_on_headlight
# Turning on headlight

Composition: create objects that are made up of other objects

Calling the start_engine method on the car object triggers the start method of the Engine object and on method of HeadLight object it contains

Composition: create objects that are made up of other objects (delegation)

The Car class has a start_engine method that delegates the start method to the Engine object and a turn_on_headlight method that delegates the on method it contains.

Rewrite the same code using Inheritance 🤓

ChatGPT: Sure, here's an example of how you could use inheritance to achieve similar functionality

class Engine
  def start
    puts "Starting engine"
  end
end

class Car < Engine
  def start_engine
    start
  end
end

car = Car.new
car.start_engine
# Starting engine

So strange!!! 😅

• In the real life case, Car is not a subclass of Engine

We need ANOTHER example of Inheritance 🤨

Simple example of inheritance: Is-A

• AutomaticCar is a Car
• ManualCar is a Car

We need another example of Inheritance

# Abstract car interface
class Car
  def start
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end
end

# Concrete car implementation 1
class AutomaticCar < Car
  def start
    puts "=== 啟動 自排車 ==="
    puts "右腳踩著煞車"
    puts "確認排檔桿的位置在「P」"
    puts "插入鑰匙在「LOCK」的位置"
    puts "將鑰匙先轉到「ACC」，再轉到「ON」"
    puts "轉到「START」，啟動馬達運轉，自排車引擎發動。\n\n"
  end
end

# Concrete car implementation 2
class ManualCar < Car
  def start
    puts "=== 啟動 手排車 ==="
    puts "確認手煞車已經拉起"
    puts "用左腳將離合器踩到底"
    puts "將排檔桿移至「N」 空檔"
    puts "插入鑰匙在「LOCK」的位置"
    puts "將鑰匙先轉到「ACC」，再轉到「ON」"
    puts "轉到「START」，啟動馬達運轉，手排車引擎發動。\n\n"
  end
end

auto = AutomaticCar.new
auto.start
# puts "=== 啟動 自排車 ==="
# puts ...

manual = ManualCar.new
manual.start
# puts "=== 啟動 手排車 ==="
# puts ...

Inheritance: When subclass NOT implement start method

# Abstract car interface
class Car
  def start
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end
end

class ElectricCar < Car
end

electric = ElectricCar.new
electric.start
# NotImplementedError (ElectricCar has not implemented method 'start')

Add more complexity using composition (and inheritance) in Abstract Factory Method

• 抽象工廠

提供一個用來建立一系列產品的抽象型態(工廠)，讓子類別負責定義產品怎麼產生。
使用抽象工廠時必須先實例化，再傳入針對抽象型態撰寫的程式碼

An example of Abstract Factory pattern (factory interface)

• Use inheritance to create XXX Factory subclass

# 提供一個用來建立一系列產品的抽象型態(工廠)

# Abstract factory interface
class CarFactory
  def create_car
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end
end

# 讓子類別負責定義產品怎麼產生

# Concrete factory implementation 1
class TeslaCarFactory < CarFactory
  def create_car
    TeslaCar.new
  end
end

# Concrete factory implementation 2
class ToyotaCarFactory < CarFactory
  def create_car
    ToyotaCar.new
  end
end

An example of Abstract Factory pattern (product interface)

• Use inheritance to create XXX Car subclass

# Abstract product interface
class Car
  def create
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end
end

# Concrete product implementation 1
class TeslaCar < Car
  def start
    puts "=== Tesla發動方式 ==="
    puts "踩下煞車踏板"
    puts "電腦螢幕選取駕駛模式\n\n"
  end
end

# Concrete product implementation 2
class ToyotaCar < Car
  def start
    puts "=== Toyota發動方式 ==="
    puts "踩下煞車踏板"
    puts "轉動鑰匙\n\n"
  end
end

An example of Abstract Factory pattern (all codes)

# Abstract factory interface
class CarFactory
  def create_car
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end
end

# Concrete factory implementation 1
class TeslaCarFactory < CarFactory
  def create_car
    TeslaCar.new
  end
end

# Concrete factory implementation 2
class ToyotaFactory < CarFactory
  def create_car
    ToyotaCar.new
  end
end

# Abstract product interface
class Car
  def create
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end
end

# Concrete product implementation 1
class TeslaCar < Car
  def start
    puts "=== Tesla 啟動方式 ==="
    puts "踩下煞車踏板"
    puts "電腦螢幕選取駕駛模式\n\n"
  end
end

# Concrete product implementation 2
class ToyotaCar < Car
  def start
    puts "=== Toyota 啟動方式 ==="
    puts "踩下煞車踏板"
    puts "轉動鑰匙\n\n"
  end
end

# Here is the Composition part
# 使用抽象工廠時必須先實例化，再傳入針對抽象型態撰寫的程式碼

# Create Car from factory and Start
class CarModel
  def initialize(factory)
    @factory = factory
  end

  def start
    car = @factory.create_car
    car.start
  end
end

tesla_car = CarModel.new(TeslaCarFactory.new)
toyota_car = CarModel.new(ToyotaFactory.new)

tesla_car.start
# puts "=== Tesla 啟動方式 ==="
# puts "踩下煞車踏板"
# puts "電腦螢幕選取駕駛模式\n\n"

toyota_car.start
# puts "=== Toyota 啟動方式 ==="
# puts "踩下煞車踏板"
# puts "轉動鑰匙\n\n"

Summery: 組合物件 vs 繼承 😃

Inheritance is the process of creating new classes from existing classes by inheriting their properties and methods. The new classes are called subclasses, and the existing classes are called superclasses. Inheritance allows subclasses to reuse code from their superclasses and also to add new functionality.

Inheritance 👨‍👩‍👦

Pros:

• Enables code reuse
• Provides a natural way to model hierarchical relationships between classes

Cons:

• Can lead to tight coupling between classes
• Can make code harder to understand and maintain

Composition 🛞 -> 🚗

Composition is the process of creating complex objects by combining simpler objects. Instead of inheriting properties and methods, an object is composed of other objects that it uses to perform its tasks. Composition allows objects to be more flexible and modular.

Composition 🛞 -> 🚗

Pros:

• Allows for greater flexibility and modularity
• Does not lead to tight coupling between objects

Cons:

• Can require more boilerplate code to set up the composition
• Can be more difficult to understand and use than inheritance

Summery: 組合物件 vs 繼承 😃

It is recommended to use composition over inheritance when possible.

Inheritance can be useful for modeling hierarchical relationships between classes, but it can also lead to tight coupling and make code harder to understand and maintain.

Composition, on the other hand, allows for greater flexibility and modularity, which can make code easier to understand and maintain in the long run.

Ref

https://github.com/maaslalani/slides