[GPT가 알려주는] SOLID원칙

SOLID 원칙은 객체지향 설계에서 유지보수성과 확장성을 높이기 위한 5가지 원칙을 말합니다. 각 원칙은 클래스, 모듈, 함수 등을 어떻게 설계해야 하는지를 안내해줍니다.

---

✅ 1. SRP (Single Responsibility Principle) - 단일 책임 원칙

• 한 클래스는 하나의 책임만 가져야 한다.
• 즉, 클래스는 하나의 변화 이유만 가져야 한다.
• 📌 기능 A와 B를 한 클래스에 넣으면, A 변경이 B에 영향을 줄 수 있음.

// 위반 예시
class Report {
    void generate() {}
    void print() {}  // 출력 로직도 포함 → SRP 위반
}

// 개선
class ReportGenerator {
    void generate() {}
}

class ReportPrinter {
    void print() {}
}

 

 

✅ 2. OCP (Open/Closed Principle) - 개방/폐쇄 원칙

• 확장에는 열려 있어야 하고, 수정에는 닫혀 있어야 한다.
• 기존 코드를 수정하지 않고 새로운 기능을 확장할 수 있어야 함.

// 위반 예시
class Discount {
    double getDiscount(String userType) {
        if (userType.equals("VIP")) return 0.2;
        else return 0.1;
    }
}

// 개선 (확장 가능)
interface DiscountPolicy {
    double getDiscount();
}

class VIPDiscount implements DiscountPolicy {
    public double getDiscount() { return 0.2; }
}

class RegularDiscount implements DiscountPolicy {
    public double getDiscount() { return 0.1; }
}

 

 

✅ 3. LSP (Liskov Substitution Principle) - 리스코프 치환 원칙

• 자식 클래스는 부모 클래스의 역할을 대체할 수 있어야 한다.
• 부모 타입으로 자식을 써도 기대한 기능이 유지되어야 한다.

// 위반 예시
class Bird {
    void fly() {}
}

class Penguin extends Bird {
    void fly() { throw new UnsupportedOperationException(); } // 펭귄은 못 날아
}

// 개선
interface Bird {}
interface Flyable {
    void fly();
}

class Sparrow implements Bird, Flyable {
    public void fly() { System.out.println("날아요"); }
}

class Penguin implements Bird {}  // Flyable을 구현하지 않음

 

 

✅ 4. ISP (Interface Segregation Principle) - 인터페이스 분리 원칙

• 클라이언트는 사용하지 않는 인터페이스에 의존하지 않아야 한다.
• 즉, 하나의 커다란 인터페이스보다, 작고 구체적인 인터페이스 여러 개로 나누어야 한다.

// 위반 예시
interface Worker {
    void work();
    void eat();
}

class Robot implements Worker {
    public void work() {}
    public void eat() {} // 로봇은 먹지 않음 → 위반
}

// 개선
interface Workable {
    void work();
}
interface Eatable {
    void eat();
}

class Robot implements Workable {
    public void work() {}
}

 

 

✅ 5. DIP (Dependency Inversion Principle) - 의존 역전 원칙

• 고수준 모듈(정책)은 저수준 모듈(구현)에 의존하면 안 된다.
• 대신 추상화(인터페이스)에 의존해야 한다.

// 위반 예시
class Light {
    void turnOn() {}
    void turnOff() {}
}

class Switch {
    private Light light = new Light(); // 구체 클래스에 직접 의존
    void operate() { light.turnOn(); }
}

// 개선
interface Switchable {
    void turnOn();
    void turnOff();
}

class Light implements Switchable {
    public void turnOn() {}
    public void turnOff() {}
}

class Switch {
    private Switchable device;
    public Switch(Switchable device) {
        this.device = device;
    }
    void operate() {
        device.turnOn();
    }
}

 

 

 

• SRP(단일 책임 원칙): 하나의 클래스는 하나의 책임만 가져야 하며, 변경 이유는 하나여야 한다.
• OCP(개방/폐쇄 원칙): 코드는 확장에는 열려 있어야 하고, 기존 코드를 수정하지 않고 기능을 추가할 수 있어야 한다.
• LSP(리스코프 치환 원칙): 자식 클래스는 부모 클래스의 역할을 대체할 수 있어야 하며, 기능이 깨지지 않아야 한다.
• ISP(인터페이스 분리 원칙): 사용하지 않는 기능에 의존하지 않도록, 인터페이스는 작고 구체적으로 나누어야 한다.
• DIP(의존 역전 원칙): 고수준 모듈은 저수준 모듈에 의존하지 않고, 둘 다 추상화(인터페이스)에 의존해야 한다.