같은 interface 여도 다른 기능, 동작이 가능 하도록 함

Protection Proxy

protocol Vehicle
{
    func drive()
}

class Car
{
    func drive()
    {
        print("Car being driven")
    }
}

class CarProxy: Vehicle
{
    private let car = Car()
    private let driver: Driver
    
    init(driver: Driver)
    {
        self.driver = driver
    }
    
    func drive()
    {
        if driver.age >= 18
        {
            car.drive()
        }
        else
        {
            print("Driver too young")
        }
        
    }
}


class Driver
{
    var age : Int
    init(age: Int)
    {
        self.age = age
    }
}


func main()
{
    let car: Vehicle = CarProxy(driver: Driver(age: 16))
    car.drive()
}

Property Proxy

class Property<T: Equatable>
{
    private var _value: T
    
    public var value: T
    {
        get { return _value }
        set (value)
        {
            if value == _value { return }
            print("Setting value to \(value)")
            _value = value
        }
    }
    
    init(_ value: T)
    {
        self._value = value
    }
}

extension Property: Equatable {}

func ==<T>(lhs: Property<T>, rhs: Property<T>) -> Bool
{
    return lhs.value == rhs.value
}


class Creature
{
    private let _agility = Property<Int>(0)
    
    var agility: Int
    {
        get { return _agility.value }
        set(value) { _agility.value = value }
    }
}


func main()
{
    let c = Creature()
    c.agility = 10
    
    print(c.agility)
}

정리

관련 있는 기능들을 가져와서 재정의 하는 방식으로 진행 됨