[CH07] 객체지향프로그래밍3 (OOP)

본 포스팅은 자바의 정석 교재를 공부하며, 간단히 정리/기록 용도로 작성하였습니다. 혹여, 잘못된 내용이 있다면 지적해주시면 감사하겠습니다.

 

 

---

1. package 와 import

  [패키지; package]

  패키지는 클래스 혹은 인터페이스를 포함시킬 수 있어서 서로 관련된 클래스들끼리 그룹 단위로 묶어 놓음으로써 클래스를 효율적으로 관리할 수 있도록 한다. 하나의 소스 파일에는 첫 번째 문장으로 한 한 번의 패키지 선언만을 허용하며, 모든 클래스는 반드시 하나의 패키지에 속해야 한다. 또한 패키지는 점을 구분자로 계층구조를 구성할 수 있으며, 물리적으로 .class 파일을 포함하는 하나의 디렉토리이다.

 

  패키지 선언문은 하나의 소스 파일 당 1 번만 선언될 수 있다. 클래스명과 구분하기 위해 소문자를 사용하도록 하며, 패키지를 선언하지 않는 경우네는 기본적으로 자바에서 제공하는 unnamed package 떄문에 문제가 없던 것이다. 자신이 속할 패키지를 선언하지 않은 소스 파일은 자동적으로 unnamed package 에 속하게 된다. 이는 패키지를 선언하지 않은 모든 클래스들은 동일한 unnamed package 에 속하게 된다는 것을 의미한다. 큰 프로젝트나 Java API 와 같은 클래스 라이브러리를 작성해야하는 경우에는 미리 패키지를 구성하여 적용하는 것이 좋다.

 

[import 문의 선언]

  다른 패키지의 클래스를 사용하려면 해당 패키지명이 포함된 클래스 이름을 사용해야 한다. 하지만 이는 매우 번거로운 일이다. 코드 작성 이전에 import 문으로 사용하고자 하는 클래스의 패키지를 미리 명시해주면 패키지명은 생략할 수 있다. import 문을 선언함으로써 컴파일러에게 소스파일에 사용된 클래스 패키지에 대한 정보를 제공할 수 있다. 컴파일러는 import 문을 통해서 source file 에서 사용하고 있는 클래스들의 패키지를 파악하여, 모든 클래스 이름 앞에 패키지 명을 붙여준다. 

 

  일반적으로 소스파일(*.java)은 package문 - import문 - class 선언의 순서로 되어있다. import 문을 선언하는 방법은 import 뒤에 패키지명.클래스명을 붙이거나, 패키지명.* 을 붙이면 된다. * 를 사용하면 해당 패키지의 모든 클래스를 사용한다는 것으로, 컴파일러는 해당 패키지에서 일치하는 클래스의 이름을 찾는 일을 수행해야 하지만 실행 시 성능상의 차이는 전혀 없다. import 문은 프로그램의 성능에 전혀 영향을 주지 않고, import 문을 많이 사용하면 컴파일 시간이 아주 조금 증가할 뿐이다. 유의해야할 점은 패키지명.* 와 같이 import 를 할 경우에는 하위 패키지의 클래스까지 포함하지는 않는 다는 것이다.

import java.text.SimpleDateFormat;
import java.util.Date;

class source{
    public static void main(String[] args) {
        Date today = new Date();

        SimpleDateFormat date = new SimpleDateFormat("yyyy/MM/dd");
        SimpleDateFormat time = new SimpleDateFormat("hh:mm:ss a");

        System.out.println("date = " + date.format(today));
        System.out.println("time = " + time.format(today));
    }
}

[static import 문]

static import 를 사용하면 static 멤버를 호출할 때 클래스의 이름을 생략할 수 있다. 특정 클래스의 static 멤버를 자주 사용하는 경우에 편리하며, 코드가 간단해진다.

import static java.lang.System.out;
import static java.lang.Math.*;

class source{
    public static void main(String[] args) {
        //System.out.println(Math.random());
        out.println(random());
        out.println(PI);
    }
}

