자바의 정석 7장: 객체지향 개념

7️⃣

[ 출처 ]
자바의 정석:
https://product.kyobobook.co.kr/detail/S000001550352
자바의 정석 유튜브:
https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp

1. 상속

3. 클래스 간의 관계 - 포함관계

4. 클래스 간의 관계 결정하기

5. 단일 상속(single inheritance)

6. Object클래스 - 모든 클래스의 조상

7. 오버라이딩(overriding)

8. 오버라이딩의 조건

9. 오버로딩 VS 오버라이딩

10. 참조변수 super

11. super() - 조상의 생성자

12. 패키지(package)

13. 패키지의 선언

14. 클래스 패스(classpath)

15. import문

16. static import문

17. 제어자(modifier)

18. static - 클래스의, 공통적인

19. final - 마지막의, 변경될 수 없는

20. abstract - 추상의, 미완성의

21. 접근 제어자(access modifier)

22. 캡슐화와 접근 제어자

23. 다형성(polymorphisom)

24. 참조변수의 형변환

26. instanceof 연산자

27. 매개변수의 다형성

28. 여러 종류의 객체를 배열로 다루기

31. 추상 클래스(abstract class)

32. 추상 메서드(abstract method)

33. 추상클래스의 작성

34. 인터페이스(interface)

36. 인터페이스의 상속

37. 인터페이스의 구현

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

39. 인터페이스의 장점

40. 디폴트 메서드와 static 메서드

1. 상속

<정의>

기존의 클래스를 재사용하여 새로운 클래스를 작성하는 것

<특징>

• 코드를 공통적으로 관리할 수 있기 때문에 코드의 추가 및 변경이 매우 용이하다

  → 코드의 재사용성을 높이고 코드의 중복을 제거하여 프로그램의 생산성과 유지보수에 크게 기여한다.

자바에서 상속을 구현하는 방법은 새로 작성하고자 하는 클래스의 이름 뒤에 상속받고자 하는 클래스의 이름을 키워드 ‘extends’와 함께 써 주기만 하면 된다.

class Parent() { }
class Child extends Parent {
	// ...
}

<상속계층도>

이 두 클래스는 서로 상속 관계에 있다고 하며, 상속해주는 클래스를 ‘조상 클래스'라 하고 상속 받는 클래스를 ‘자손 클래스’라 한다.

💡

자손 클래스는 조상 클래스의 모든 멤버를 상속받는다.
(단, 생성자와 초기화 블럭은 상속되지 않는다.)
자손 클래스의 멤버 개수는 조상 클래스보다 항상 같거나 많다.

3. 클래스 간의 관계 - 포함관계

상속이외에도 클래스를 재사용하는 또 다른 방법이 있는데, 그것은 클래스 간에 ‘포함(Composite)’ 관계를 맺어 주는 것이다. 클래스 간의 포함관계를 맺어는 것은 한 클래스의 멤버변수로 다른 클래스 타입의 참조변수를 선언하는 것을 뜻한다.

원(Circle)을 표현하기 위한 Circle클래스와 좌표상의 한 점을 다루기 위한 Poin클래스를 다음과 같이 작성되어 있다고 가정하자.

class Circle {
	int x; // 원점의 x좌표
	int y; // 원점의 y좌표
	int r; // 반지름(radius)
}

class Point {
	int x;
	int y;
}

Point 클래스를 재사용해서 Circle 클래스를 작성한다면 다음과 같이 할 수 있을 것이다.

class Circle {
	int x; // 원점의 x좌표
	int y; // 원점의 y좌표
	int r; // 반지름(radius)
}

class class Circle {
	Point p = new Point(); // 원점
	int r; // 반지름(radius)
}

이와 같이 한 클래스를 작성하는 데 다른 클래스를 멤버변수로 선언하여 포함시키는 것은 좋은 생각이다. 하나의 거대한 클래스를 작성하는 것보다 단위별로 여러 개의 클래스를 작성한 다음, 이 단위 클래스들을 포함관계로 재사용하면 보다 간결하고 손쉽게 클래스를 작성할 수 있다.

4. 클래스 간의 관계 결정하기

💡

상속관계 ‘~은 이다.’(is-a)

포함관계 ‘~은 ~을 가지고 있다. ’(has-a)

<예시> - Circle, Point

원은 점이다. - Circle is a Point. (X)

원은 점을 가지고 있다. - Circle has a Point. (O)

→ 포함관계

<예시2> - SportsCar, Car

스포츠카는 차이다. - SportsCar is a Car. (O)

스포츠카는 차를 가지고 있다. - SportsCar has a Car (X)

→ 상속관계

5. 단일 상속(single inheritance)

장점	단점
여러 클래스로부터 상속받을 수 있기 때문에 복합적인 기능을 가진 클래스를 쉽게 작성할 수 있다	- 클래스간의 관계가 매우 복잡해진다 - 서로 다른 클래스로부터 상속받는 멤버간의 이름이 같은 경우 구별할 수 있는 방법이 없다.

자바에서는 단일 상속의 문제점을 해결하기 위해 다중상속의 장점을 포기하고 단일상속만을 허용한다. 단일 상속이 하나의 조상 클래스만을 가질 수 있기 때문에 다중상속에 비해 불편한 점도 있지만, 클래스 간의 관계가 보다 명확해지고 코드를 더욱 신뢰할 수 있게 만들어준다는 점에서 다중상속보다 유리하다.

6. Object클래스 - 모든 클래스의 조상

Object 클래스는 모든 클래스 상속계층도의 최상위에 있는 조상클래스이다. 다른 클래스로부터 상속 받지 않는 모든 클래스들은 자동적으로 Obejct 클래스로부터 상속받게 함으로써 이것을 가능하게한다.

class Tv {
	...
}

→

class Tv extends Object{
	...
}

위의 코드를 컴파일하면 컴파일러는 위의 코드를 다음과 같이 자동적으로 ‘extends Object’를 추가하여 Tv 클래스가 Object 클래스로부터 상속받도록한다.

class Tv {
	...
}

class SmartTv extends Tv {
	...
}

만일 다른 클래스로부터 상속을 받는다고 하더라도 상속계층도를 따라 조상클래스, 조상클래스의 조상클래스를 찾아 올라가다보면 결국 마지막 최상위 조상은 Obejct 클래스일 것이다.

이처럼 모든 상속계층도의 최상위에는 Object 클래스가 위치한다. 그래서 자바의 모든 클래스들은 Object 클래스의 멤버들을 상속받기 때문에 Object 클래스에 정의된 멤버들을 사용할 수 있었다.

그동안 toString() 이나 equals(Object o)와 같은 메서드를 따로 정의하지 않고도 사용할 수 있었던 이유는 이 메서드들이 Object 클래스에 정의된 것들이기 때문이다.

7. 오버라이딩(overriding)

조상 클래스로부터 상속받은 메서드의 내용을 변경하는 것을 오버라이딩이라고 한다. 상속받은 메서드를 그대로 사용하기도 하지만, 자손 클래스 자신에 맞게 변경해야 하는 경우가 많다.

2차원 좌표계의 한 점을 표현하기 위한 Point 클래스가 있을 때, 이를 조상으로 하는 Point3D 클래스, 3차원 좌표계의 한 점을 표현하기 위한 클래스를 다음과 같이 새로 작성하였다고 하자.

class Point {
    int x;
    int y;

    String getLocation() {
        return "x : " + x + ", y : " + y;
    }
}

class Point3D extends Point {
    int z;

