[혼공자] 5주차_Chapter 8~9
√ 미션
1. 기본 미션 : 클래스를 선언할 때 인터페이스는 어떻게 선언될 수 있는지 정리하기
답 :
인터페이스 선언은 다음과 같이 interface 키워드를 사용한다.
[public] interface 인터페이스이름 {
//상수
타입 상수이름 = 값;
//추상 메소드
타입 메소드이름(매개변수,...);
}
인터페이스의 구현 객체를 생성하는 클래스를 구현 클래스라고 하는데, 인터페이스 타입으로 사용할 수 있음을 알려주기 위해 클래스 선언부에 implements 키워드를 추가하고 인터페이스 이름을 명시한다.
public class 구현클래스이름 implements 인터페이스이름 {
//인터페이스에 선언된 추상 메소드의 실체 메소드 선언
}
cf) 더 자세한 내용은 밑의 정리 참고
2. 선택미션 : p. 421 09-1 확인 문제 3번 풀어보기
3번. 다음과 같이 Car 클래스 내부에 Tire와 Engine이 멤버 클래스로 선언되어 있습니다. 바깥 클래스(NestedClassExample)에서 멤버 클래스의 객체를 생성하는 코드를 빈 칸에 작성해보세요.
답 :
public class NestedClassExample {
public static void main(String[] args) {
Car myCar = new Car();
Car.Tire tire = myCar.new Tire();
Car.Engine engine = new Car.Engine();
}
}Chapter 8 : 인터페이스
1. 인터페이스
인터페이스는 객체의 사용 방법을 정의한 타입으로 이를 통해 다양한 객체를 동일한 사용 방법으로 이용할 수 있다. 개발 코드가 인터페이스의 메소드를 호출하면 인터페이스는 객체의 메소드를 호출시킨다. 인터페이스를 사용하면 개발 코드를 수정하지 않고 사용하는 객체를 변경할 수 있기 때문에 실행 내용과 리턴값을 다양화할 수 있다는 장점이 있다.
인터페이스 선언은 다음과 같이 interface 키워드를 사용한다. 이때 인터페이스는 객체로 생성할 수 없기 때문에 생성자를 가질 수 없다.
/* [public] interface 인터페이스이름 {
//상수
타입 상수이름 = 값;
//추상 메소드
타입 메소드이름(매개변수,...);
}
*/
public interface RemoteControl{
//상수
public int MAX_VOLUME = 10;
public int MIN_VOLUME = 0;
//추상 메소드
public void turnOn();
public void turnOff();
public void setVolume(int volume);
}
1) 상수 필드 선언
인터페이스는 객체 사용 방법을 정의한 것으로 실행 시 데이터를 저장할 수 있는 인스턴스 또는 정적 필드를 선언할 수 없다. 대신 상수 필드만 선언 가능한데, 상수는 고정된 값으로 실행 시에 데이터를 바꿀 수 없다.
[public static final] 타입 상수이름 = 값;
2) 추상 메소드 선언
인터페이스로 호출된 메소드는 객체에서 실행되므로 추상 메소드로 선언한다.
[public abstract] 리턴타입 메소드이름(매개변수, ...);
3) 인터페이스 구현
객체는 인터페이스에서 정의된 추상 메소드와 동일한 메소드 이름, 매개 타입, 리턴 타입을 가진 실체 메소드를 가지고 있어야 한다.
인터페이스의 구현 객체를 생성하는 클래스를 구현 클래스라고 하는데, 인터페이스 타입으로 사용할 수 있음을 알려주기 위해 클래스 선언부에 implements 키워드를 추가하고 인터페이스 이름을 명시한다.
public class 구현클래스이름 implements 인터페이스이름 {
//인터페이스에 선언된 추상 메소드의 실체 메소드 선언
}
구현 객체를 생성하기 위해 다음과 같이 인터페이스 변수를 선언하고 구현 객체를 대입한다.
인터페이스 변수;
변수 = 구현객체;
인터페이스 변수 = 구현객체;
4) 다중 인터페이스 구현
다중 인터페이스를 구현할 경우, 구현 클래스는 모든 인터페이스의 추상 메소드에 대해 실체 메소드를 작성해야 한다.
public class 구현클래스이름 implements 인터페이스A, 인터페이스B {
//인터페이스A에 선언된 추상 메소드의 실체 메소드 선언
//인터페이스B에 선언된 추상 메소드의 실체 메소드 선언
}
5) 인터페이스 사용
인터페이스로 구현 객체를 사용하는 방법은 다음과 같다.
- 필드로 선언된 rc 사용
MyClass myClass = new MyClass();
myClass.rc.turnOn();
myClass.rc.setVolume(5);
- 생성자의 매개 변수 타입으로 선언된 rc 사용
MyClass( RemoteControl rc ){
this.rc = rc;
rc.turnOn();
rc.setVolume(5);
}
- 로컬 변수로 선언된 rc 사용
void methodA() {
RemoteControl rc = new Audio();
rc.turnOn();
rc.setVolume(5);
}
- 메소드의 매개 변수 타입으로 선언된 rc 사용
void methodB(RemoteContorl rc){
rc.turnOn();
rc.setVolume(5);
}
2 . 타입 변환과 다형성
인터페이스 다형성이란 프로그램 소스 코드는 변함이 없는데, 구현 객체를 교체함으로써 프로그램의 실행결과가 다양해지는 것이다.
1) 자동 타입 변환
구현 객체가 인터페이스 타입으로 변환되는 것을 자동 타입 변환이라고 한다. 인터페이스 구현 클래스를 상속해서 자식 클래스를 만들었다면 자식 객체 역시 인터페이스 타입으로 자동 타입 변환 가능하다.
//인터페이스 변수 = 구현객체;
//자동 타입 변환
public class Car{
Tire frontLeftTire = new HankookTire();
Tire frontRightTire = new HankkookTire();
}
//다른 구현 객체 대입 가능
Car myCar = new Car();
myCar.frontLeftTire = new kumhoTire();
myCar.frontRightTire = new kumhoTire();
매개값을 다양화하기 위해 매개 변수를 인터페이스 타입으로 선언하고 호출할 때에는 구현 객체를 대입한다.
public interface Vehicle {
public void run();
}
public class Driver {
public void drive(Vehicle vehicle){
vehicle.run();
}
}
다음과 같이 drive() 메소드는 Vehicle 타입을 매개 변수로 선언했지만, Vehicle을 구현한 Bus 객체가 매개값으로 사용되면 자동 타입 변환이 발생한다.
2) 강제 타입 변환
자동 타입 변환을 하면 인터페이스에 선언된 메소드만 사용 가능하다는 제약이 따른다. 이때 다시 구현 클래스 타입으로 변환한 다음, 구현 클래스의 필드와 메소드를 사용하는 것을 강제 타입 변환이라고 한다.
구현클래스 변수 = (구현클래스) 인터페이스변수;
3) 객체 타입 확인
instanceof 연산자를 이용해서 어떤 구현 객체가 인터페이스 타입으로 변환되었는지 확인할 수 있다.
//Vehicle 인터페이스 타입으로 변환된 객체가 Bus인지 확인
if(vehicle instanceof Bus){
Bus bus = (Bus) vehicle;
}
4) 인터페이스 상속
인터페이스는 다른 인터페이스를 상속하는 다중 상속을 할 수 있다. 이때 하위 인터페이스를 구현하는 클래스는 하위 인터페이스의 메소드뿐만 아니라 상위 인터페이스의 모든 추상 메소드에 대한 실체 메소드를 가지고 있어야 한다.
public interface 하위인터페이스 extends 상위인터페이스1, 상위인터페이스2 {...}
하위인터페이스 변수 = new 구현클래스(...);
상위인터페이스1 변수 = new 구현클래스(...);
상위인터페이스2 변수 = new 구현클래스(...);
Chapter 9 : 중첩 클래스와 중첩 인터페이스
1 . 중첩 클래스와 중첩 인터페이스 소개
중첩 클래스란 클래스 내부에 선언한 클래스이고, 중첩 인터페이스는 클래스 내부에 인터페이스를 선언한 것이다.
//중첩 클래스
class ClassName {
class NestedClassName {
}
}
//중첩 인터페이스
class ClassName{
interface NestedInterfaceName{
}
}
1) 중첩 클래스
중첩 클래스는 클래스 내부에 선언되는 위치에 따라서 멤버 클래스와 로컬 클래스로 나뉜다. 멤버 클래스는 클래스나 객체가 사용 중이라면 언제든지 재사용이 가능하지만, 로컬 클래스는 메소드를 실행할 때만 사용되고 메소드가 종료되면 없어진다.
- 인스턴스 멤버 클래스
static 키워드 없이 중첩 선언된 클래스이다. 인스턴스 필드와 메소드만 선언이 가능하고 정적 필드와 메소드는 선언할 수 없다.
클래스 외부와 내부에 객체를 생성할 때의 선언 방법도 다르다. 보통 클래스 내부에 객체를 생성해서 사용한다.
- 정적 멤버 클래스
static 키워드로 선언된 클래스이다. 정적 멤버 클래스는 모든 종류의 필드와 메소드를 선언할 수 있다.
클래스 외부에서 정적 멤버 클래스 C의 객체를 생성하기 위해서는 A 객체를 생성할 필요가 없고, C 객체를 생성해야 한다.
- 로컬 클래스
로컬 클래스는 메소드 내에 중첩 클래스를 선언한 것이다. 로컬 클래스는 메소드 내부에서만 사용되므로 접근을 제할할 필요가 없기 때문에 접근 제한자(public, private) 및 static을 붙일 수 없다.
2) 중첩 클래스의 접근 제한
- 멤버 클래스에서 사용 제한
멤버 클래스 내부에서 바깥 클래스의 필드와 메소드에 접근할 때에도 제한이 따른다.
인스턴스 멤버 클래스(B) 안에서는 바깥 클래스의 모든 필드와 모든 메소드에 접근할 수 있다. 그러나 정적 멤버 클래스(C) 안에서는 바깥 클래스의 정적 필드와 메소드에만 접근 가능하다.
- 로컬 클래스에서 사용 제한
로컬 클래스의 객체는 메소드 실행이 종료되면 없어지는 것이 일반적이지만, 메소드가 종료되어도 계속 실행 상태로 존재할 수 있다. 이를 해결하기 위해 매개 변수나 로컬 변수를 final로 선언해야 하는데, 자바 8 이후부터는 final 선언을 하지 않아도 값이 수정될 수 없도록 final 특성을 부여한다.
- 중첩 클래스에서 바깥 클래스 참조 얻기
중첩 클래스에서 this 키워드를 사용하면 바깥 클래스의 객체 참조가 아니라, 중첩 클래스의 객체 참조가 된다.
바깥클래스.this.필드
바깥클래스.this.메소드();
public class Outter {
String field = "Outter-field";
void method(){
System.out.println("Outter-method");
}
class Nested{
String field = "Nested-field";
void method() {
System.out.println("Nested-method");
}
void print(){
//중첩 객체 참조
System.out.println(this.field);
this.method();
//바깥 객체 참조
System.out.println(Outter.this.field);
Outter.this.method();
}
}
}
3) 중첩 인터페이스
중첩 인터페이스는 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들기 위해 클래스의 멤버로 선언된 인터페이스이다. 인스턴스 멤버 인터페이스는 바깥 클래스의 객체가 있어야 사용 가능하며, 정적 멤버 인터페이스는 바깥 클래스의 객체 없이 바깥 클래스만으로 접근 가능하다. 주로 정적 멤버 인터페이스를 많이 사용하는데 주로 UI 프로그래밍에서 이벤트 처리 목적으로 활용된다.
class A {
[static] interface I {
void mehtod();
}
}
2 . 익명 객체
익명 객체는 이름이 없는 객체이다. 익명 객체를 만들기 위해서는 클래스를 상속하거나 인터페이스를 구현해야 한다. 이때 부모 클래스 변수는 이름이 없는 자식 객체를 참조하고, 인터페이스 변수는 이름이 없는 구현 객체를 참조한다.
//일반적인 경우
//[상속]
class 클래스이름1 extends 부모클래스 {...}
부모클래스 변수 = new 클래스이름1();
//[구현]
class 클래스이름2 implements 인터페이스 {...}
인터페이스 변수 = new 클래스이름2();
//익명 객체 생성
//[상속]
부모클래스 변수 = new 부모클래스() {...};
//[구현]
인터페이스 변수 = new 인터페이스() {...};
1) 익명 자식 객체 생성
자식 클래스를 재사용하지 않고, 특정 위치에서 사용할 경우라면 자식 클래스를 명시적으로 선언하지 않는 익명 자식 객체를 생성한다.
- 하나의 실행문이므로 끝에는 세미콜론(;)을 붙여야 한다.
- 부모 클래스(매개값, ...) {...} : 부모 클래스를 상속해서 중괄호{}와 같이 자식 클래스 선언
- new 연산자 : 자식 클래스를 객체로 생성
- 부모 클래스(매개값, ...) : 부모 생성사 호출
- 중괄호 {} 내부 : 필드나 메소드를 선언하거나 부모 클래스의 메소드 재정의(오버라이딩)
/* 부모 클래스 [필드|변수] = new 부모클래스(매개값, ...){
//필드
//메소드
};
*/
class A {
Parent field = new Parent() {
int childField;
void childMethod(){}
@Override
void parentMethod() {}
};
}
익명 자식 객체에 새롭게 정의된 필드와 메소드는 익명 자식 객체 내부에서만 사용되고, 외부에서는 접근할 수 없다.
2) 익명 구현 객체 생성
구현 객체를 재사용하지 않고, 특정 위치에서 사용할 경우라면 구현 클래스를 명시적으로 선언하지 않고 익명 구현 객체를 생성한다.
- 인터페이스() {...} : 인터페이스를 구현해서 중괄호 {}와 같이 클래스 선언
- new 연산자 : 구현 클래스를 객체로 생성
- 중괄호 {} : 인터페이스에 선언된 모든 추상 메소드의 실체 메소드 재정의
/* 인터페이스 [필드|변수] = new 인터페이스() {
//인터페이스에 선언된 추상 메소드의 실체 메소드 선언
//필드
//메소드
};
*/
class A {
RemoteControl field = new RemoteControl {
@Override
void turnOn() {}
};
}