2. 제어자(Modifier)

  [제어자란?]

메서드 선언부에 사용되어 부가적인 의미/기능을 부여한다. 접근 제어자와 그 외 제어자로 구분할 수 있다.

접근 제어자는 public, protected, default, private 가 있고 외에는 static, final, abstract, native, transient, synchronized, volatile, strictfp 가 있다. 멤버 변수와 메서드, 클래스에 사용되며 여러 제어자를 조합하여 사용할 수 있다. 다만 접근 제어자는 여러 개를 조합하여 사용할 수 없다.

 

Static - 클래스의, 공통적인

  static 은 '클래스의' 또는 '공통적인' 이라는 의미를 가지고 있다. 인스턴스 변수는 하나의 클래스로부터 생성되어도 각각 다른 값을 가지지만 static 변수는 같은 값을 가진다.(공유) static 키워드가 붙은 멤버변수, 메서드, 초기화블럭은 인스턴스와 관계 없이 클래스와만 관계된 것이기 때문에 인스턴스를 생성하지 않고도 사용이 가능하다. 인스턴스 메서드와 static 메서드의 차이점을 물어본다면, 매서드 내에서 인스턴스 멤버를 사용하느냐 여부가 핵심이다.

 

  static 멤버변수는 모든 인스턴스에 대하여 공통적으로 사용되는 클래스 변수이며, 인스턴스 생성 없이도 사용이 가능하고 클래스가 메모리에 로드될 때 생성된다.

  static 메서드는 인스턴스 생성 없이 호출 가능한 메서드로, static 메서드 내에서는 인스턴스 멤버를 직접적으로 접근할 수 없다.

 

  가능하면 static 메서드로 선언하는 것이 인스턴스 생성 없이도 호출이 가능하므로 효율적이다. 인스턴스 멤버를 사용하고 있지 않다면 static 메서드로 선언하는 것을 고려해보는 것이 좋다.

 

Final - 마지막의, 변경될 수 없는

  final 은 클래스, 메서드, 멤버변수, 지역변수에 사용할 수 있으며 변수에 사용할 경우에는 상수가 되고 메서드에 사용하면 오버라이딩이 불가능해지며 클래스에 사용하면 자기 자신을 확장하는 자손 클래스를 정의할 수 없게 된다. final 클래스는 변경할 수 없는(확장 불가능한) 클래스이며, final 메서드는 변경될 수 없는 메서드로 오버라이딩을 통한 재정의가 불가능하다. final 멤버변수 혹은 지역 변수는 상수로서 동작한다.

 

final class FinalTest{

final int MAX_SIZE = 10;

final void getMaxSize() {

final int LV = MAX_SIZE;

return MAX_SIZE;

     }

}

  생성자를 이용한 final 멤버 변수는 상수이기 때문에 선언과 동시에 초기화하지만, 인스턴스 변수는 생성자에서 초기화될 수 있도록 할 수 있다. 클래스 내에서 매개 변수를 가지는 생성자를 만들고, 인스턴스를 생성할 때 final 멤버변수 초기화에 필요한 값을 매개변수로부터 제공받도록 하면 된다. 이렇게 하면 final 멤버 변수가 각각의 인스턴스마다 다 다른 값을 가지도록 할 수 있다.

class Card{
    final int NUMBER;
    final String KIND;
    static int width = 100;
    static int height = 250;

    Card(String kind, int num){
        KIND = kind;
        NUMBER = num;
    }
    Card(){
        this("HEART", 1);
    }
    public String toString(){
        return KIND + " " + NUMBER;
    }
}

class source{
    public static void main(String[] args) {
        Card c = new Card("HEART" , 10);
        //c.NUMBER = 5;
        //ERROR!
        //Can't assign a value to final variable NUMBER.
        System.out.println(c.KIND);
        System.out.println(c.NUMBER);
        System.out.println(c);
    }
}

 