    @Override
    String getLocation() { // 오버라이딩
        return super.getLocation() + ", z : " + z;
    }
}

Point 클래스의 getLocation()은 한 점의 x, y 좌표를 문자열로 반환하도록 작성되었다.

이 두 클래스는 서로 상속관계에 있으므로 Point3D 클래스는 Point 클래스로부터 getLocation()을 상속받지만, Point3D 클래스는 3차원 좌표계의 한 점을 표현하기 위한 것이므로 조상인 Point 클래스로부터 상속받은 getLocation()은 Point3D 클래스에 맞지 않는다. 그래서 이 메서드를 Point3D 클래스 자신에 맞게 z축의 좌표값도 포함하여 반환하도록 오버라이딩하였다.

Point 클래스를 사용하던 사람들은 새로 작성된 Point3D 클래스가 Point 클래스의 자손이므로 Point3D 클래스의 인스턴스에 대해서 getLocation()을 호출하면 Point 클래스의 getLocation()이 그랬듯이 점의 좌표를 문자열로 얻을 수 있을 것이라고 기대할 것이다.

그렇기 때문에 새로운 메서드를 제공하는 것보다 오버라이딩을 하는 것이 바른 선택이다.

8. 오버라이딩의 조건

💡

조상 클래스의 메서드를 자손 클래스에서 오버라이딩할 때

1. 선언부가 조상 클래스의 메서드와 일치해야 한다.

2. 접근 제어자는 조상 클래스의 메서드보다 좁은 접위로 변경할 수 없다.

   조상 ≤ 자손

3. 조상 클래스의 메서드보다 많은 수의 예외를 선언할 수 없다.

   자손 ≤ 조상

9. 오버로딩 VS 오버라이딩

오버로딩(overloading) : 기존에 없는 새로운 메서드를 정의하는 것(new)

오버라이딩(overriding) : 상속받은 메서드의 내용을 변경하는 것(change, modify)

class Parent {
	void parentMethod() {}
}

class Child extends Parent {
	void parentMethod() {}      // 오버라이딩   
	void parentMethod(int i) {} // 오버로딩
	
	void childMethod() {}       // 새로운 메서드 정의
	void childMethod(int i) {}  // 오버로딩
	void childMethod() {}       // 에러. 중복정의 되었음 / already defined in Child
}

10. 참조변수 super

super는 자손 클래스에서 조상 클래스로부터 상속받은 멤버를 참조하는데 사용되는 참조변수이다. 멤버변수와 지역변수의 이름이 같을 때 this를 붙여서 구별했듯이 상속받은 멤버와 자신의 멤버와 이름이 같을 때는 super를 붙여서 구별할 수 있다.

class Ex7_2 {
    public static void main(String[] args) {
        Child c = new Child();
    }
}

class Parent {
    int x = 10; /* super.x */
}

class Child extends Parent {
    int x = 20; // this.x

    void method() {
        System.out.println("x = " + x);
        System.out.println("this.x  = " + this.x);
        System.out.println("super.x  = " + super.x);
    }
}

<실행결과>
x = 20
this.x = 20
super.x = 10

위의 예제에서 Child 클래스는 조상인 Parent 클래스로부터 x를 상속받는데, 공교롭게도 자신의 멤버인 x와 이름이 같아서 이 둘을 구분할 방법이 필요하다. 바로 이럴 때 사용하는 것이 super다.

아래의 경우 x, this.x, super.x 모두 같은 변수를 의미하므로 모두 같은 값이 출력되었다.

class Ex7_2 {
    public static void main(String[] args) {
        Child c = new Child();
    }
}

class Parent {
    int x = 10; /* super.x와 this.x 둘 다 가능 */
}

class Child extends Parent {
    void method() {
        System.out.println("x = " + x);
        System.out.println("this.x  = " + this.x);
        System.out.println("super.x  = " + super.x);
    }
}

<실행결과>
x = 10
this.x = 20
super.x = 10

모든 인스턴스 메서드에는 this와 super가 지역변수로 존재하는데, 이들에는 자신이 속한 인스턴스의 주소가 자동으로 저장된다. 조상의 멤버와 자신의 멤버를 구별하는데 사용된다는 점만 제외하면 this와 super는 근본적으로 같다.

11. super() - 조상의 생성자

super()는 조상의 생성자를 호출하는데 사용된다.

class Point {
	int x, y;

	Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
}

class Point3D extends Point{
	int x, y;

	Point(int x, int y, int z) {
		this.x = x; // 조상의 멤버를 초기화
		this.y = y; // 조상의 멤버를 초기화
		this.z = z;
	}
}

위의 코드에서는 Point3D 클래스의 생성자가 조상인 Point 클래스로부터 상속받은 x, y를 초기화한다. 틀린 코드는 아니지만, 생성자 Point3D()를 아래처럼 조상의 멤버는 조상의 생성자를 통해 초기화되도록 하는 것이 바람직하다.

Point3D(int x, int y, int z) {
	super(x, y); // 조상클래스의 생성자 Point(int x, int y)를 호출
	this.z = z;  //자신의 멤버를 초기화
}

12. 패키지(package)

패키지란, 클래스의 묶음이다. 패키지에는 클래스 또는 인터페이스를 포함시킬 수 있으며, 서로 관련된 클래스들끼리 그룹 단위로 묶어 놓음으로써 클래스를 효율적으로 관리할 수 있다.

같은 이름의 클래스일지라도 서로 다른 패키지에 존재하는 것이 가능하므로, 자신만의 패키지 체계를 유지함으로써 다른 개발자가 개발한 클래스 라이브러리의 클래스와 이름이 충돌하는 것을 피할 수 있다.

지금까지는 단순히 클래스 이름으로만 클래스를 구분했지만, 사실 클래스의 실제 이름(full name)은 패키지명을 포함한 것이다.

예를 들면 String 클래스의 실제 이름은 java.lang.String이다. java.lang패키지에 속한 String 클래스라는 의미이다. 그래서 같은 이름의 클래스일지라도 서로 다른 패키지에 속하면 패키지명으로 구별이 가능하다.

클래스가 물리적으로 하나의 클래스파일(.class)인 것과 같이 패키지는 물리적으로 하나의 디렉토리이다. 그래서 어떤 패키지에 속한 클래스는 해당 디렉토리에 존재하는 클래스파일(클래스 이름.class)이어야 한다.

예를 들어, java.lang.String 클래스는 물리적으로 디렉토리 java의 서브디렉토리인 lang에 속한 String.class 파일이다. 그리고 우리가 자주 사용하는 System 클래스 역시 java.lang 패키지에 속하므로 lang디렉토리에 포함되어 있다.

String 클래스는 rt.jar 파일에 압축되어 있으며, 이 파일의 압축을 풀면 아래의 그림과 같다.

디렉토리가 하위 디렉토리를 가질 수 있는 것처럼, 패키지도 다른 패키지를 포함할 수 있으며 점'.’으로 구분한다. 예를 들면 java.lang 패키지에서 lang 패키지는 java 패키지의 하위패키지이다.

13. 패키지의 선언

패키지는 클래스나 인터페이스의 소스파일(.java)의 맨 위에 다음과 같이 한 줄만 적어주면 된다.

package 패키지명;

• 패키지 선언문은 반드시 소스파일에서 주석과 공백을 제외한 첫 번째 문장이어야하며, 하나의 소스파일에 단 한 번만 선언될 수 있다.

• 클래스명과 쉽게 구분하기 위해 소문자로 하는 것을 원칙으로 한다.

14. 클래스 패스(classpath)

