Java 세션_객체 간의 결합도와 다형성

객체 간의 결합도와 다형성

11/29 11:10 ~ 12:30 (약 1시간 20분 진행)

 

⭐ 중요 키워드 ⭐

• 객체 간의 결합도
• 다형성
• DI 의존성 주입
• IoC 제어의 역전
• 객체 지향 4가지 특징

 

1. 인터페이스를 활용한 다형성

시나리오 1 - 자동차 주행 프로그램

임무 : 자동차를 주행시키는 프로그램을 만드세요.

senario1.directBinding 패키지에 Car, GasEngine, ElectricEngine, Main 클래스 생성

package senario1.directBinding;

public class Car {

    // 1. 속성
    private GasEngine engine;


    // 2. 생성자
    public Car(){
        this.engine = new GasEngine();
    }

    public void drive() {
        System.out.println("자동차가 주행됩니다.");
        this.engine.run();
    }
}

package senario1.directBinding;

public class GasEngine {

    // 1. 속성


    // 2. 생성자


    // 3. 기능
    public void run() {
        System.out.println("가스 엔진이 동작합니다.");
    }
}

package senario1.directBinding;

public class Main {

    public static void main(String[] args) {

        Car carA = new Car();
        carA.drive();
    }
}

 

✔️ 강결합

객체 간의 의존성이 높을 때 결합도가 강하다. 

 

시나리오 1 - 새로운 요구사항

새로운 엔진(ElectricEngine)이 개발되었습니다. 자동차가 새로 개발된 엔진을 사용하세 해주세요.

package senario1.directBinding;

public class Car {

    // 1. 속성
    private GasEngine engine;
    private ElectircEngine electircEngine;  // 수정


    // 2. 생성자
    public Car(){
        this.engine = new GasEngine();
        this.electircEngine = new ElectircEngine();  // 수정
    }

    public void drive() {
        System.out.println("자동차가 주행됩니다.");
        this.engine.run();
    }

    public void driveWithElectricEngine() {  // 수정
        System.out.println("자동차가 주행됩니다.");
        this.electircEngine.run();
    }
}

package senario1.directBinding;

public class ElectircEngine {

    // 3. 기능
    public void run() {
        System.out.println("전기 엔진이 동작합니다.");
    }
}

package senario1.directBinding;

public class Main {

    public static void main(String[] args) {

        Car carA = new Car();
        //carA.drive();
        carA.driveWithElectricEngine();
    }
}

코드를 완성했지만 이렇게 작성한 코드는 강한 결합도(강결합)를 가지고 있다.
코드가 강결합이라면 유지보수에 좋지 않다..

시나리오 1 - 인터페이스를 활용한 해결 방법

senario1.looseCoupling 패키지에 Engine 인터페이스와 Car, GasEngine, ElectricEngine, Main 클래스 생성

package senario1.looseCoupling;

public interface Engine {

    void run();
}

package senario1.looseCoupling;

public class GasEngine implements Engine{

    @Override
    public void run() {
        System.out.println("가스 엔진이 동작합니다.");
    }
}

package senario1.looseCoupling;

public class ElectricEngine implements Engine{

    @Override
    public void run() {
        System.out.println("전기 엔진이 동작합니다.");
    }
}

package senario1.looseCoupling;

public class Car {

    // 속성
    private Engine engine;


    // 생성자
    public Car(Engine engine) {
        this.engine = engine;
    }


    // 기능
    public void drive() {
        this.engine.run();
    }
}

package senario1.looseCoupling;

public class Main {

    public static void main(String[] args) {

        GasEngine gasEngine = new GasEngine();
        ElectricEngine electricEngine = new ElectricEngine();

        Car gasCar = new Car(electricEngine);
        gasCar.drive();
    }
}

새로운 엔진 객체가 생긴다고 해도 자동차 객체는 변경에서 자유로워진다.

 

2. 다형성

하나의 객체가 여러 가지 형채를 가질 수 있는 것이다.
이러한 특징을 잘 활용하면 객체 간의 느슨한 결합도를 구현할 수 있다.

 

3. 의존성주입(DI : Dependency Injection)

객체에 필요한 객체를 주입해 주는 것을 의존성 주입이라고 한다.

public class Main {

    public static void main(String[] args) {
        GasEngine gasEngine = new GasEngine();
        Car gasCar = new Car(gasEngine); // 의존성 주입! Car 객체에 Engine 타입의 객체가 필요하기 때문에 Engine을 인스턴스화해서 넣어준다!
        ...
    }
}

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

 

4. 제어의 역전(IoC : Inversion of Control)

프로그램 실행 흐름의 제어권을 제3의 주체(외부)로 넘겨주는 것이다.
IoC는 객체 생성, 의존성 관리를 외부에서 관리하도록 하여 객체 간의 결합도를 낮추는 설계 원칙이다.
스프링에서는 IoC 컨테이너가 이 역할을 한다.

• 객체 생성에 대한 책임을 외부로 전가
• 어떤 엔진을 구현할지 결정을 외부로 전가

public class Main {