Abstract - 추상의, 미완성의

  Abstract 은 미완성의 의미를 가지고 있어, 메서드의 선언부만 작성하고 실제 수행 내용은 구현하지 않은 추상 메서드 선언 시 사용된다.클래스, 메서드에 사용할 수 있으며 abstract 클래스는 클래스 내에 추상 메서드가 선언되어 있음을 의미하는 것이고 abstract 메서드는 추상 메서드(선언부만 작성된 메서드) 임을 의미한다. 추상 클래스는 추상 메서드가 존재하는 클래스이기 때문에 인스턴스를 생성할 수 없다. 자세한 내용은 추후에 다루도록 하자.

 

접근 제어자(Access modifier)

  접근 제어자는 멤버, 클래스에 사용할 수 있다. 외부에서 접근할 수 있는 범위를 제한하는 역할을 한다. private 는 같은 클래스 내에서만 접근이 가능한 것이고, default 는 같은 패키지 내에서만 접근이 가능하고 protected 는 같은 패키지 내와 다른 패키지의 자손 클래스에서 접근이 가능한 것이다. public 은 아무런 접근 제한이 없다.

 

public > protected > default > private

 

클래스에는 public, default 를 사용할 수 있고 메서드, 멤버변수에는 public, protected, default, private 를 사용할 수 있으며 지역 변수에는 사용할 수 없다.

 

접근 제어자를 사용하는 목적은 클래스 내부 변수의 보호를 위한 것으로, 데이터가 유효한 값을 유지하고 보안을 유지하기 위함이다. 이를 데이터 감추기(data hiding), 캡슐화(encasulation) 이라고 한다. 또한 클래스 내에서만 사용되는 멤버 변수나 메서드와 같은 멤버들을 클래스 내부에 감춤으로써 복잡성을 줄일 수 있다.

 

접근 제어자를 사용하는 이유

1. 외부로부터 데이터를 보호하기 위해서

2. 외부에는 불필요한, 내부적으로만 사용되는 부분을 감추기 위해서

 

어떤 메서드를 변경해야하는 작업이 필요하다고 가정해보자. 해당 메서드가 public 이라면, 메서드를 변경한 뒤에 전체적으로 테스트를 거쳐야 한다. default 라면 같은 패키지 내에서만 테스트하면 되고, private 라면 같은 클래스 내에서만 확인해주면 된다. 이와 같이 접근 제어자를 어떻게 지정하느냐에 따라서 작업 부하는 크게 달라진다.

public class source{
    public int hour;
    public int miniute;
    public int second;
    public static void main(String[] args) {
        source t = new source();
        t.hour = 25;
    }
}

 

위와 같은 클래스가 있다고 하자. 인스턴스를 생성한 다음 hour 값을 25 로 바꿔주었다. 근데 사실 hour 이 25 가 되면 데이터 무결성에 위반된다. 이와 같이 멤버 변수의 값을 유효하지 않게 변경하는 작업에 대한 아무런 대응책이 존재하지 않는다. 이러한 경우, 멤버 변수를 private 나 protected 로 제한하고 멤버 변수의 값을 변경하고 읽을 수 있는 public 메서드를 제공하여 간접적으로 멤버변수의 값을 다룰 수 있게 하여, 데이터를 유효하게 만들 수 있도록 할 수 있다.

public class source{
    private int hour;
    private int minute;
    private int second;
    
    public int getHour(){return hour;}
    public void setHour(int hour){
        if(hour<0 || hour>23) return;
        this.hour = hour;
    }
    public int getMinute(){return minute;}
    public void setMinute(int minute){
        if(minute<0 || minute>59) return;
        this.minute = minute;
    }
    public int getSecond(){return second;}
    public void setSecond(int second){
        if(second<0 || second>59) return;
        this.second = second;
    }
}

이와 같이 getter, setter 을 만들어 데이터의 유효성을 위반하지 않도록 제한할 수 있다.

 

  [생성자의 접근 제어자]