PackageTest 클래스가 com.codechobo.book 패키지에 포함되어 있다면 클래스 파일인 PackageTest.class는 아래의 그림과 같이 com 폴더 안의 codechobo 폴더 안의 book 폴더 안에 있어야 한다.

이제는 패키지의 루트 디렉토리를 클래스패스(classpath)에 포함시켜야 한다. com.codechobo.book 패키지의 루트 디렉토리는 디렉토리 ‘com’의 상위 디렉토리인 ‘C:\jdk1.8\work’이다. 이 디렉토리를 클래스패스에 포함시켜야만 실행 시 JVM이 PackageTest 클래스를 찾을 수 있다.

Windows에서는 ‘제어판 - 시스템 - 고급 시스템 설정 - 환경변수 - 새로 만들기’에서 변수이름에 ‘CLASSPATH’를 입력하고 변수 값에는 ‘.;c:\jdk1.8\work’를 입력한다.

‘;’를 구분자로하여 여러 개의 경로를 클래스패스에 지정할 수 있으며, 맨 앞에 ‘.;’를 추가한 이유는 현재 디렉토리(.)를 클래스패스에 포함시키기 위해서이다.

클래스패스를 지정해 주지 않으면 기본적으로 현재 디렉토리(.)가 클래스패스로 지정되지만, 이처럼 클래스패스를 따로 지정해주는 경우에는 더 이상 현재 디렉토리가 자동적으로 클래스패스로 지정되지 않기 때문에 이처럼 별도로 추가를 해주어야 한다.

jar파일을 클래스패스에 추가하기 위해서는 경로와 파일명을 적어주어야 한다. 예를 들어 ‘C:\jdk1.8\work\util.jar’파일을 클래스패스에 포함시키려면 다음과 같이 한다

C:\WINDOWS>SET CLASSPATH=.;C:\jdk1.8\work;C:\jdk1.8\work\util.jar;

15. import문

import문으로 클래스의 패키지명을 생략할 수 있다.

java util Date today 
= new java.util.Data();

→

import java.util.Date;
...
Date today = new Date();

import문의 역할은 컴파일러에게 소스파일에 사용된 클래스의 패키지에 대한 정보를 제공하는 것이다. 컴파일 시에 컴파일러는 import문을 통해 소스파일에 사용된 클래스의 패키지를 알아 낸 다음, 모든 클래스 이름 앞에 패키지명을 붙여준다.

// 키워드 import와 패키지명을 생략하고자 하는 클래스의 이름을 패키지명과 함께 써주면 된다.
import 패키지명.클래스명;
	또는
// 같은 패키지에서 여러 개의 클래스가 사용될 때,
//import문을 여러 번 사용하는 대신 ‘패키지명.*’을 이용해서 지정된 패키지에 속하는 모든 클래스를 패키지명 없이 사용할 수 있다.
import 패키지명.*;

클래스 이름을 지정해주는 대신 ‘*’을 사용하면, 컴파일러는 해당 패키지에서 일치하는 클래스 이름을 찾아야 하는 수고를 더 해야 할 것이다. 단지 그 뿐이다. 실행 시 성능상의 차이는 전혀 없다.

16. static import문

static import문을 사용하면 static멤버를 호출할 때 클래스 이름을 생략할 수 있다.

import static java.lang.Integer.*; // Integer 클래스의 모든 static 메서드
import static java.lang.Math.random; // Math.random()만. 괄호 안 붙임
import static java.lang.System.out; // System.out을 out만으로 참조가능

위와 같이 static import문을 선언하였다면, 아래의 왼쪽 코드를 오른쪽 코드와 같이 간략히 할 수 있다.

System.out.println(Math.random());

→

out.println(random());

// 예제 7-6
import static java.lang.System.out;
import static java.lang.Math.*;
class Ex7_2 {
    public static void main(String[] args) {
        // System.out.println(Math.random());
        out.println(random());

        // System.out.println("Math.PI : " + Math.PI);
        System.out.println("Math.PI : " + PI);
    }
}

17. 제어자(modifier)

제어자(modifier)는 클래스, 변수 또는 메서드의 선언부에 함께 사용되어 부가적인 의미를 부여한다.

제어자의 종류는 크게 접근 제어자와 그 외의 제어자로 나눌 수 있다.

💡

접근 제어자 private, (default), protected, private

그 외 static, final, abstract, native, transient, synchronized, volatile, strictfp

제어자는 클래스와 멤버변수와 메서드에 주로 사용되며, 하나의 대상에 대해서 여러 제어자를 조합하여 사용하는 것이 가능하다.

18. static - 클래스의, 공통적인

💡

static이 사용될 수 있는 곳 - 멤버변수, 메서드 초기화 블럭

대상	의미
멤버변수	- 모든 인스턴스에 공통적으로 사용되는 클래스 변수가 된다. - 클래스 변수는 인스턴스를 생성하지 않고도 사용 가능하다. - 클래스가 메모리에 로드될 때 생성된다.
메서드	- 인스턴스를 생성하지 않고도 호출이 가능한 static 메서드가 된다. - static메서드 내에서는 인스턴스 멤버들을 직접 사용할 수 없다.

인스턴스 멤버를 사용하지 않는 메서드는 static을 붙여서 static 메서드로 선언하는 것을 고려해보도록 하자. 가능하다면 static 메서드로 하는 것이 인스턴스를 생성하지 않고도 호출이 가능해서 더 편리하고 속도도 더 빠르다.

class StaticTest {
	static int width = 200;        // 클래스 변수(static 변수)
	static int hegith = 120;       // 클래스 변수(static 변수)

	satic {                        // 클래스 초기화 블럭
		// static 변수의 복잡한 초기화 수행
	}

	static int max(int a, int b) { // 클래스 메서드(static 메서드)
		return a > b ? a : b;
	}
}

19. final - 마지막의, 변경될 수 없는

💡

final이 사용될 수 있는 곳 - 클래스, 메서드, 멤버변수, 지역변수

대상	의미
클래스	변경될 수 없는 클래스, 확장될 수 없는 클래스가 된다. 그래서 final로 지정된 클래스는 다른 클래스의 조상이 될 수 없다.
메서드	변경될 수 없는 메서드, final로 지정된 메서드는 오버라이딩을 통해 재정의 될 수 없다.
멤버변수	변수 앞에 final이 붙으면, 값을 변경할 수 없는 상수가 된다.
지역변수	“”

+) final 클래스의 대표적인 예는 String과 Math이다.

final class FinalTest { // 조상이 될 수 없는 클래스
	final int MAX_SIZE = 10; // 값을 변경할 수 없는 멤버변수(상수)

	final void getMaxSize() { // 오버라딩할 수 없는 메서드(변경불가)
		final int LV = MAX_SIZE; // 값을 변경할 수 없는 지역변수(상수)
		return MAX_SIZE;
	}
}

20. abstract - 추상의, 미완성의

💡

abstract가 사용될 수 있는 곳 - 클래스, 메서드

대상	의미
클래스	클래스 내에 추상 메서드가 선언되어 있음을 의미한다.
메서드	선언부만 작성하고 구현부는 작성하지 않은 추상 메서드임을 알린다.

abstract class AbstractTest { // 추상 클래스(추상 메서드를 포함한 클래스)
	abstract void move();       // 추상 메서드(구현부가 없는 메서드)
}

// 추상 클래스는 아직 완성되지 않은 메서드가 존재하는 '미완성 설계도'이므로 인스턴스를 생성할 수 없다.
AbstractTest a = new AbstractTest(); // 에러. 추상 클래스의 인스턴스 생성 불가

