SOLID 원칙과 구체적인 예시

개요

아래 내용은 Chat GPT가 작성한 내용입니다.

따라서 잘못된 내용이 있을 수 있습니다....가 아니라 많네요 보니까 ^^;

Chat GPT 테스트 겸 그대로 업로드합니다

 

SOLID 원칙

1. 단일 책임 원칙 (Single Responsibility Principle) : 모든 클래스는 하나의 책임만 가져야 합니다. 이는 클래스를 변경할 때 다른 기능에 영향을 미치지 않도록 하는 것을 의미합니다.
2. 개방 폐쇄 원칙 (Open-Closed Principle) : 소프트웨어 개체(클래스, 모듈, 함수 등)는 확장에 대해 열려 있어야 하고 변경에 대해서는 닫혀 있어야 합니다. 즉, 기존 코드를 변경하지 않고 새로운 기능을 추가할 수 있어야 합니다.
3. 리스코프 치환 원칙 (Liskov Substitution Principle) : 자식 클래스는 부모 클래스를 대체할 수 있어야 합니다. 이는 자식 클래스에서는 부모 클래스의 속성과 행동을 모두 유지해야 한다는 것을 의미합니다.
4. 인터페이스 분리 원칙 (Interface Segregation Principle) : 클라이언트는 자신이 사용하지 않는 메서드에 의존하지 않아야 합니다. 인터페이스를 클라이언트의 요구에 따라 분리하면 이 원칙을 따를 수 있습니다.
5. 의존 역전 원칙 (Dependency Inversion Principle) : 고차원 모듈은 저차원 모듈에 의존해서는 안 됩니다. 대신, 둘 다 추상화에 의존해야 합니다. 이는 구체적인 구현에 의존하는 것보다는 추상화된 인터페이스에 의존하는 것이 더 유연하고 확장 가능하다는 것을 의미합니다.

단일 책임 원칙

예를 들어, 주문(Order) 클래스가 있는데, 이 클래스는 주문을 만들고, 주문을 저장하고, 주문 내역을 출력하는 등의 여러 기능을 수행할 수 있다. 하지만 이렇게 한 클래스가 여러 기능을 수행하게 되면, 클래스의 변경이 다른 기능에도 영향을 미치게 되어 유지보수가 어려워진다. 따라서 단일 책임 원칙을 따르면, 이 클래스를 각각 주문 생성(OrderCreator), 주문 저장(OrderSaver), 주문 출력(OrderPrinter) 등으로 분리할 수 있다.

public class OrderCreator {
    public Order createOrder() {
        // ...
    }
}

public class OrderSaver {
    public void saveOrder(Order order) {
        // ...
    }
}

public class OrderPrinter {
    public void printOrder(Order order) {
        // ...
    }
}

개방 폐쇄 원칙

예를 들어, Shape 인터페이스가 있고, 이를 구현하는 Rectangle, Circle, Triangle 등의 클래스가 있다. 이 때, 새로운 도형을 추가하려면 기존 코드를 변경해야 한다면, 이는 개방 폐쇄 원칙을 위반하는 것이다. 따라서 새로운 도형을 추가하기 위해서는 Shape 인터페이스를 구현하면 된다.

public interface Shape {
    double getArea();
}

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

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

public class Circle implements Shape {
    private double radius;

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

public class Triangle implements Shape {
    private double base;
    private double height;

    public double getArea() {
        return 0.5 * base * height;
    }
}

리스코프 치환 원칙

예를 들어, Animal 클래스가 있고, 이를 상속하는 Dog, Cat 클래스가 있다. 이 때, Dog 클래스에서 Animal 클래스의 메서드를 오버라이딩하고, 그 결과가 예상치 못한 결과를 만들면 이는 리스코프 치환 원칙을 위반하는 것이다.

public class Animal {
    public void eat() {
        // ...
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        // 뼈다귀를 먹는다
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        // 생선을 먹는다
    }
}

인터페이스 분리 원칙

예를 들어, 인터페이스가 있는데, 이 인터페이스에는 여러 메서드가 있다. 이 때, 이 인터페이스를 구현하는 클래스에서 사용하지 않는 메서드까지 구현해야 한다면, 인터페이스 분리 원칙을 위반하는 것이다. 따라서 인터페이스를 분리하여 사용하지 않는 메서드를 포함하지 않도록 한다.

public interface Movable {
    void move();
    void stop();
    void turnLeft();
    void turnRight();
}

public class Car implements Movable {
    public void move() {
        // ...
    }

    public void stop() {
        // ...
    }

    public void turnLeft() {
        // ...
    }

    public void turnRight() {
        // ...
    }
}

public class Bicycle implements Movable {
    public void move() {
        // ...
    }

    public void stop() {
        // ...
    }

    public void turnLeft() {
        // ...
    }

    public void turnRight() {
        // ...
    }
}

public class Boat implements Movable {
    public void move() {
        // ...
    }

    public void stop() {
        // ...
    }
}

의존 역전 원칙

예를 들어, Car 클래스가 Engine 클래스에 의존하고 있다. 이 때, Car 클래스가 Engine 클래스의 구현을 직접 참조하는 것이 아니라 인터페이스를 통해 참조하도록 하면, 의존 역전 원칙을 따르는 것이다.

public interface Engine {
    void start();
    void stop();
}

public class GasolineEngine implements Engine {
    public void start() {
        // ...
    }

    public void stop() {
        // ...
    }
}

public class ElectricEngine implements Engine {
    public void start() {
        // ...
    }

    public void stop() {
        // ...
    }
}

public class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
    }

    public void stop() {
        engine.stop();
    }
}