생성자에 접근 제어자를 사용하여 인스턴스 생성을 제한할 수 있다. 생성자를 private 로 지정하면 외부에서 생성자에 접근할 수 없게 되어, 인스턴스를 생성할 수 없고 오직 클래스 내부에서만 인스턴스를 생성할 수 있게 되는 것이다.

final class Singleton {
    private static Singleton s = new Singleton();
    private Singleton(){
        //
    }
    public static Singleton getInstance() {
        return s;
    }

}

위와 같이 생성자를  private 로 설정하여, 인스턴스를 직접적으로 생성하지 못하도록 한다. 그리고 public 메서드를 통해서 인스턴스에 접근하도록 함으로써 사용가능한 인스턴스 개수를 제한할 수 있다. 유의해야할 점은 생성자가 private 인 클래스는 다른 클래스의 조상이 될 수 없다. 자손 클래스는 인스턴스가 생성될 때, 상속받은 클래스의  생성자를 호출하는데 위의 경우 private 로 되어있기 때문에 호출이 불가능해진다. 그래서 이러한 경우에는 해당 클래스에 final 키워드를 붙여서, 더 이상 상속할 수 없는 클래스임을 명시하는 것이 좋다 .

 

  [제어자;modifiler 의 조합]

더 다양한 제어자들이 존재하지만, 일단 이 정도로만 정리하도록 하자. 아래는 대상에 따라 사용 가능한 제어자들이다.

 

클래스 : public, default, final, abstract

메서드 : 모든 접근 제어자, final, abstract, static

멤버변수 : 모든 접근 제어자, final, static

지역변수 : final

 

제어자를 조합하여 사용할 때에는 몇 가지 조심해야할 점이 있다.

 

1. 메서드에 static 과 abstract 를 같이 사용할 수 없다.

:  static 메서드는 몸통이 있는 메서드에만 사용이 가능하다.

2. 클래스에 abstract 와 final 을 동시에 사용할 수 없다.

:  클래스에 사용되는 final 은 클래스를 확장할 수 없다는 의미이고 abstract 는 상속을 통해 완성되어야 한다는 것이므로 서로 모순된다.

3. abstract 메서드의 접근 제어자가 private 일 수는 없다.

:  abstract 메서드는 자손 클래스에서 구현해야 하는데 접근 제어자가 private 이면 자손 클래스에서 접근이 불가능해진다.

4. 메서드에 private 와 final 을 같이 사용하는 것은 비효울적이다.

:  접근 제어자가 private 이면 오버라이딩 될 수 없다. 둘 중 하나만 사용해도 충분하다.

 

3.  다형성(polymorphism)

  [다형성의 정의]

 다형성(polymorphism)이란 여러 가지 형태를 가질 수 있는 능력을 말한다. 자바에서는 조상 클래스 타입의 참조 변수로 자손 클래스의 인스턴스를 참조할 수 있도록 하여 다형성을 구현하였다. 아래의 코드를 보자.

class Tv{
    boolean power;
    int channel;
    
    void power(){ };
    void channelUp(){};
    void channelDown(){};
}
class CaptionTv extends Tv{
    String text;
    void caption() {};
}

위와 같은 관계에서 보통 아래와 같이 인스턴스를 생성하여 참조하였다.

 

Tv t = new Tv();

CaptionTv c = new CaptionTv();

 

하지만 아래와 같이 할 수도 있다.

 

CaptionTv c = new CaptionTv();

Tv t = new CaptionTv();

 