21. 접근 제어자(access modifier)

💡

접근 제어자가 사용될 수 있는 곳 - 클래스, 멤버변수, 메서드, 생성자

private	같은 클래스 내에서만 접근이 가능하다.
default	같은 패키지 내에서만 접근이 가능하다.
protected	같은 패키지 내에서, 그리고 다른 패키지의 자손 클래스에서 접근이 가능하다.
private	접근 제한이 없다.

22. 캡슐화와 접근 제어자

💡

접근 제어자를 사용하는 이유
- 외부로부터 데이터를 보호하기 위해서
- 외부에는 불필요한, 내부적으로만 사용되는 부분을 감추기 위해서

데이터가 유효한 값을 유지하도록, 또는 비밀번호와 같은 데이터를 외부에서 함부로 변경하지 못하도록 하기 위해서는 외부로부터의 접근을 제한하는 것이 필요하다.

이것을 데이터 감추기(data hiding)라고 하며, 객체지향 개념의 캡슐화(encapsulation)에 해당하는 내용이다.

---

예제

시간을 표시하기 위한 클래스

public class Time {
	public int hour;
	public int minute;
	public int seconde;
}

Time t = new Time();
t.hour = 25; // 멤버변수에 직접 접근

멤버변수 hour는 0보다는 같거나 크고 24보다는 작은 범위의 값을 가져야 하지만 위의 코드에서처럼 잘못된 값을 지정한다고 해도 이것을 막을 방법은 없다. 이런 경우 멤버변수를 private이나 protected로 제한하고 멤버변수의 값을 읽고 변경할 수 있는 public 메서드를 제공함으로써 간접적으로 멤버변수의 값을 다룰 수 있도록 하는 것이 바람직하다.

public class Time {
	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 int setMinute() {
		if( minute < 0 || minute > 59 ) return;
		this.minute = minute;
	}
	public int getSecond() { return second; }
	public void setSecond() {
	  if( second < 0 || second > 59 ) return;
		this.second = second;
	}

}

만일 상속을 통해 확장될 것이 예상되는 클래스라면 멤버에 접근 제한을 주되 자손클래스에서 접근하는 것이 가능하도록 하기 위해 private 대신 protected를 사용한다.

23. 다형성(polymorphisom)

💡

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

다형성이란 ‘여러 가지 형태를 가질 수 있는 능력’을 의미하며, 자바에서는 조상 클래스 타입의 참조변수로 자손 클래스의 인스턴스를 참조할 수 있도록 하는 것을 의미한다.

CaptionTv c = new CaptionTv(); // 참조 변수와 인스턴스 타입이 일치
Tv        t = new CaptionTv(); // 조상 타입 참조변수로 자손 타입 인스턴스 참조

위의 경우 실제 인스턴스가 CaptionTv 타입이라 할지라도, 참조변수 t로는 CaptionTv 인스턴스의 모든 멤버를 사용할 수 없다.

Tv 타입의 참조변수로는 CaptionTv 인스턴스 중에서 Tv 클래스의 멤버들(상속받은 멤버포함)만 사용할 수 있다. 따라서, 생성된 Caption 인스턴스 멤버 중에서 Tv 클래스에 정의되지 않은 멤버, text와 caption()은 참조변수 t로 사용이 불가능하다. 즉, t.text 또는 t.caption()와 같이 할 수 없다는 것이다. 둘 다 같은 타입의 인스턴스지만 참조변수 타입에 따라 사용할 수 있는 멤버의 개수가 달라진다.

반대로 아래와 같이 자손 타입의 참조변수로 조상 타입의 인스턴스를 참조하는 것은 가능할까?

Caption c = new Tv(); // 에러. 허용 안 됨.

위의 코드를 컴파일하면 에러가 발생한다. 실제 인스턴스인 Tv의 멤버 개수보다 참조변수 c가 사용할 수 있는 멤버 개수가 더 많기 때문이다. 그래서 이를 허용하지 않는다.

24. 참조변수의 형변환

💡

서로 상속 관계에 있는 타입간의 형변환은 양방향으로 자유롭게 수행될 수 있으나 참조변수가 가리키는 인스턴스의 자손타입으로 형변환은 허용되지 않는다.
그래서 참조변수가 가리키는 인스턴스의 타입이 무엇인지 먼저 확인하는 것이 중요하다.

class Ex7_7 {
    public static void main(String[] args) {
        Car car = null;
        FireEngine fe = new FireEngine();
        FireEngine fe2 = null;

        fe.water();
        car = fe; // car = (Car) fe; 에서 형변환이 생략됨 
        // car.water(); // 컴파일 에러!!! Car 타입의 참조변수로는 water()를 호출할 수 없다. 
        fe2 = (FireEngine) car; // 조상타입 -> 자손타입. 형변환 생략 불가 
        fe2.water();
    }
}

class Car {
    String color;
    int door;

    void drive() {
        System.out.println("drive, Brrrr~");
    }

    void stop() {
        System.out.println("stop!!!!");
    }
}

class FireEngine extends Car {
    void water() {
        System.out.println("water!!!");
    }
}

이 예제에서 중요한 부분은 다음의 두 줄이며, 그림으로 그려보면 아래와 같다.

FireEngine fe = new FireEngine(); // FireEngine 객체를 생성
car = (Car) fe;                   // fe의 값을 car에 저장.(형변환 생략됨)

참조변수 fe의 값을 car에 저장하여 car로도 FireEngine 인스턴스를 다룰 수 있게 되었다. 다만 참조변수 fe와 달리 car로는 FireEngine 인스턴스의 멤버 중 4개만 사용 가능하다.

26. instanceof 연산자

💡

어떤 타입에 대한 instanceof 연산의 결과가 true라는 것은 검사한 타입으로 형변환이 가능하다는 것을 뜻한다.

참조변수가 참조하고 있는 인스턴스의 실제 타입을 알아보기 위해 instanceof 연산자를 사용한다. 주로 조건문에 사용되며, instanceof의 왼쪽에는 참조변수를, 오른쪽에는 타입(클래스명)이 피연산자로 위치한다. 그리고 연산의 결과로 boolean값인 true와 false중의 하나를 반환한다.

instanceof를 이용한 연산결과로 true를 얻었다는 것은 참조변수가 검사한 타입으로 형변환이 가능하다는 것을 뜻한다.

void doWork(Car c) {
	if(c instanceof FireEngine) {    // 1. 형변환이 가능한지 확인.
		FireEngine fe = (FireEngine)c; // 2. 형변환
		fe.water();
	}
}

위의 코드는 Car타입의 참조변수 c를 매개변수로 하는 메서드이다. 이 메서드가 호출될 때, 매개변수로 Car 클래스 또는 그 자손 클래스의 인스턴스를 넘겨받겠지만 메서드 내에서는 정확히 어떤 인스턴스인지 알 길이 없다. 그래서 instanceof 연산자로 참조변수 c가 가리키고 있는 인스턴스 타입을 체크하고, 적절히 형변환한 다음에 작업을 해야 한다.

조상타입 참조변수로 자손타입의 인스턴스를 참조할 수 있기 때문에, 참조변수의 타입과 인스턴스 타입이 항상 일치하지 않다는 것을 배웠다. 조상타입의 참조변수로는 실제 인스턴스의 멤버들을 모두 사용할 수 없기 때문에, 실제 인스턴스와 같은 타입의 참조변수로 형변환을 해야만 인스턴스의 모든 멤버들을 사용할 수 있다.

27. 매개변수의 다형성

