객체지향 프로그래밍의 SOLID 원칙

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

• 예시: 하나의 클래스가 사용자 정보 관리와 파일 입출력 처리를 동시에 담당한다면, 이는 단일 책임 원칙을 위반한 것이다. 사용자의 정보가 변경될 때와 파일 입출력 로직이 변경될 때 클래스가 수정되어야 하므로, 이 클래스는 두 가지 책임을 가지고 있다.

class UserManager {
    public void addUser(String userName) {
        // 사용자 추가 로직
    }

    public void saveToFile(String fileName) {
        // 파일에 사용자 정보 저장 로직
    }
}

class UserManager {
    public void addUser(String userName) {
        // 사용자 추가 로직
    }
}

class FileManager {
    public void saveToFile(String fileName) {
        // 파일에 저장 로직
    }
}

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

• 예시: 새로운 기능을 추가할 때 기존 코드를 변경하지 않고, 새로운 클래스를 추가하거나 상속을 통해 기능을 확장하는 방식이다.

class Rectangle {
    public double width;
    public double height;
}

class AreaCalculator {
    public double calculateRectangleArea(Rectangle rectangle) {
        return rectangle.width * rectangle.height;
    }
}

interface Shape {
    double calculateArea();
}

class Rectangle implements Shape {
    private double width;
    private double height;

    Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double calculateArea() {
        return width * height;
    }
}

class Circle implements Shape {
    private double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class AreaCalculator {
    public double calculateArea(Shape shape) {
        return shape.calculateArea();
    }
}

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

• 예시: 만약 자식 클래스가 부모 클래스의 메서드를 재정의하여 원래의 의도를 변경하면, 이는 리스코프 치환 원칙을 위반한 것이다.

class Bird {
    public void fly() {
        System.out.println("Bird is flying");
    }
}

class Ostrich extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Ostrich can't fly");
    }
}

class Bird {
    public void move() {
        System.out.println("Bird is moving");
    }
}

class Ostrich extends Bird {
    @Override
    public void move() {
        System.out.println("Ostrich is walking");
    }
}

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

• 예시: 클라이언트가 사용하지 않는 메서드를 강제로 구현하도록 하는 큰 인터페이스는 ISP를 위반한다.

interface Worker {
    void work();
    void eat();
}

class HumanWorker implements Worker {
    public void work() {
        System.out.println("Human is working");
    }

    public void eat() {
        System.out.println("Human is eating");
    }
}

class RobotWorker implements Worker {
    public void work() {
        System.out.println("Robot is working");
    }

    public void eat() {
        // 로봇은 먹지 않으므로 불필요한 메서드 구현
    }
}

interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class HumanWorker implements Workable, Eatable {
    public void work() {
        System.out.println("Human is working");
    }

    public void eat() {
        System.out.println("Human is eating");
    }
}

class RobotWorker implements Workable {
    public void work() {
        System.out.println("Robot is working");
    }
}

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

• 예시: 고수준 모듈이 저수준 모듈의 구현에 의존하면 DIP를 위반하게 된다.

class Light {
    public void turnOn() {
        System.out.println("Light is on");
    }

    public void turnOff() {
        System.out.println("Light is off");
    }
}

class Switch {
    private Light light;

    public Switch(Light light) {
        this.light = light;
    }

    public void operate() {
        light.turnOn();
    }
}

interface Switchable {
    void turnOn();
    void turnOff();
}

class Light implements Switchable {
    public void turnOn() {
        System.out.println("Light is on");
    }

    public void turnOff() {
        System.out.println("Light is off");
    }
}

class Switch {
    private Switchable device;

    public Switch(Switchable device) {
        this.device = device;
    }

    public void operate() {
        device.turnOn();
    }
}

결론