💡 직무 면접에서 자주 나오는 SOLID 원칙

✅ SOLID 원칙이란?

객체 지향 프로그래밍은 소프트웨어 개발에서 널리 사용되는 패러다임 중 하나입니다. 이는 데이터와 그 데이터를 처리하는 메서드를 객체라는 단위로 묶어서 프로그래밍하는 방식을 말합니다.

객체 지향 프로그래밍의 핵심은 실제 세계의 사물을 모델링하여 소프트웨어 내에서 재현하는 데 있으며, 객체 지향 설계 원칙인 SOLID는 이러한 객체 지향 프로그래밍을 보다 효과적으로 수행하기 위한 지침을 제공합니다.

🔍 SOLID는 다음 다섯 가지 원칙의 약어입니다:

• S: 단일 책임 원칙 (Single Responsibility Principle)

• O: 개방-폐쇄 원칙 (Open-Closed Principle)

• L: 리스코프 치환 원칙 (Liskov Substitution Principle)

• I: 인터페이스 분리 원칙 (Interface Segregation Principle)

• D: 의존 역전 원칙 (Dependency Inversion Principle)

✅ SOLID 원칙은 개발 과정에서 문제를 예방하고, 코드의 재사용성을 높이며 유지보수를 용이하게 하는 데 큰 도움을 줍니다.

---

📘 각 원칙 요약 + 예시

1. 🔹 단일 책임 원칙 (SRP)

클래스는 단 하나의 책임만 가져야 한다.

📌 예시 (Java)

// Bad Example
class UserService {
    void registerUser(User user) { ... }
    void sendEmail(User user) { ... } // 역할이 섞임
}

// Good Example
class UserService {
    void registerUser(User user) { ... }
}

class EmailService {
    void sendEmail(User user) { ... }
}

💥 위반 시 문제점

• 여러 변경 이유가 생기므로 수정 시 연쇄적인 오류 가능성 증가

---

2. 🔹 개방-폐쇄 원칙 (OCP)

확장에는 열려 있어야 하고, 변경에는 닫혀 있어야 한다.

📌 예시

interface DiscountPolicy {
    int discount(int price);
}

class FixDiscountPolicy implements DiscountPolicy {
    public int discount(int price) {
        return price - 1000;
    }
}

class OrderService {
    private DiscountPolicy discountPolicy;

    public OrderService(DiscountPolicy discountPolicy) {
        this.discountPolicy = discountPolicy;
    }

    public void order(int price) {
        int finalPrice = discountPolicy.discount(price);
        // 주문 처리 로직
    }
}

💥 위반 시 문제점

• 기능 추가 시 기존 클래스 내부 코드를 수정해야 하므로 안정성이 낮음

---

3. 🔹 리스코프 치환 원칙 (LSP)

하위 클래스는 상위 클래스의 행위를 대체할 수 있어야 한다.

📌 예시

class Bird {
    void fly() {}
}

class Ostrich extends Bird {
    @Override
    void fly() {
        throw new UnsupportedOperationException(); // 날 수 없음
    }
}

💥 위반 시 문제점

• 상속받은 객체를 사용하는 코드에서 예외 발생 → 다형성 깨짐

---

4. 🔹 인터페이스 분리 원칙 (ISP)

클라이언트는 자신이 사용하지 않는 인터페이스에 의존하지 않아야 한다.

📌 예시

// Bad Interface
interface Machine {
    void print();
    void scan();
    void fax();
}

// Good Interfaces
interface Printer {
    void print();
}

interface Scanner {
    void scan();
}

💥 위반 시 문제점

• 불필요한 메서드 구현 강제 → 유지보수 어려움

---

5. 🔹 의존 역전 원칙 (DIP)

고수준 모듈은 저수준 모듈에 의존하면 안 되며, 둘 다 추상화에 의존해야 한다.

📌 예시

// 나쁜 예
class MySQLDatabase {
    void connect() { ... }
}

class UserService {
    private MySQLDatabase db = new MySQLDatabase(); // 직접 의존
}

// 좋은 예
interface Database {
    void connect();
}

class MySQLDatabase implements Database {
    public void connect() { ... }
}

class UserService {
    private Database db;

    public UserService(Database db) {
        this.db = db;
    }
}

💥 위반 시 문제점

• 구현 클래스가 바뀌면 고수준 모듈까지 수정해야 함

---

📌 SOLID 원칙을 지켜야 하는 이유

• ✅ 코드 재사용성 증가
• ✅ 변경에 유연한 설계 가능
• ✅ 유지보수 비용 감소
• ✅ 유닛 테스트 용이

---

🧠 면접 TIP

• 각 원칙의 핵심 개념과 예시 코드를 간단히 숙지하자
• 실제 프로젝트에서 어떤 원칙을 적용했는지 설명할 수 있다면 가산점