참조변수의 다형적인 특징은 메서드의 매개변수에도 적용된다. 아래와 같이 Product, Tv, Computer, Buyer 클래스가 정의되어 있다고 가정하자.

class Product {
	int price;                      // 제품의 가격
	int bonusPoint;                 // 제품구매 시 제공하는 보너스 포인트
}

class Tv extends Product {}
class Computer extends Product {}

class Buyer {                     // 고객, 물건을 사는 사람
	int money = 1000;               // 소유금액
	int bonusPoint = 0;             // 보너스 포인트
}

Product 클래스는 Tv와 Computer 클래스의 조상이며, Buyer 클래스는 제품(Product)를 구입하는 사람을 클래스로 표현한 것이다.

Buyer 클래스에 물건을 구입하는 기능의 메서드를 추가해보자. 구입할 대상이 필요하므로 매개변수로 구입할 제품을 넘겨받아야 한다. Tv를 살 수 있도록 매개변수를 Tv타입으로 하였다.

void buy(Tv t) {
	// Buyer가 가진 돈(money)에서 제품의 가격(t.price)만큼 뺀다.
	money = money - t.price;
	
	// Buyer의 보너스점수(bonusPoint)에 제품의 보너스점수(t.bonusPoint)를 더한다.
	bonusPoint = bonusPoint + t.bonusPoint;
}

buy(Tv t)는 제품을 구입하면 제품을 구입한 사람이 가진 돈에서 제품의 가격을 빼고, 보너스 점수는 추가하는 작업을 하도록 작성되었다. 그런데 buy(Tv t)로는 Tv밖에 살 수 없기 때문에 아래와 같이 다른 제품들도 구입할 수 있는 메서드가 추가로 필요하다.

void buy(Computer c) {
	money = money - t.price;
	bonusPoint = bonusPoint + t.bonusPoint;
}

이렇게 되면, 제품의 종류가 늘어날 때마다 Buyer 클래스에는 새로운 buy메서드를 추가해주어야 할 것이다.

그러나 메서드의 매게변수에 다형성을 적용하면 아래와 같이 하나의 메서드로 간단히 처리할 수 있다.

void buy(Computer p) {
	money -= p.price;
	bonusPoint += p.bonusPoint;
}

→

void buy(Product p) {
	money -= p.price;
	bonusPoint += p.bonusPoint;
}

매개변수가 Product 타입의 참조변수라는 것은, 메서드의 매개변수로 Product 클래스의 자손타입의 참조변수면 어느 것이나 매개변수로 받아들일 수 있다는 것이다.

그리고 Product 클래스에 price와 bonusPoint가 선언되어 있기 때문에 참조변수 p로 인스턴스의 price와 bonusPoint를 사용할 수 있기에 이와 같이 할 수 있다.

앞으로 다른 제품 클래스를 추가할 때 Product 클래스를 상속받기만 하면, buy(Product p)메서드의 매개변수로 받아들여질 수 있다.

Buyer b = new Buyer();
Tv t = new Tv();
Computer c = new Computer();

b.buy(t); // b.buy(new Tv());
t.buy(c); // b.buy(new Computer());

Tv 클래스와 Computer 클래스는 Product 클래스의 자손이므로 위의 코드와 같이 buy(Product p) 메서드에 매개변수로 Tv 인스턴스와 Computer 인스턴스를 제공하는 것이 가능하다.

// 예제 7-8

class Product {
	int price;                      // 제품의 가격
	int bonusPoint;                 // 제품구매 시 제공하는 보너스 포인트

	Product(int price) {
		this.price = price;
		bonusPoint = (int)(price / 10.0); // 보너스 점수는 제품 가격의 10%
	}
}

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("잔액이 부족하여 물건을 살 수 없습니다.");
			return;
		}

		money -= p.price;
		bonusPoint += p.bonusPoint;
		System.out.println(p + "을/를 구입하셨습니다.");
	}
}

class Ex7_8 {
	public static void main(String args[]) {
		Buyer b = new Buyer();

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

		System.out.println("현재 남은 돈은 " + b.money + "만원입니다.");
		System.out.println("현재 보너스 점수는 " + b.bonusPoint + "점입니다.");
	}

}

<결과>
Tv을/를 구입하셨습니다.
Computer을/를 구입하셨습니다.
현재 남은 돈은 700만원입니다.
현재 보너스 점수는 30점입니다.

28. 여러 종류의 객체를 배열로 다루기

Product p1 = new Tv();
Product p2 = new Computer();
Product p3 = n ew Audio();

→

Product p[] = new Product[3];
p[0] = new Tv();
p[1] = new Computer();
p[2] = new Audio();

왼쪽의 코드를 Product 타입의 참조변수 배열로 처리하면 오른쪽과 같다.

이처럼 조상타입의 참조변수 배열을 사용하면, 공통의 조상을 가진 서로 다른 종류의 객체를 배열로 묶어서 다룰 수 있다. 또는 묶어서 다루고 싶은 객체들의 상속관계를 따져서 가장 가까운 공통조상 클래스 타입의 참조변수 배열을 생성해서 객체들을 저장하면 된다.

// 예제 7-9
class Product {
	int price;                      // 제품의 가격
	int bonusPoint;                 // 제품구매 시 제공하는 보너스 포인트

	Product(int price) {
		this.price = price;
		bonusPoint = (int)(price / 10.0); // 보너스 점수는 제품 가격의 10%
	}

    Product() {

    }
}

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(50); 
    }

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

class Buyer {                         // 고객, 물건을 사는 사람
	int money = 1000;                 // 소유금액
	int bonusPoint = 0;               // 보너스 포인트
    Product[] cart = new Product[10]; // 구입한 제품을 저장하기 위한 배열
    int i = 0;

	void buy(Product p) {
		if( money < p.price ) {
			System.out.println("잔액이 부족하여 물건을 살 수 없습니다.");
			return;
		}

		money -= p.price;             // 가진 돈에서 구입한 제품의 가격을 뺀다.
		bonusPoint += p.bonusPoint;   // 제품의 보너스 포인트를 추가한다.
        cart[i++] = p;                // 제품을 Product[] cart에 저장한다.
		System.out.println(p + "을/를 구입하셨습니다.");
	}

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

        for(int i = 0; i < cart.length; i++) {
            if(cart[i] == null) break;

            sum += cart[i].price;
            itemList += cart[i] + ", ";
        }

        System.out.println("구입하신 물품의 총 금액은 " + sum + "만원입니다.");
        System.out.println("구입하신 제품은 " + itemList + "입니다.");

    }
}

class Ex7_7 {
	public static void main(String args[]) {
		Buyer b = new Buyer();

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

        b.summary();
	}

}

<결과>
Tv을/를 구입하셨습니다.
Computer을/를 구입하셨습니다.
Audio을/를 구입하셨습니다.
구입하신 물품의 총 금액은 350만원입니다.
구입하신 제품은 Tv, Computer, Audio, 입니다.

31. 추상 클래스(abstract class)

💡

추상 클래스 미완성 설계도. 인스턴스 생성불가
미완성 메서드(추상 메서드)를 포함하고 있는 클래스

추상 클래스 자체로는 클래스로서의 역할을 다 못하지만, 새로운 클래스를 작성하는데 있어서 바탕이 되는 조상 클래스로서 중요한 의미를 같는다. 새로운 클래스를 작성할 때 아무것도 없는 상태에서 시작하는 것보다는 완전하지는 못하더라도 어느 정도 틀을 갖춘 상태에서 시작하는 것이 나을 것이다.

