[Design Pattern]Bridge Pattern

Bridge Pattern (Structural Design Pattern)

브릿지 패턴이란?

기능과 구현을 분리하여 각각의 클래스로 만들어 구현하는 패턴이다.

기능 : Abstraction 
    => RefineAbstraction1
    => RefineAbstraction2

구현 : Implementor
    => ConcreteImplementor1
    => ConcreteImplementor2

Abstraction(기능)은 Implementor(구현)을 소유(사용)한다.

하지만, Abstraction(기능)은 Implementor(구현)에 대해 알지 못한다. 
                                        (독립되어 있음.)

브릿지 패턴의 구성요소

• Abstraction : 기능을 정의하는 인터페이스
• RefinedAbstraction : 기능을 정의하는 클래스
• Implementor : 구현을 정의하는 인터페이스
• ConcreteImplementor : 구현을 정의하는 클래스
• Client : 브릿지 패턴을 사용하는 클래스

브릿지 패턴의 예시

차를 만들어보려고하는데, 동력은 어떤걸 할지? 차의 종류는 어떤걸 할지 ?

자동차 클래스 (Abstraction)
    => 스포츠카 (RefinedAbstraction)
    => 세단 (RefinedAbstraction)

(추후 추가)=> 버스 (RefinedAbstraction)

동력 클래스 (Implementor)
    => 가솔린 (ConcreteImplementor)
    => 디젤 (ConcreteImplementor)


(추후 추가)=> 전기 (ConcreteImplementor)
자동차 클래스는 동력 클래스를 포함한다. 

하지만, 자동차 클래스는 동력 클래스에 대해 알지 못한다. 
                                        (독립되어 있음.)

브릿지 패턴 구현

# Implementor (Backend)
class Power:
    def engineStart(self):
        pass
    def powerUp(self):
        pass
    def powerDown(self):
        pass

# ConcreteImplementor
class Gasoline(Power):
    def __init__(self):
        self.energy = 0

    def engineStart(self):
        print("가솔린 엔진을 켭니다.")
        self.energy += 1

    def powerUp(self):
        print("가솔린 실린더 가동")
        self.energy += 9

    def powerDown(self):
        print("가솔린 실린더 정지")
        self.energy -= 10
        if self.energy <= 0:
            print("가솔린 엔진을 끕니다.")
            self.energy = 0

# ConcreteImplementor
class Diesel(Power):
    def __init__(self):
        self.energy = 0

    def engineStart(self):
        print("디젤 엔진을 켭니다.")
        self.energy = 1

    def powerUp(self):
        print("디젤 실린더 가동")
        self.energy += 5

    def powerDown(self):
        print("디젤 실린더 정지")
        self.energy -= 6
        if self.energy <= 0:
            print("디젤 엔진을 끕니다.")
            self.energy = 0


# Abstraction (UI)
class Car:
    def __init__(self, power: Power):
        self.power = power

    def accelerate(self):
        self.power.powerUp()

    def drive(self):
        if self.power.energy == 0:
            self.power.engineStart()
        self.power.powerUp()

    def stop(self):
        self.power.powerDown()

# RefinedAbstraction
class SportsCar(Car):
    def __init__(self, power):
        super().__init__(power)

    def accelerate(self):
        super().accelerate()

    def drive(self):
        super().drive()
        if type(self.power) == Gasoline:
            print("븡으으으ㅡㅇ잉으잉으잉~~!!!")
        elif type(self.power) == Diesel:
            print("쁘아아아ㅏ앙아아ㅏㅇ아ㅏ앙ㅇ!!!!!!!!!!!!!!!!!!!")
    def stop(self):
        super().stop()
        print("스포츠카 정지")

# RefinedAbstraction
class Sedan(Car):
    def __init__(self, power):
        super().__init__(power)

    def accelerate(self):
        super().accelerate()

    def drive(self):
        super().drive()
        if type(self.power) == Gasoline:
            print("부우웅~~~")
        elif type(self.power) == Diesel:
            print("드르엉부우웅~~~")

    def stop(self):
        return super().stop()

# Client
myBenz = SportsCar(Gasoline())
myBenz.drive()
myBenz.accelerate()

myBenz = SportsCar(Diesel())
myBenz.drive()
myBenz.accelerate()

yourTico = Sedan(Diesel())
yourTico.drive()
yourTico.accelerate()

yourTico = Sedan(Gasoline())
yourTico.drive()
yourTico.accelerate()