조상 클래스 타입의 참조 변수로 자식 클래스 인스턴스를 참조한 것이다. 그렇다면 같은 타입의 참조 변수로 인스턴스를 참조한 것과, 다른 타입(조상 클래스)의 참조 변수로 인스턴스를 참조한 것은 어떠한 차이가 있을까? 조상 클래스 타입의 참조 변수로 자식 클래스의 인스턴스를 참조하는 경우에는 조상 클래스의 멤버(상속받은 멤버)만 사용할 수 있다. 즉, 조상 클래스 타입으로 참조하면 CaptionTv 인스턴스 중에서 Tv 클래스에서 정의되지 않은 멤버는 사용하지 못한다는 것이다. 같은 타입의 인스턴스이지만 참조 변수의 타입을 어떻게 하느냐에 따라서 사용 가능한 멤버의 개수가 달라진다는 것이 핵심이다. 그럼 자식 클래스 타입으로 참조변수를 만들고, 조상 클래스 타입의 인스턴스를 참조하는 것은 가능할까? 불가능하다. 왜냐면 실제 인스턴스보다 참조 변수가 사용할 수 있는 멤버의 개수가 더 많기 때문에, 존재하지 않은 멤버를 사용하려고 할 수 있기 때문이다. 참조변수가 사용할 수 있는 멤버의 개수는 인스턴스의 멤버 개수보다 같거자 작아야 한다. 

 

조상 타입의 참조변수로 자손 타입의 인스턴스를 참조할 수 있다.

자손 타입의 참조 변수로 조상 타입의 인스턴스를 참조할 수는 없다.

 

[참조 변수의 형변환]

  기본형 변수와 마찬가지로 참조변수도 형변환이 가능하다. 하지만 오로지 상속 관계에 놓여있는 클래스 간에서만 가능하다는 것이 차이점이다. 자손타입을 조상 타입으로 형변환하는 것을 업캐스팅이라고 하는데, 이는 생략이 가능하다. 반면 조상 타입을 자손 타입으로 형변환하는 다운 캐스팅은 생략이 불가능하다. 왜냐면 업캐스팅을 한 경우에는 참조 변수의 멤버가 인스턴스의 멤버보다 적거나 같은 것이 보장이 되는데 반해 다운 캐스팅의 경우에는 참조 변수의 멤버가 인스턴스의 멤버보다 많을 것이기 때문에 생략이 불가능한 것이다. 그래서 참조변수의 형변환은 하기 전에 instanceof 연산자를 이용해서 참조변수가 참조하고 있는 실제 인스턴스의 타입이 무엇인지 체크하는 것이 안전하다. 형변환은 참조 변수의 타입을 변환할 뿐이므로 인스턴스와 관계 없다. 그냥 참조 변수의 타입을 조절함으로써 참조하고 있는 인스턴스에서 사용할 수 있는 멤버의 개수를 제한할 뿐이다. 

 

  Car 클래스를 상속받은 FireEngine 클래스가 있다고 가정하자. 그리고 Car 인스턴스를 가리키는 참조변수 car 와 FireEngine 타입의 참조변수 fe 가 주어졌다. fe = (FireEngine)car 와 같이 하면 down - casting 이므로 컴파일 상 아무런 문제가 발생하지 않는다. 하지만 실제로 car 은 Car 클래스에 대한 인스턴스를 가리키는 참조변수이고 이를 수행하게 되면 결국에 자손 타입의 참조 변수로 조상 타입의 인스턴스를 참조하게 되는 것이다. 이는 위에서 언급하였듯 가능하지 않은 것인데, 그럼에도 컴파일 시에는 오류가 발생하지 않는 것은 그저 참조 변수 간의 관계만 따지기 때문이다. 이와 같은 경우 때문에 instanceof 연산자를 이용하여 참조 변수가 가리키는 인스턴스의 타입이 무엇인지 확인하는 것이 중요하다. 서로 상속 관계에 놓여진 타입 간 형변환은 자유롭지만 참조변수가 가리키는 인스턴스의 자손 타입으로의 형변환은 허용되지 않는 것에 주의하자.

 

[Instanceof 연산자]

  참조변수가 참조하고 있는 인스턴스의 타입을 알기 위해 instanceof 연산자를 사용할 수 있다. 조건문에 주로 사용하며, 왼편에는 참조변수를 오른편에는 타입(클래스명)이 피연산자가 된다. 결과 값은 true/false 의 boolean 으로 주어지며 true 를 반환한다는 것은 참조변수가 testing 한 타입으로의 형변환이 문제없이 수행이 가능하다는 것을 의미한다.

 