실생활에서 예를 들자면, 같은 크기의 TV라도 기능의 차이에 따라 여러 종류의 모델이 있지만, 사실 이 들의 설계도는 아마 90%정도는 동일할 것이다. 서로 다른 세 개의 설계도를 따로 그리는 것보다는 이들의 공통부분만을 그린 미완성 설계도를 만들어 놓고, 이 미완선 설계도를 이용해서 각각의 설계도를 완성하는 것이 훨씬 효율적일 것이다.

추상 클래스는 키워드 ‘abstract’를 붙이기만 하면 된다. 이렇게 함으로써 이 클래스를 사용할 때, 클래스 선언부의 abstract를 보고 이 클래스에는 추상메서드가 있으니 상속을 통해서 구현해주어야 한다는 것을 쉽게 알 수 있을 것이다.

abstract class 클래스이름 {
	...
}

추상 클래스는 추상 메서드를 포함하고 있다는 것을 제외하고는 일반 클래스와 전혀 다르지 않다. 추상 클래스에도 생성자가 있으며, 멤버변수와 메서드도 가질 수 있다.

32. 추상 메서드(abstract method)

💡

추상 메서드 미완성 메서드.
선언부만 작성하고 구현부는 작성하지 않은 채로 남겨 둔 것

메서드를 이와 같이 미완성 상태로 남겨 놓는 이유는 메서드의 내용이 상속받는 클래스에 따라 달라질 수 있기 때문에 조상 클래스에서는 선언부만을 작성하고, 주석을 덧붙여 어떤 기능을 수행할 목적으로 작성되었는지 알려 주고, 실제 내용은 상속받는 클래스에서 구현하도록 비워 두는 것이다. 그래서 추상클래스를 상속받는 자손 클래스는 조상의 추상메서드를 상황에 알맞게 적절히 구현해주어야 한다.

추상메서드 역시 키워드 ‘abstract’를 앞에 붙여 주고, 추상메서드는 구현부가 없으므로 괄호{} 대신 문장의 끝을 알리는 ‘;’을 적어준다.

/* 주석을 통해 어떤 기능을 수행할 목적으로 작성하였는지 설명한다. */
abstract 리턴타입 메서드이름();

추상클래스로부터 상속받는 자손 클래스는 오버라이딩을 통해 조상인 추상클래스의 추상메서드를 모두 구현해주어야 한다. 만일 조상으로부터 상속받는 추상메서드 중 하나라도 구현하지 않는다면, 자손클래스 역시 추상클래스로 지정해 주어야 한다.

abstract class Player { // 추상클래스
	abstract void play(int pos);         // 추상메서드
	abstract void stop();                // 추상메서드
}

class AudioPlayer extends Player {
	void play(int pos) { /* 내용 생략 */ } // 추상메서드를 구현
	void stop() { /* 내용 생략 */ }        // 추상메서드를 구현

}

실제 작업내용인 구현부가 없는 메서드가 무슨 의미가 있을까 싶기도 하겠지만, 메서드를 작성할 때 실제 작업내용인 구현부보다 더 중요한 부분이 선언부이다.

메서드를 사용하는 쪽에서는 메서드가 실제로 어떻게 구현되어있는지 몰라도 메서드의 이름과 매개변수, 리턴타입, 즉 선언부만 알고 있으면 되므로 내용이 없을 지라도 추상메서드를 사용하는 코드를 작성하는 것이 가능하며, 실제로는 자손클래스에 구현된 완성된 메서드가 호출되도록 할 수 있다.

33. 추상클래스의 작성

여러 클래스에 공통적으로 사용될 수 있는 클래스를 바로 작성하기도 하고, 기존의 클래스의 공통적인 부분을 뽑아서 추상클래스로 만들어 상속하도록 하는 경우도 있다.

참고로 추상의 사전적 정의는 다음과 같다.

💡

추상 미완성 설계도. 인스턴스 생성불가
미완성 메서드(추상 메서드)를 포함하고 있는 클래스

상속이 자손 클래스를 만드는데 조상 클래스를 사용하는 것이라면, 이와 반대로 추상화는 기존의 클래스의 공통부분을 뽑아내서 조상 클래스를 만드는 것이라고 할 수 있다.

추상화를 구체화와 반대대는 의미로 이해하면 보다 쉽게 이해할 수 있다. 상속계층도를 따라 내려갈수록 클래스는 점점 기능이 추가되어 구체화의 정도가 심해지며, 상속계층도를 따라 올라갈수록 클래스는 추상화의 정도가 심해진다고 할 수 있다. 즉, 상속계층도를 따라 내려 갈수록 세분화되며, 올라갈수록 공통요소만 남게된다.

유명한 컴퓨터 게임에 나오는 유닛들을 클래스로 간단히 정의해보았다. 이 유닛들을 각자 나름대로의 기능을 가지고 있지만 공통부분을 뽑아내어 하나의 클래스로 만들고, 이 클래스로부터 상속받도록 변경해보자.

class Marine { // 보병
	int x, y;    // 현재 위치
	void move(int x, int y) { /* 지정된 위치로 이동 */ }
	void stop()             { /* 현재 위치에 정지  */ }
	void stimPack()         { /* 스팀팩을 사용한다. */ }
}

class Tank { // 탱크
	int x, y;  // 현재 위치
	void move(int x, int y) { /* 지정된 위치로 이동 */ }
	void stop()             { /* 현재 위치에 정지  */ }
	void changeMode()       { /* 공격모드를 변환한다. */ }
}

class Dropship{ // 수송선
	int x, y;  // 현재 위치
	void move(int x, int y) { /* 지정된 위치로 이동 */ }
	void stop()             { /* 현재 위치에 정지  */ }
	void load()             { /* 선택된 대상을 태운다. */ }
	void unload()           { /* 선택된 대상을 내린다. */ }
}

abstract class Unit {
	int x, y;
	abstract void move(int x, int y);
	void stop();
}

class Marine extends Unit { // 보병
	void move(int x, int y) { /* 지정된 위치로 이동 */ }
	void stimPack()         { /* 스팀팩을 사용한다. */ }
}

class Tank extends Unit { // 탱크
	void move(int x, int y) { /* 지정된 위치로 이동 */ }
	void changeMode()       { /* 공격모드를 변환한다. */ }
}

class Dropship extends Unit { // 수송선
	void move(int x, int y) { /* 지정된 위치로 이동 */ }
	void load()             { /* 선택된 대상을 태운다. */ }
	void unload()           { /* 선택된 대상을 내린다. */ }
}

각 클래스의 공통 부분을 뽑아내서 Unit 클래스를 정의하고 이로부터 상속받도록 하였다. 이 Unit클래스는 다른 유닛을 위한 클래스를 작성하는데 재활용될 수 있을 것이다.

이들 클래스에 대해서 stop메서드는 선언부와 구현부 모두 공통적이지만, Marine, Tank는 지상유닛이고 Dropship은 공중유닛이기 때문에 이동하는 방법이 서로 달라서 move메서드의 실제 구현 내용이 다를 것이다.

그래서 move메서드의 선언부는 같기 때문에 추상메서드로 정의할 수 있다. 최대한의 공통 부분을 뽑아내기 위한 것이기도 하지만, 모든 유닛은 이동할 수 있어야 하므로 Unit클래스에는 move메서드가 반드시 필요한 것이기 때문이다.

move메서드가 추상메서드로 선언된 것은, 앞으로 Unit클래스를 상속받아서 작성되는 클래스는 move메서드를 자신의 클래스에 알맞게 구현해야 한다는 의미가 담겨 있는 것이기도 하다.

