포함관계 Composition, 상속과는 다르다.

⭐포함관계
Compositon

한 클래스가 다른 클래스를 포함하는 관계다.

"has a"

⭐ 강한 연관성(필수적)

단, 상속과는 다르다

 

 

포함관계를 이해하기 위해

 

차와 엔진을 코드로 간략히 구현해봤다.

 

차와 엔진은 강한 연관성(필수적)을 가지고 있다.

 

1. 엔진

package com.composition;
/**
 * 4.21 포함개념 8
 */
public class Engine {

    //멤버변수설계
    String name;
    int price;

    //메서드
    void start() {
        System.out.println("start() 엔진을 구동합니다.");
    }

    void stop() {
        System.out.println("stop() 엔진을 정지합니다.");
    }

}// end of Engine

/**
객체지향 패러다임 고민

Q 차와 엔진을 상속관계에 둬도 될까?

A 안된다 💀
 */

 

2. 차

차가 움직이려면 먼저 엔진이 가동해야 한다.

package com.composition;
/**
 * 4.21 포함개념 8
 */
public class Car {

    //멤버변수설계
    String name;
    int price;
    /*
    ⭐Car 클래스는 Engine 객체를 포함한다.
    포함관계(Compositoion)
     */
    Engine engine;

    //생성자
    public Car(String name, int price) {
        this.name = name;
        this.price = price;

        /*
        자동차 객체가 생성될 때 엔진 객체도 함께 생성된다.
        포함관계
        ⭐강한의존성
         */
        engine = new Engine();
    }

    //메서드
    void startCar() {

        //car 객체를 통해 engine의 start(); 메서드를 호출한다
        engine.start();
        System.out.println("startCar() 자동차가 움직입니다.");
    }

    void stopCar() {

        engine.stop();
        System.out.println("stopCar() 자동차가 멈춥니다.");
    }

//테스트코드작성
    public static void main(String[] args) {

        /*
        ⭐컴포지션 관계란

        자동차 클래스 내부에서
        엔진 객체를 생성시켜야 컴포지션 관계다
         */

        Car car = new Car("소나타", 1000);
        car.startCar(); // 시동걸기

        System.out.println();
        car.stopCar(); // 시동끄기

    }//main

} // end of Car

 

또 다른 포함관계 예제

 

PC와 CPU 역시 강한 연관성(필수적)을 가지고 있다.

 

1.CPU

package com.composition;
/**
 * 4.21 포함개념 8_1
 */
public class CPU {

    //멤버변수
    private String name;
    private int id;

    //메서드

    void startCPU() {
        System.out.println(this.name + "CPU 가동");
    }

    void stopCPU() {
        System.out.println(this.name + "CPU 정지");
    }

}//end of CPU

 

2. PC

package com.composition;
/**
 * 4.21 포함개념 8_1
 */
public class PC {

    //멤버변수
    private String name;
    private int id;

    //CPU 객체 선언
    CPU cpu;

    //생성자
    PC(String name, int id) {
        this.name = name;
        this.id = id;

        cpu = new CPU();
    }

    //메서드
    void startPC() {
        cpu.startCPU();
        System.out.println(this.name + " PC 가동");
    }
    void stopPC() {
        cpu.stopCPU();
        System.out.println(this.name + "PC 정지");
    }

    //main
    public static void main(String[] args) {

        PC pc1 = new PC("삼보", 1113);
        PC pc2 = new PC("현대", 4321);

        pc1.startPC();
        pc1.stopPC();

        System.out.println();

        pc2.startPC();
        pc2.stopPC();

    }//end of main

}//end of PC

 

다른 형태의 포함관계를 생각해보자.

 

집과 방도 강한 연관성(필수적)을 가지고 있다.

 

1. 방

package com.composition;
/**
 * 4.21 포함개념 8_2
 */
public class Room {

    private String type;

    public Room(String type) {
        this.type = type;
    }

    void descrive() {
        System.out.println(this.type + " 입니다.");
    }
}// end of Room

 

2. 집

 

집은 여러개의 방으로 구성돼 있다.

 

반복되는 부분이 있는 점을 고려해

 

배열과 반복문을 응용해서 넣어봤다.

package com.composition;
/**
 * 4.21 포함개념 8_2
 */
public class House {

    private String address;
    Room[] rooms;

    public House(String address) {
        this.address = address;

        this.rooms = new Room[3];

        rooms[0] = new Room("1.거실");
        rooms[1] = new Room("2.침실");
        rooms[2] = new Room("3.주방");

        //속성으로 선언되고
        //내붸서 객체생성
        //컴포지션이다.
        //room = new Room(type:"안방");
    }

    void showRoom() {
        System.out.println(address+ "에 있는 한 주택의 방 목록: " );
        for (int i = 0; i < rooms.length; i++) {
            if (rooms[i] != null) {
                rooms[i].descrive();
            }
        }
    }

    //테스트
    public static void main(String[] args) {
        House house = new House("부산시진구");
        house.showRoom();

        //house 객체가 소멸이 되면 rooms 도 Room 객체도 소멸
        //GC에 의해 소멸
        house = null;
    }//end of main

}//end of House