SOLID Principle

S : Single Responsibility Principle

단일 책임 원칙 : 클래스나 함수는 단 하나의 책임만을 가져야 한다.

🎯 예시)

public class SRP {
    public static void main(String[] args) {
        add(10,20);
    }

    public static void add(int num1, int num2){
        System.out.println(num1+num2);
    }
}

👉 위 코드에서 SRP를 적용하기

public class SRP {
    public static void main(String[] args) {
        printNum(add(10,20));
    }

    public static int add(int num1, int num2){
        return num1 + num2;
    }

    public static void printNum(int num){
        System.out.println(num);
    }
}

위와 같이 add함수에서 출력까지 하지 않고 printNum 함수를 정의함으로써 add함수의 책임을 나누어 줌

---

O : Open Closed Principle

개방 폐쇄 원칙 : 기존 코드 변경에는 닫혀있고, 추가나 확장에는 열려있어야 한다.

🎯 예시)

class Animal {
    public void wai(String animal){
        if (animal.equals("Cat")){
            System.out.println("Cat");
        }else if (animal.equals("Dog")){
            System.out.println("Dog");
        }
    }
}

public class OCP{
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.wai("Cat");
        animal.wai("Dog");
    }
}

👉 위 코드에서 OCP를 적용하기

abstract class Animal {
    public abstract void wai();
}
class Cat extends Animal {

    @Override
    public void wai() {
        System.out.println("Cat");
    }
}

class Dog extends Animal {

    @Override
    public void wai() {
        System.out.println("Dog");
    }
}

public class OCP{
    public static void main(String[] args) {
        Cat kitty = new Cat();
        kitty.wai();

        Dog snoopy = new Dog();
        snoopy.wai();
    }
}

horse를 추가하고자 할 때 Horse 클래스를 생성하고 Animal Class를 상속 =>
기존의 코드를 수정하지 않고 기능 확장

---

L : Liskov Substitution Principle

리스코프 치환 원칙 : 서브클래스는 슈퍼클래스에서 가능한 행위를 수정할 수 있어야 한다.

🎯 예시)

class Cat{
    public void speak(){
        System.out.println("meow");
    }
}

class BlackCat extends Cat{
    @Override
    public void speak() {
        System.out.println("black meow");
    }
}

public class LSP {
    public static void main(String[] args) {
        Cat blackCat = new BlackCat();
        blackCat.speak();
    }
}

상위 타입의 Cat을 하위 타입의 BlackCat으로 치환할 경우 원하는 대로 black meow가 출력됨

---

I : Interface segregation Principle

인터페이스 분리 원칙 : 클라이언트가 자신이 이용하지 않는 메소드들에 의존하면 안된다.

🎯 예시)

interface Phone{
    void samsungOpen();
    void samsungClose();
    void appleOpen();
    void appleClose();
}

👉 위 코드에서 ISP를 적용하기

interface SamsungPhone{
    void samsungOpen();
    void samsungClose();
}

interface ApplePhone{
    void appleOpen();
    void appleClose();
}

삼성폰과 애플폰을 구분지어 인터페이스를 생성한다.

---

D : Dependency Inversion Principle

의존관계 역전 원칙 : 변화하기 쉬운 것 보다는 변화하기 어려운 것에 의존한다.

🎯 예시)

abstract class Pants{
    abstract String wear();
}

class OnePiece extends Pants{
    @Override
    String wear() {
        return "OnePiece";
    }
}

class Skirt extends Pants{
    @Override
    String wear() {
        return "Skirt";
    }
}

class Person{
    private Pants pants;

    public void addPants(Pants pants){
        this.pants = pants;
    }

    public void printPants(){
        System.out.println(pants.wear());
    }
}

public class DIP {
    public static void main(String[] args) {
        OnePiece onePiece = new OnePiece();
        Skirt skirt = new Skirt();

        Person person = new Person();
        person.addPants(onePiece);
        person.printPants();
    }
}

Skirt와 OnePiece를 Pants로 부터 상속받는다. 그리고 main함수에와 같이 사용하게 되면 Person은 Skirt와 OnePiece가 아닌 Pants로 접근하여 사용하게 됨

---

https://www.youtube.com/channel/UCHcG02L6TSS-StkSbqVy6Fg
=> 코드없는 프로그래밍 님의 유튜브 동영상 시청 후 이해한 내용을 바탕으로 자바로 작성한 글입니다.