Unit[] group = new Unit[3];
group[0] = new Marine();
group[1] = new Tank();
group[2] = new Dropship();

for(int i = 0; i < group.length; i++) {
	group[i].move(100, 200); // Unit 배열의 모든 유닛을 좌표(100, 200)의 위치로 이동한다.
}

34. 인터페이스(interface)

인터페이스는 일종의 추상클래스이다. 인터페이스는 추상클래스처럼 추상메서드를 갖지만 추상클래스보다 추상화 정도가 높아서 추상클래스와 달리 몸통을 갖춘 일반 메서드 또는 멤버변수를 구성원으로 가질 수 없다. 오직 추상메서드와 상수만을 멤버로 가질 수 있으며, 그 외의 다른 어떠한 요소도 허용되지 않는다.

추상메서드 = 미완성 설계되(부분적으로만 완성된)

인터페이스 = 기본 설계도(구현된 것은 아무것도 없고 밑그림만 그려져 있음)

인터페이스도 추상클래스처럼 완성되지 않은 불완전한 것이기 때문에 그 자체만으로 사용되기 보다는 다른 클래스를 작성하는데 도움 줄 목적으로 작성된다.

인터페이스를 작성하는 것은 클래스를 작성하는 것과 같다. 다만 키워드로 class 대신 interface를 사용한다는 것만 다르다. 그리고 interface에도 클래스처럼 접근제어자로 public 또는 default만 사용할 수 있다.

interface 인터페이스이름 {
	public static final 타입 상수이름 = 값;
	public abstract 메서드이름(매개변수목록);
}

일반적인 클래스와 달리 인터페이스의 멤버들은 다음과 같은 제약사항이 있다.

❕

- 모든 멤버변수는 public static final 이어야 하며, 이를 생략할 수 있다.
- 모든 메서드는 public abstract 이어야 하며, 이를 생략할 수 있다.
단, static 메서드와 디폴트 메서드는 예외(JDK1.8 부터)

인터페이스에 정의된 모든 멤버에 예외없이 적용되는 사항이기 때문에 제어자를 생략할 수 있는 것이며, 편의상 생략하는 경우가 많다. 생략된 제어자는 컴파일 시에 컴파일러가 자동적으로 추가해준다.

interface PlayingCard {
	public static final int SPADE = 4;
	final int DIAMOND = 3;
	static int HEART = 2;
	int CLOVER = 1;

	public abstract String getCardNumber();
	String getCardKind(); // public abstract String getCardKind();
}

36. 인터페이스의 상속

✅

- 인터페이스는 인터페이스로부터만 상속받을 수 있다.
- 클래스와는 달리 다중상속, 즉 여러개의 인터페이스로부터 상속받는 것이 가능하다.

인터페이스는 인터페이스로부터만 상속받을 수 있으며, 클래스와는 달라 다중상속, 즉 여러개의 인터페이스로부터 상속을 받는 것이 가능하다.

+) 인터페이스는 클래스와 달리 Obejct 클래스와 같은 최고 조상이 없다.

interface Movable {
    // 지정된 위치(x, y)로 이동하는 기능의 메서드
    void move(int x, int y);
}

interface Attackable {
    // 지정된 대상(u)을 공격하는 기능의 메서드
    void attack(Unit u);
}

interface Fightable extends Movable, Attackable { }

클래스의 상속과 마찬가지로 자손 인터페이스(Fightable)는 조상 인터페이스(Movable, Attackable)에 정의된 멤버를 모두 상속받는다.

그래서 Fightable 자체에는 정의된 멤버가 하나도 없지만 조상 인터페이스로부터 상속받은 두 개의 추상메서드, move(int x, int y)와 attack(Unit u)을 멤버로 갖게 된다.

37. 인터페이스의 구현

✅

- 인터페이스 구현 시 ‘implements’ 키워드를 사용한다.
- 만일 구현하는 인터페이스의 메서드 중 일부만 구현 시, 추상클래스로 선언해야 한다.

인터페이스도 추상클래스처럼 그 자체로는 인스턴스를 생성할 수 없다.

추상클래스가 상속을 통해 추상메서드를 완성하는 것처럼, 인터페이스도 자신에 정의된 추상메서드의 몸통을 만들어주는 클래스를 작성해야 한다.

클래스는 확장한다는 의미의 키워드 ‘extends’를 사용하지만 인터페이스는 구현한다는 의미의 키워드 ‘implements’를 사용할 뿐이다.

class 클래스이름 implements 인터페이스이름 {
	// 인터페이스에 정의된 추상메서드를 모두 구현해야 한다.
}

// Fighter 클래스는 Fightable 인터페이스를 구현한다.
class Fighter implements Fightable {
	public void move(int x, int y) { /* 내용 생략 */ }
	public void attack(Unit u) { /* 내용 생략 */ }
}

만일 구현하는 인터페이스의 메서드 중 일부만 구현한다면, abstract를 붙여서 추상클래스로 선언해야 한다.

abstract class Fighter implements Fightable {
	public void move(int x, int y) { /* 내용 생략 */ }
}

그리고 다음과 같이 상속과 구현을 동시에 할 수도 있다.

class Fighter extends Unit implements Fightable {
	public void move(int x, int y) { /* 내용 생략 */ }
	public void attack(Unit u)     { /* 내용 생략 */ }
}

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

✅

인터페이스 타입의 참조변수로 이를 구현한 클래스의 인스턴스를 참조할 수 있다.

다형성을 학습할 때 자손클래스의 인스턴스를 조상타입의 참조변수로 참조하는 것이 가능하다는 것을 배웠다. 인터페이스 역시 이를 구현한 클래스의 조상이라 할 수 있으므로 해당 인터페이스 타입의 참조변수로 이를 구현한 클래스의 인스턴스를 참조할 수 있으며, 인터페이스 타입으로의 형변환도 가능하다.

인터페이스 Fightable을 클래스 Fighter가 구현했을 때, 다음과 같이 Fighter 인스턴스를 Fightable 타입의 참조변수로 참조하는 것이 가능하다.

Fightable f = (Fightable) new Fighter();
    또는
Fightable f = new Fighter();

따라서 인터페이스는 다음과 같이 메서드의 매개변수의 타입으로도 사용될 수 있다.

void attack(Fightable f) {
	// ...
}

인터페이스 타입의 매개변수가 갖는 의미는 메서드 호출 시 해당 인터페이스를 구현한 클래스의 인스턴스를 매개변수로 제공해야 한다는 것이다.

class Fighter extends Unit implements Fightable {
	public void move(int x, int y) { /* 내용 생략 */ }
	public void attack(Fightable f) { /* 내용 생략 */ }
}

위와 같이 Fightable 인터페이스를 구현한 Fighter 클래스가 있을 때, attack 메서드의 매개변수로 Fighter 인스턴스를 념겨줄 수 있다. 즉 attack(new Fighter())와 같이 할 수 있다는 것이다. 그리고 아래처럼 메서드의 리턴타입으로 인터페이스를 지정하는 것도 가능하다.

Fightable method() {
	...
	Fighter f = new Fighter();
	return f;
  // => return new Fighter();
}

리턴타입이 인터페이스라는 것은 메서드가 해당 인터페이스를 구현한 클래스의 인스턴스를 반환한다는 것을 의미한다. 이 문장은 외울 때까지 반복해서 읽어야 한다.

위의 코드에서는 method()의 리턴타입이 Fightable 인터페이스이기 때문에 메서드의 return문에서 Fightable 인터페이스를 구현한 Fighter 클래스의 인스턴스의 주소를 반환한다.