    public static void main(String[] args) {
        ElectricEngine electricEngine = new ElectricEngine();  // 객체 생성에 대한 책임을 외부로 전가.
        GasEngine gasEngine = new GasEngine();

        Car electricCar = new Car(electricEngine);  // 어떤 엔진을 구현할 지 책임을 외부로 전가.
        Car gasCar = new Car(gasEngine);

        electricCar.drive();
        gasCar.drive();
    }
}

 

5. 상속을 활용한 다형성

시나리오 2 - 자동차 부품 검수 프로그램

자동차 부품을 검수할 수 있는 프로그램을 만드세요.

package senario2.directBinding;

/**
 * 브레이크 객체
 */
public class Brake {

    private String name;  // 브레이크 이름
    private boolean isInspected;  // 검수 여부(true/false)


    public Brake(String name) {
        this.name = name;
        this.isInspected = false;
    }

    // 게터
    public  boolean getIsInspected() {
        return this.isInspected;
    }

    // 세터
    public void setInInspected(boolean isInspected) {
        this.isInspected = isInspected;
    }
}

package senario2.directBinding;

/**
 * 브레이크 검수 역할 담당 객체
 */
public class InspectService {

    // 기능
    public void inspect(Brake brake) {
        System.out.println("검수를 시작합니다.");
        System.out.println(brake.getIsInspected());  // false
        brake.setInInspected(true);
        System.out.println("변경되었습니다 -> " + brake.getIsInspected());  // true
    }
}

package senario2.directBinding;

public class Main {

    public static void main(String[] args) {
        Brake brake = new Brake("디스크 브레이크");
        InspectService inspectService = new InspectService();

        inspectService.inspect(brake);
    }
}

새로운 부품(Sensor)이 추가된다면..?

public class Main {

    public static void main(String[] args) {
        Brake brakeA = new Brake("디스크 브레이크");
        Sensor sensor = new Sensor("충돌방지");

        InspectService inspectService = new InspectService();
        inspectService.inspect(brakeA);
        inspectService.inspect(sensor);  // 에러발생
    }
}

 

시나리오 2 - 상속을 활용한 해결

package senario2.looseCoupling;

/**
 * 자동차 부품(부모클래스)
 * 검수만 받아야 해!
 */
public abstract class CarPart {

    // 속성
    private boolean isInspected;

    // 생성자
    public CarPart(boolean isInspected) {
        this.isInspected = isInspected;
    }

    // 기능
    public void inspect() {
        System.out.println("검수를 진행합니다.");
        this.isInspected = true;
        System.out.println(" -> " + this.isInspected );
    }
}

package senario2.looseCoupling;

public class Brake extends CarPart{

    private String name;

    public Brake(String name) {
        super(false);
        this.name = name;
    }
    public void stop() {
        System.out.println("멈출 수 있다.");
    }
}

package senario2.looseCoupling;

public class InspectService {

    // 기능
    public void inspect(CarPart carPart) {
        carPart.inspect();
    }
}

package senario2.looseCoupling;

public class Main {

    public static void main(String[] args) {
        Brake brake = new Brake("디스크 브레이크");
        InspectService inspectService = new InspectService();

        inspectService.inspect(brake);
    }
}

 

추상화

객체 본질에 집중할 수 있게 본질 외의 정보를 숨기는 것이다.

 

인터페이스 vs 상속

특징	인터페이스	상속
코드 재사용성	❌ 구현체에서 각자 구현 필요	✔️ 부모클래스 것을 그대로 사용가능
구현 강제성	✔️ 모든 메서드 구현 강제 보장	❌ 필요한 것만 재정의
계층 표현	❌ 부적합	✔️ 적합
다중 구현 가능	✔️ implements 여러 개 가능	❌ extends 여러 개 불가능

 

6. 객체 지향 4가지 특징 (면접 단골 질문)⭐⭐⭐⭐⭐

추상화

불필요한 구현을 숨기고 객체의 본질적인 부분에만 집중할 수 있게 하는 설계이다.

• 부모 클래스(CarPart)에서 검수와 관련된 공통 속성과 동작을 정의해서 자식 클래스(Brake 또는 타이어)는 검수를 신경 쓸 필요 없이 스스로 역할(brake.stop( ))에 집중할 수 있다.

상속

부모 클래스의 속성과 기능을 자식 클래스가 물려받는 것이다.

• 부모 클래스에서 정의된 속성(isInspected)과 메서드(inspect( ))를 자식 클래스에서 물려받아 그대로 사용할 수 있다.

캡슐화

외부에서 접근을 제어하는 것이다. 데이터를 보호한다.

• 클래스에서 접근 제어자(private, public)를 사용해서 필요한 정보만 외부로 노출하고 불필요한 정보는 외부로부터 감추고 보호할 수 있는 설계를 할 수 있다.

다형성

같은 타입의 참조변수가 여러 가지 형태를 가질 수 있는 것이다.

• 인터페이스와 상속을 통해 다양한 타입을 받을 수 있는 구조를 설계함으로써 객체 간의 결합도를 낮출 수 있다.