내가 볼려고 만든 SOLID정리

1. 단일 책임 원칙 (Single Reponsibility Principle): 한 가지 일에만 집중!

한 가지 클래스는 한 가지 일만 해야한다. 이는 클래스를 더 쉽게 이해할 수 있도록 도와준다.

• 예를 들어, 만약 당신이 과일 판매상이라면 과일을 파는 일에만 집중해야 한다. (예를 들어 의류, 음료, 과자 판매 등등에는 관여 X)

// 단일 책임 원칙
class FruitSeller{
	func sellFruit(){
    	// 과일을 판매하는 로직
    }
}
    
class PaymentProcessor{
	func processPayment{
    	// 결제를 처리하는 로직
    }
}

 

2. 개방-폐쇠 원칙 (Open/Closed Principle): 바꿀 수 있지만, 바꾸지 않아!

 클래스나 모듈은 확장에는 열려 있어야 하지만, 수정에는 닫혀 있어야 한다. 즉,

새로운 기능을 추가할 수 있지만, 기존의 코드는 수정하지 않아야 한다.

 

• 예를 들어, 만약 당신이 로봇 장난감을 만든다면, 장난감이 다양한 동작을 할 수 있게 만들되, 그 기능이 바뀌어도 장난감 자체는 바뀌지 않아야 한다. 즉, 새로운 동작을 추가할 수는 있지만, 기존의 기능을 수정하지는 않아야 한다.

// 개방-폐쇄 원칙 (Open/Closed Principle)
protocol Shap {
	func draw()
}

class Circle: Shape{
	func draw(){
    	// 원을 그리는 로직
    }
}

class Rectangle: Shape{
	func draw() {
       // 사각형을 그리는 로직
    }
}

 

3. 리스코프 치환 원칙 (Liskov Substitution Principle): 누구나 대체할 수 있어!

 상속 받은 클래스는 부모 클래스의 역할을 완전히 대체할 수 있어야 한다.

이것은 다형성을 유지하고, 부모 클래스와 자식 클래스 간의 호환성을 보장한다.

• 예를 들어, 만약 당신이 과일 상자를 만든다면, 그 상자에는 어떤 과일이 들어가든 상자의 크기나 모양 등이 바뀌지 않아야 한다. 즉, 어떤 종류의 과일이든 상자에 넣을 수 있어야 함.

// 리스코프 치환 원칙

class Rectangle {
	var width: Double
	var height: Double
    
    init(width: Double, height: Double) {
    	self.width = width
        self.height = height
    }
    
    func area() -> Double {
    	return width * height
    }
}

class Square: Rectangle{
	override init(width: Double, height: Double){
    	super.init(width: width, height: width)
    }
}

 

4. 인터페이스 분리 원칙 (Interface Segregation Principle): 크게 나눠서 필요한 것만 사용해!

 클라이언트는 자신이 사용하지 않는 메서드에 의존해서는 안 된다.

즉, 사용하지 않은 기능에 대한 의존성을 제기하여 인터페이스를 작고 간결하게 유지해야 한다.

• 예를 들어, 만약 당신이 게임을 만든다면, 각 캐릭터에 맞는 인터페이스를 만들어서 그들이 필요로 하는 것만 사용해야 한다. 모든 캐릭터가 같은 기능을 가져야 하는것은 아니니까.

protocol Login {
    func login()
}

protocol Register {
    func register()
}

protocol ProfileEditor {
    func editProfile()
}

class UserManager: Login, Register, ProfileEditor {
    func login() {
        // 로그인 기능 구현
    }
    
    func register() {
        // 회원가입 기능 구현
    }
    
    func editProfile() {
        // 프로필 수정 기능 구현
    }
}

 

5. 의존 역전 원칙 (Dependency Inversion Principle): 누구든지 의존할 수 있어!

 고수준 모듈은 저수준 모듈에 의존해서는 안 되며

양쪽 모두 추상화에 의존해야 한다. 즉, 구체적인 구현이 아닌 추상화 된 인터페이스에 의존해야 한다.

protocol ElectronicDevice {
    func turnOn()
}

class TV: ElectronicDevice {
    func turnOn() {
        // TV를 켜는 로직
    }
}

class RemoteControl {
    let device: ElectronicDevice
    
    init(device: ElectronicDevice) {
        self.device = device
    }
    
    func turnOnDevice() {
        device.turnOn()
    }
}

 

 ++ 내용 추가예정