39. 인터페이스의 장점

💡

- 개발시간을 단축시킬 수 있다.
- 표준화가 가능하다.
- 서로 관계없는 클래스들에게 관계를 맺어줄 수 있다.
- 독립적인 프로그래밍이 가능하다.

1. 개발시간을 단축시킬 수 있다.

   일단 인터페이스가 작성되면, 이를 사용해서 프로그램을 작성하는 것이 가능하다. 메서드를 호출하는 쪽에서는 메서드의 내용에 관계없이 선언부만 알면 되기 때문이다.

   그리고 동시에 다른 한 쪽에서는 인터페이스를 구현하는 클래스를 작성하게 하면, 인터페이스를 구현하는 클래스가 작성될 때까지 기다리지 않고도 양쪽에서 동시에 개발을 진행할 수 있다.

2. 표준화가 가능하다.

   프로젝트에 사용되는 기본 틀을 인터페이스로 작성한 다음, 개발자들에게 인터페이스를 구현하여 프로그램을 작성하도록 함으로써 보다 일관되고 정형화된 프로그램의 개발이 가능하다.

3. 서로 관계없는 클래스들에게 관계를 맺어 줄 수 있다.

   서로 상속관계에 있지도 않고, 같은 조상클래스를 가지고 있지 않은 서로 아무런 관계도 없는 클래스들에게 하나의 인터페이스를 공통적으로 구현하도록 함으로써 관계를 맺어줄 수 있다.

4. 독립적인 프로그래밍이 가능하다.

   인터페이스를 이용하면 클래스의 선언과 구현을 분리시킬 수 있기 때문에 실제구현에 독립적인 프로그램을 작성하는 것이 가능하다. 클래스와 클래스간에 직접적인 관계를 인터페이스를 이용해서 간접적인 관계로 변경하면, 한 클래스의 변경이 관련된 다른 클래스에 영향을 미치지 않는 독립적인 프로그래밍이 가능하다.

<인터페이스>

두 대상(객체) 간의 연결, 대화, 소통을 돕는 중간 역할(기계 껍데기)

ex) GUI(graphic user interface)

• 알맹이가 바뀌어도 껍데기가 그대로면 사용에 아무 지장 없다.(변경에 유리)

• 선언(설계)와 구현을 분리시킬 수 있다.

  ⇒ 변경사항이 있어도 수정 범위가 적다.(느슨한 결합)

<인터페이스의 장점>

1. 개발 시간 단축
   • 선언과 구현을 다른 위치에서 하기 때문

2. 변경에 유리한 설계가 가능하다.

3. 표준화가 가능하다.

   EX) JDBC(인터페이스의 집합 - 표준)

   DB가 바뀌어도 application에 큰 변경이 필요없다.

class A {
    public void method(B b) {
        b.method();
    }
}

class B {
    public void method() {
        System.out.println("B클래스의 메서드");
    }
}

class C {
    public void method() {
        System.out.println("C클래스의 메서드");
    }
}

public class InterfaceTest {
    public static void main(String[] args) {
        A a = new A();
        a.method(new B()); // A가 B를 사용(의존)
        a.method(new C()); // A가 B를 사용(의존)
    }
}

→

interface I {
    public void method();
}

class A {
    public void method(I i) {
        i.method();
    }
}

class B implements I {
    public void method() {
        System.out.println("B클래스의 메서드");
    }
}

class C implements I {
    public void method() {
        System.out.println("C클래스의 메서드");
    }
}

public class InterfaceTest {
    public static void main(String[] args) {
        A a = new A();
        a.method(new B());
        a.method(new C());
    }
}

40. 디폴트 메서드와 static 메서드

원래는 인터페이스에 추상 메서드만 선언할 수 있었으나, JDK1.8부터 디폴트 메서드와 static 메서드도 추가할 수 있게 되었다. static 메서드는 인스턴스와 관계가 없는 독립적인 메서드이기 때문에 예전부터 인터페이스에 추가하지 못할 이유가 없었다.

그러나 자바를 보다 쉽게 배울 수 있도록 규칙을 단순히 할 필요가 있어서 인터페이스의 모든 메서드는 추상 메서드이어야 한다는 규칙에 예외를 두지 않았다.

조상 클래스에 새로운 메서드를 추가하는 것은 별 일이 아니지만, 인터페이스의 경우에는 보통 큰 일이 아니다. 인터페이스에 메서드를 추가한다는 것은, 추상 메서드를 추가한다는 것이고, 이 인터페이스를 구현한 기존의 모든 클래스들이 새로 추가된 메서드를 구현해야하기 때문이다.

인터페이스가 변경되지 않으면 제일 좋겠지만, 아무리 설계를 잘해도 언젠가 변경은 발생하기 마련이다. JDK의 설계자들은 고심 끝에 디폴트 메서드(default method)라는 것을 고안해내었다. 디폴트 메서드는 추상 메서드의 기본적인 구현을 제공하는 메서드로, 추상 메서드가 아니기 때문에 디폴트 메서드가 새로 추가되어도 해당 인터페이스를 구현한 클래스를 변경하지 않아도 된다.

디폴트 메서드는 앞에 키워드 default를 붙이며, 추상 메서드와 달리 일반 메서드처럼 몸통 {}이 있어야 한다. 디폴트 메서드 역시 접근 제어자가 public이며, 생략 가능하다.

interface MyInterface {
	void method();
	void newMethod(); // 추상 메서드
}

→

interface MyInterface {
	void method();
	defulat void newMethod();
}

위의 왼쪽과 같이 newMethod()라는 추상 메서드를 추가하는 대신, 오른쪽과 같이 디폴트 메서드를 추가하면, 기존의 MyInterface를 구현한 클래스를 변경하지 않아도 된다. 즉, 조상 클래스에 새로운 메서드를 추가한 것과 동일해지는 것이다.

대신, 새로 추가된 디폴트 메서드가 기존의 메서드와 이름이 중복되어 충돌하는 경우가 발생한다. 이 충돌을 해결하는 규칙은 다음과 같다.

1. 여러 인터페이스의 디폴트 메서드 간의 충돌
   • 인터페이스를 구현한 클래스에서 디폴트 메서드를 오버라이딩해야 한다.

2. 디폴트 메서드와 조상 클래스의 메서드 간의 충돌
   • 조상 클래스의 메서드가 상속되고, 디폴트 메서드는 무시된다.

위의 규칙이 외우기 귀찮으면, 그냥 필요한 쪽의 메서드와 같은 내용으로 오버라이딩 해버리면 그만이다.

// 예제 7-11
class Ex7_11 {
    public static void main(String[] args) {
        Child c = new Child();
        c.method1();
        c.method2();
        MyInterface.staticMethod();
        MyInterface2.staticMethod();
    }
}

class Child extends Parent implements MyInterface, MyInterface2 {
    public void method1() {
        System.out.println("method1() in Child"); // 오버라이딩
    }
}

class Parent {
    public void method2() {
        System.out.println("method2() in Parent");
    }
}

interface MyInterface {
    default void method1() {
        System.out.println("method1() in MyInterface");
    }

    default void method2() {
        System.out.println("method2() in MyInterface");
    }

    static void staticMethod() {
        System.out.println("staticMethod() in MyInterface");
    }
}

interface MyInterface2 {
    default void method1() {
        System.out.println("method1() in MyInterface2");
    }

    static void staticMethod() {
        System.out.println("staticMethod() in MyInterface2");
    }
}

Uploaded by N2T