void doWork(Car c){

if (c instanceof FireEngine) {

FireEngine fe = (FireEngine)c;

fe.water();

...

}

 위와 같이 사용할 수 있다. 정리하자면 어떤 타입에 대한 instanceof 연산의 결과가 true 라는 것은 검사한 타입으로의 형변환이 가능하다는 것을 시사한다.

 

[참조변수와 인스턴스의 연결]

  조상 클래스에 정의되어 있는 멤버 변수와 중복되는 이름을 가지는 인스턴스 변수를 자손 클래스에서도 정의하였을 때에는 참조 변수의 타입에 따라서 다른 변수를 호출한다. 조상 클래스 타입인 경우에는 조상 클래스에 정의된 변수를 호출하고, 자식 클래스 타입인 경우에는 자식 클래스에 정의된 변수를 호출한다. 메서드의 경우에는 참조 변수의 타입에 관계없이 실제 인스턴스의 메서드가 호출된다. 아래 코드를 보자.

class source{
    public static void main(String[] args) {
        Parent p = new Child();
        Child c = new Child();

        System.out.println("p.x = " + p.x );
        p.method();
        System.out.println("c.x = " + c.x);
        c.method();
    }
}
class Parent{
    int x = 100;
    void method(){
        System.out.println("Parent Method");
    }
}
class Child extends Parent{
    int x = 200;
    void method(){
        System.out.println("Child Method");
    }
}

Parent 타입의 참조변수 p 로 Child 인스턴스를 참조하게 하였고, Child 타입의 참조변수 c 로 Child 인스턴스를 참조하게 하였다. p.x 를 호출한 경우에는 p 가 Parent 타입의 참조변수이므로 Parent 클래스에 정의된 x 값인 100 을 출력하는 것이고 c.x 를 호출한 경우에는 c 가 Child 타입의 참조변수이므로 Child 클래스에 정의된 x 값인 200 이 출력되는 것이다. method() 의 경우에는 실제 인스턴스의 타입을 따라가므로 Child 클래스에 정의된 method() 가 호출된다. 아래와 같이 Child 클래스에 아무것도 작성하지 않는다면 상속받은 클래스와 중복된 멤버 변수나 method 가 존재하지 안흔다. 이러한 경우에는참조변수의 타입에 따른 변화는 없다. 참조 변수의 타입에 따라서 다른 결과를 가져오는 경우는 오로지 조상 클래스의 멤버 변수와 같은 이름의 멤버변수를 자손 클래스에 중복하여 정의한 경우 뿐이다.

class source{
    public static void main(String[] args) {
        Parent p = new Child();
        Child c = new Child();

        System.out.println("p.x = " + p.x );
        p.method();
        System.out.println("c.x = " + c.x);
        c.method();
    }
}
class Parent{
    int x = 100;
    void method(){
        System.out.println("Parent Method");
    }
}
class Child extends Parent{
    // nothing
}

 

[매개변수의 다형성]

class Product{
    int price;
    int bonusPoint;

    Product(int price){
        this.price = price;
        bonusPoint = (int)(price/10.0);
    }
}
class Tv extends Product{
    Tv(){
        super(100);
    }
    public String toString(){return "Tv";}
}
class Computer extends Product{
    Computer(){
        super(200);
    }
    public String toString(){return "Computer";}
}
class Buyer{
    int money = 1000;
    int bonusPoint = 0;

    void buy(Product p){
        if(money < p.price)
        {
            System.out.println("no money");
            return;
        }
        money -= p.price;
        bonusPoint += p.bonusPoint;
        System.out.println("you have purchased " + p);
    }
}
class source{
    public static void main(String[] args) {
        Buyer b = new Buyer();

        b.buy(new Tv());
        b.buy(new Computer());

        System.out.println("balance : $" + b.money);
        System.out.println("bonus Point : " + b.bonusPoint );
    }
}

위 코드를 보면, Product 의 자식 클래스인 Tv, Computer, Audio 가 있고 Buyer 클래스에서 물건을 구입하는 기능이 담긴 메서드인 buy 를 정의하였을 때, 매개변수를 Tv, Computer, Audio 별로 따로 구현하지 않고 공통의 조상 클래스인 Product 로 사용하여 구현하였다, 이와 같이 가능한 것은 매개변수에서도 다형성을 적용할 수 있기 때문이다.

 

[여러 종류의 객체를 배열로 다루기] 

  위에서 Product 의 자식 클래스인 Tv, Computer, Audio 를 각각 개별적으로 다루었는데 Product 타입의 참조변수 배열로 처리하여 보다 간단하게 구현할 수 있다.

 

Product p[] = new Product[3];

p[0] = new Tv();

p[1] = new Computer();

p[2] = new Audio();

 

이를 이용하여 Buyer 클래스를 수정하면 아래와 같다.

class Buyer{
    int money = 1000;
    int bonusPoint = 0;
    Product[] item = new Product[10];
    int i = 0;
    void buy(Product p){
        if(money < p.price)
        {
            System.out.println("no money");
            return;
        }
        money -= p.price;
        bonusPoint += p.bonusPoint;
        item[i++] = p;
        System.out.println("you have purchased " + p);
    }
}

이와 같이 수정하여 배열 item 에 구입한 물건이 저장되도록 구현할 수 있다. 모든 제품 클래스의 조상 클래스인 Product 클래스 타입의 배열을 사용하여 구입한 제품을 하나의 배열로 간단하게 다룰 수 있게 되었다. 다만 item 배열의 크기를 10으로 고정했기 떄문에 물건을 10개보다 많이 사게되는 경우에 대한 대비책이 없다. 이러한 경우에는 배열을 새로 만들고, 복사해주면 되는데 이보다는 Vector 클래스를 사용하는 것이 효율적이다. Vector 클래스는 내부적으로 Object 타입의 배열을 가지고 있고, 크기를 알아서 관리해주기 때문에 인스턴스의 개수를 고려하지 않아도 된다. 

import java.util.Vector;

class Product {
    int price;
    int bonusPoint;

    Product(int price) {
        this.price = price;
        bonusPoint = (int) (price / 10.0);
    }
}

class Tv extends Product {
    Tv() {
        super(100);
    }

    public String toString() {
        return "Tv";
    }
}

class Computer extends Product {
    Computer() {
        super(200);
    }

    public String toString() {
        return "Computer";
    }
}

class Audio extends Product {
    Audio() {
        super(300);
    }

    public String toString() {
        return "Audio";
    }
}

class Buyer {
    int money = 1000;
    int bonusPoint = 0;
    Vector item = new Vector();
    int i = 0;

    void buy(Product p) {
        if (money < p.price) {
            System.out.println("no money");
            return;
        }
        money -= p.price;
        bonusPoint += p.bonusPoint;
        item.add(p);
        System.out.println("you have purchased " + p);
    }

    void refund(Product p) {
        if (item.remove(p)) {
            money += p.price;
            bonusPoint -= p.bonusPoint;
            System.out.println("you have refunded " + p);
        } else {
            System.out.println("something wrong...");
        }
    }

    void summary() {
        int sum = 0;
        String itemList = "";

        if (item.isEmpty()) {
            System.out.println("Something wrong...");
            return;
        }
        for (int i = 0; i < item.size(); i++) {
            Product p = (Product) item.get(i);
            sum += p.price;
            itemList += (i == 0) ? "" + p : ", " + p;
        }
        System.out.println("total price = $" + sum);
        System.out.println("you have purchased " + itemList);
    }
}

class source {
    public static void main(String[] args) {
        Buyer b = new Buyer();
        Tv tv = new Tv();
        Computer com = new Computer();
        Audio audio = new Audio();

        b.buy(tv);
        b.buy(com);
        b.buy(audio);
        b.summary();
        System.out.println();
        b.refund(com);
        b.summary();
    }
}

 

 

---

References

http://www.yes24.com/Product/Goods/24259565

Java의 정석 - YES24