### 組合物件 vs 繼承
what’s the pros and cons between `Inheritance` and `Composition`?
---
### Simple example of composition: Has-A
- Car `has an engine`
- Car `has headlights`
---
### Simple example of composition: Has-A
```ruby
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
```ruby
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
```ruby
# 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
```ruby
# 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
```ruby
# 提供一個用來建立一系列產品的抽象型態(工廠)
# 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
```ruby
# 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)
```ruby
# 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
{"metaMigratedAt":"2023-06-17T22:57:23.083Z","metaMigratedFrom":"YAML","title":"Composition and Inheritance","breaks":true,"description":"View the slide with \"Slide Mode\".","contributors":"[{\"id\":\"55148774-a793-4ea6-a8ad-d47b88b811b2\",\"add\":9375,\"del\":1920}]"}