[35] 230216 Java Ch. 7 상속: 2. 타입 변환과 다형성 [K-디지털 트레이닝 35일]

230216 Thu 35th class

Ch. 7 상속
진도: p. 332 ~ (교재: 혼자 공부하는 자바, 저자: 신용권)
한빛미디어_혼공자_용어집.pdf
용어 참고

혼자 공부하는 자바 | 신용권 - 교보문고

오늘 배운 것 중 기억할 것을 정리했다. 

---

지난 수업 때 배운 것 중 다시 기억할 것

2023.01.31 - [1. Revision 2023/Java] - [23] 230131 Ch. 2 자바 변수와 타입(2): 타입 변환, 변수와 시스템 입출력

• Widening Casting (automatically) - converting a smaller type to a larger type size
   자동 타입 변환: 큰 타입 = 작은 타입(작은 타입 → 큰 타입)
  
  byte → short → char → int → long → float → double
  Widening casting is done automatically when passing a smaller size type to a larger size type.

    int myInt = 9;
    double myDouble = myInt; // Automatic casting: int to double

    System.out.println(myInt);      // Outputs 9
    System.out.println(myDouble);   // Outputs 9.0

• Narrowing Casting (manually) - converting a larger type to a smaller size type
  강제 타입 변환: 작은 타입 = (작은 타입)큰 타입(큰 타입 → 작은 타입)
  
  double → float → long → int → char → short → byte
  Narrowing casting must be done manually by placing the type in parentheses in front of the value.
  

    double myDouble = 9.78d;
    int myInt = (int) myDouble; // Manual casting: double to int

    System.out.println(myDouble);   // Outputs 9.78
    System.out.println(myInt);      // Outputs 9

타입 변환
byte → short → char → int → long → float → double

int a = 10; 
long b = a; (작은 -> 큰: 자동)

char c = 'A';
int d = c; (작은 -> 큰: 자동)

int e = 65;
char f = e; (큰 -> 작은: 강제)

---

2023.02.10 - [1. Revision 2023/Java] - [31] 230210 Ch. 6 클래스(2): 메서드

void: Used at method declaration and definition to specify that the method does not return any type.

리턴값이 없는 메서드는 리턴 타입으로 void를 사용한다.
void로 선언된 메서드에서도 return문을 사용할 수 있다. 리턴값을 지정하는 것이 아니라 메서드 실행을 강제로 종료시키는 역할이다. 

리턴문: 메서드 선언부에 리턴 타입이 있다면 리턴값을 지정하기 위해 return문이 반드시 있어야 한다. 리턴 타입이 void라면 return문은 필요 없지만, 메서드 실행 종료를 위해 사용할 수 있다.

return (null): null로 return한다.
submit을 하지 못하고 null을 반환한다. 해당 return 아래를 전부 실행하지 않고 return 줄에서 클래스를 끝내버린다.

return true: submit 하기 전에 함수에서 유효성 검사를 하고 통과가 되면 true(=submit true)로 리턴한다는 뜻이다.

return false: 값이 들어가 있지 않으면 submit을 하지 않고 fasle로 리턴한다는 뜻(return null과 아주 조금 차이가 있다.)이다.

참고: https://diaryofgreen.tistory.com/80

---

Java에서 sysout + [Ctrl] + [space] = System.out.println(); 이 자동으로 생성된다.

---

 

2023.02.09 - [1. Revision 2023/Java] - [30] 230209 Ch. 6 클래스(1): 객체 지향 프로그래밍, 필드, 생성자

new는 클래스로부터 객체를 생성시키는 연산자이다. (생성자: 객체가 생성될 때마다 실행되는 메서드)
new 연산자는 힙 영역에 객체를 생성시킨 후 객체의 번지를 리턴하도록 되어 있다. 

//클래스로 선언된 변수에 new 연산자가 리턴한 객체의 번지를 저장한다.
클래스 변수;
변수 = new 클래스();

//1개의 실행문으로 작성할 수 있다.
클래스 변수 = new 클래스();

---

this, this() 차이
this는 인스턴스 자신을 가르키는 참조 변수이고 this()는 생성자를 뜻한다.
참고: https://lowelllll.github.io/java/2018/12/09/java-this-%EC%B0%A8%EC%9D%B4%EC%A0%90/
참고: https://itprogramming119.tistory.com/149

---

 

Ch. 7 상속

책의 목차
07-1 상속
07-2 타입 변환과 다형성
07-3 추상 클래스

7.2 타입 변환(type conversion)과 다형성(polymorphism)

상속이 이루어져야한다. → 크다(부모), 작다(자식)이 된다. 
부모(큼) → 자식(작음): 강제
부모(작은) → 자식(큼): 자동

다형성(polymorphism): 같은 타입이지만 실행 결과가 다양한 객체를 이용할 수 있는 성질을 말한다. 코드 측면에서 보면 다형성은 하나의 타입에 여러 객체를 대입함으로써 다양한 기능을 이용할 수 있도록 해준다.

사용 방법은 동일하지만 다양한 객체를 이용해서 다양한 실행결과가 나오도록 하는 성질이다.

class 동물{
}

class 고양이 extends 동물{
}

class 강아지 extends 동물{
}

class 동물테스트(){
          동물 = 고양이
          동물 = 강아지
}

---

1) 자동 타입 변환(Promotion)

타입 변환: 타입을 다른 타입으로 변환하는 행위

클래스도 마찬가지로 타입 변환이 있는데, 클래스의 반환은 상속 관계에 있는 클래스 사이에서 발생한다.
자식은 부모 타입으로 자동 타입 변환이 가능하다.

자동 타입 변환: 프로그램 실행 도중에 자동적으로 타입 변환이 일어나는 것
조건:

<- 자동 타입 변환 <-

부모타입 변수 = 자식 타입;

Cat cat = new Cat();
Animal animal = cat;
//아래와 같다.
Animal animal = new Cat();

자식은 부모의 특징과 기능을 상속받기 때문에 부모와 동일하게 취급될 수 있다.

cat == animal //true

참조 변수의 == 연산은 참조 번지가 같을 경우 true를 산출하므로 두 변수가 동일한 객체를 참조하고 있다.

바로 위의 부모가 아니더라고 상속 계층에서 상위 타입이라면 자동 타입 변환이 일어날 수 있다.

예제 1) 자동 타입 변환

class A {}
//	자식		<	부모
class B extends A {}
//자식		<	부모
class C extends A {}

//자식		<	부모
class D extends B {}
//자식		<	부모
class E extends C {}

public class PromotionExample {
	public static void main(String[] args) {
		
		B b = new B();
		C c = new C();
		D d = new D();
		E e = new E();
		
		//int a = 10;
		A a1 = b; //A: 클래스 타입, 참조 타입, a1: 참조 변수
		A a2 = c;
		A a3 = d;
		A a4 = e;
		
		B b1 = d;
		C c1 = e;
		
		//상속 관계에 있지 않기 때문에 컴파일 에러 발생
		//B b3 = e; 
		//C c2 = d;
	}
}

---

[중요!] 부모 타입으로 자동 타입 변환된 이후에는 부모 클래스에 선언된 필드와 메서드만 접근이 가능하다. 
비록 변수는 자식 객체를 참조하지만 변수로 접근 가능한 멤버는 부모 클래스 멤버로 한정된다.
예외) 메서드가 자식 클래스에서 재정의(오버라이딩)되었다면 자식 클래스의 메서드가 대신 호출된다.

예제 1) 자동 타입 변환 후의 멤버 접근 Parent.java

public class Parent {
	int a = 10;
	public void method1() {
	System.out.println("Parent-method1()");
	}
	public void method2() {
	System.out.println("Parent-method2()");
	}
}

예제 2) 자동 타입 변환 후의 멤버 접근 Child.java

public class Child  extends Parent{
	int a = 20;
	public void method2(){
		System.out.println("Child-method2()");
	}
	public void method3(){
		System.out.println("Child-method3()");
	}
}

예제 3) 자동 타입 변환 후의 멤버 접근 ChildExample.java

public class ChildExample {
	public static void main(String[] args) {
		//int a = 10;
		Child child = new Child();

		Parent parent = child; //자동 타입 변환
		
		System.out.println(parent.a);
		
		parent.method1();
		parent.method2(); //재정의된 메서드가 호출됨
		//parent.method3(); //호출 불가능
	}
}

결과)

10
Parent-method1()
Child-method2()

---

2) 필드의 다형성 p. 337

다형성을 구현하기 위해 부모 타입으로 변환해서 사용한다. 
필드의 타입을 부모 타입으로 선언하면 다양한 자식 객체들이 저장될 수 있기 때문에 필드 사용 결과가 달라질 수 있다. (=필드의 다형성)
프로그램은 수많은 객체들이 서로 연결되고 각자의 역할을 하게 되는데, 이 객체들은 다른 객체로 교체될 수 있어야 한다.

ex) 자동차 클래스를 처음 설계할 때 사용한 타이어 객체는 언제든지 성능이 좋은 다른 타이어 객체로 교체할 수 있어야 한다. 
새로 교체되는 타이어 객체는 기존 타이어와 사용 방법은 동일하지만 실행 결과는 더 우수하게 나와야 할 것이다. 
→ 프로그램으로 구현하기 위해 상속과 재정의, 타입 변환을 이용한다. 

[다형성을 구현할 수 있는 기술적 조건] 
1. 부모 클래스를 상속하는 자식 클래스는 부모가 가지고 있는 필드와 메서드를 가지고 있으니 사용 방법이 동일하다.
2. 자식 클래스는 부모의 메서드를 재정의해서 메서드의 실행 내용을 변경함으로써 더 우수한 실행결과가 나오게 할 수도 있다. 
3. 자식 타입을 부모 타입으로 변환할 수 있다

---

다형성: 전체 수정이 아닌, 특정 부분을 수정한다. (유지보수), 효율적인지 판단한다. 
ex) 타이어 4개의 자동차의 경우 앞 타이어 2개, 뒷 타이어 2개 나누는 경우 
책의 아래 예제에서는 타이어를 4개로 나뉘었다. 

1) ~ 4)의 전체 코드

1) Tire  클래스

최대 회전수 = 타이어의 수명, 최대 회전수에 도달하면 타이어에 펑크가 난다. 

예제 1) Tire.java
if, else일 때 각각 return true; return false; 쓴다.

package ch07_2;
//[1]
public class Tire {
	//필드(기본 타입)
	public int maxRotation;//접근제한자가 public인 인스턴스 필드: 최대 회전수를 저장하는 필드(타이어 수명) 
	public int accumulatedRotation;//접근제한자가 public인 인스턴스 필드: 누적 회전수
	public String location;//접근제한자가 public인 인스턴스 필드: 타이어의 위치(앞왼쪽, 앞오른쪽, 뒤왼쪽, 뒤오른쪽)
	
	//생성자(매개변수 2개인 생성자: 타이어위치, 최대 회전수를 초기화하는 생성자)
	public Tire(String location, int maxRotation) {
		
		 //타이어의 위치 초기화
		this.location = location;
		
		 //최대 회전수 초기화
		this.maxRotation = maxRotation;
	}
	
	//메서드
	public boolean roll() {//접근제한자가 public이고, 리턴타입은 boolean인 roll이라는 이름의 메서드 
		//누적 회전 수 1씩 증가시켜서 누적회전수 필드에 저장한다. 
		++accumulatedRotation;
		
		//누적 회전수가 최대 회전수보다 작으면 (정상 회전(누적<최대)일 경우) 실행한다.
		if(accumulatedRotation < maxRotation) {
			
			System.out.println(location + " Tire 수명: "+(maxRotation-accumulatedRotation) + "회");
			return true;//리턴타입과 return키워드 뒤에 있는 타입이 일치한다. 
			
		}else {//그렇지 않으면 = 누적 회전수가 최대 회전수와 같거나 크면 (펑크(누적=최대)일 경우) 실행한다. 
			
			System.out.println("***" + location + " Tire 펑크 ***");
			return false;
		}
	}
}

번외) 아래 방식으로도 if, else문이 가능하다.
if, else에 각각 result = true; result = false; 넣고 return result;를 쓴다. 

	public boolean roll() {//접근제한자가 public이고, 리턴타입은 boolean인 roll이라는 이름의 메서드 
		//누적 회전 수 1씩 증가시켜서 누적회전수 필드에 저장한다. 
		++accumulatedRotation;
		//누적 회전수가 최대 회전수보다 작으면 (정상 회전(누적<최대)일 경우) 실행한다.
		if(accumulatedRotation < maxRotation) {
			System.out.println(location + "Tire 수명: "+(maxRotation-accumulatedRotation) + "회");
			result = true;//리턴타입과 return키워드 뒤에 있는 타입이 일치한다. 
		}else {//그렇지 않으면 = 누적 회전수가 최대 회전수와 같거나 크면 (펑크(누적=최대)일 경우) 실행한다. 
			System.out.println("***" + location + "Tire 펑크 ***");
			result = false;
		}
		return result;
	}

---

2) Car 클래스

예제 2) Tire를 부품으로 가지는 클래스 Car.java

	int run() {//접근제한자가 default이고, 리턴타입이 int인 run이라는 이름의 메서드
	System.out.println("[자동차가 달립니다.]");
	if(frontLeftTire.roll()==false) {stop(); return 1;}
	if(frontRightTire.roll()==false) {stop(); return 2;}
	if(backLeftTire.roll()==false) {stop(); return 3;}
	if(backRightTire.roll()==false) {stop(); return 4;}
	return 0; //위 조건이 아닌 경우 0이 필요하므로 넣어준다. 
	}

[1] Tire.java의 메서드가 return false;가 될 경우 (false를 리턴하는 roll()이 있을 경우)
stop() 메서드를 호출하고 해당 타이어 번호를 리턴한다. 

package ch07_2;
//[2]
public class Car {
	//필드(참조 타입): 자동차는 4개의 타이어를 가진다.
	Tire frontLeftTire = new Tire("앞왼쪽", 6); //new 뒤에 있는 것: 생성자 호출
	Tire frontRightTire = new Tire("앞오른쪽", 2);
	Tire backLeftTire = new Tire("뒤왼쪽", 3);
	Tire backRightTire = new Tire("뒤오른쪽", 4);

	//생성자
	
	//메서드: 모든 타이어를 1회 회전시키기 위해 각 Tire 객체의 roll() 메서드를 호출한다. 
	//false를 리턴하는 roll()이 있을 경우 stop()메서드를호출하고 해당 타이어 번호를 리턴한다. 
	int run() {//접근제한자가 default이고, 리턴타입이 int인 run이라는 이름의 메서드
	System.out.println("[자동차가 달립니다.]");
	if(frontLeftTire.roll()==false) {stop(); return 1;}
	if(frontRightTire.roll()==false) {stop(); return 2;}
	if(backLeftTire.roll()==false) {stop(); return 3;}
	if(backRightTire.roll()==false) {stop(); return 4;}
	return 0; //위 조건이 아닌 경우 0이 필요하므로 넣어준다. 
	}

	//펑크 났을 때 실행: 접근제한자가 default이고, 리턴타입이 void인 run이라는 이름의 메서드
	void stop() {//void이므로 return이 없다.
		System.out.println("[자동차가 멈춥니다.]");
	}
}

new로 아래처럼 새로운 수를 계속 만든다.

Tire frontLeftTire = new Tire("앞왼쪽", 6);

		0x100
frontLeftTire	0x100 <---	Tire1
		maxRotation	6
		accumulatedRotation	0
		location	앞왼쪽

Tire frontRightTire = new Tire("앞오른쪽", 2);

		0x200
frontRightTire	0x200 <---	Tire1
		maxRotation	2
		accumulatedRotation	0
		location	앞오른쪽

Tire backLeftTire = new Tire("뒤왼쪽", 3);

		0x300
BackLeftTire	0x300 <---	Tire1
		maxRotation	3
		accumulatedRotation	0
		location	뒤왼쪽

Tire backRightTire = new Tire("뒤오른쪽", 4);

		0x400
BackRightTire	0x400 <---	Tire1
		maxRotation	4
		accumulatedRotation	0
		location	뒤오른쪽

---

3) HankookTire, KumhoTire 클래스

이 두 클래스는 Tire 클래스를 상속받는다.
생성자는 타이어의 위치, 최대 회전수를 매개값으로 받아서 부모인 Tire 클래스의 생성자를 호출할 때 넘겨주었다.
roll 메서드는 재정의되어 정상 회전과 펑크가 났을 때 출력하는 내용이 Tire 클래스의 roll() 메서드와 다르다.
(메서드가 자식 클래스에서 재정의(오버라이딩)되었다면 자식 클래스의 메서드가 대신 호출된다.)
(출력하는 내용은 아래와 같고 제품 이름이 없는 Tire 클래스의 roll() 메서드 출력 내용과는 다르다.)

System.out.println(location + "HankookTire 수명: "+(maxRotation-accumulatedRotation)+"회");
System.out.println("***" + location + "HankookTire 펑크 ***");

System.out.println(location + "KumhoTire 수명: "+(maxRotation-accumulatedRotation)+"회");
System.out.println("***" + location + "KumhoTire 펑크 ***");

예제 3) Tire의 자식 클래스 HankookTire.java

package ch07_2;
//[3]
public class HankookTire extends Tire {
	//필드
	
	//생성자
	public HankookTire(String location, int maxRotation) {
		super(location, maxRotation);
	}
	
	//메서드: 다른 내용을 출력하기 위해 재정의한 roll() 메서드
	public boolean roll() {
		++accumulatedRotation;
		if (accumulatedRotation < maxRotation) {
			System.out.println(location + " HankookTire 수명: "+(maxRotation-accumulatedRotation)+"회");
			return true;
		}else {
			System.out.println("***" + location + "HankookTire 펑크 ***");
			return false;
		}
	}
}

예제 4) Tire의 자식 클래스 KumhoTire.java

package ch07_2;
//[4]
public class KumhoTire extends Tire {
	//필드
	//생성자
	public KumhoTire(String location, int maxRotation) {
		super(location, maxRotation);
	}
	
	//메서드: 다른 내용을 출력하기 위해 재정의한 roll() 메서드
	public boolean roll() {
		++accumulatedRotation;
		if (accumulatedRotation < maxRotation) {
			System.out.println(location + " KumhoTire 수명: "+(maxRotation-accumulatedRotation)+"회");
			return true;
		}else {
			System.out.println("***" + location + "KumhoTire 펑크 ***");
			return false;
		}
	}
}

---

4) CarExample 클래스

메인 메서드가 있는 클래스를 먼저 실행한다. (CarExample)
여기에 그 후의 실행 순서를 나열한다. 

마지막으로 CarExample 클래스를 보면 지금까지 작성한 Tire, Car, HankookTire, KumhoTire 클래스를 이용하는 실행클래스이다. 

예제 5) 실행 클래스 CarExample.java

package ch07_2;
//[5]
public class CarExample {
	public static void main(String[] args) {
		//Car 객체 생성
		Car car = new Car(); 
		
		//Car 객체의 run() 메서드 5번 반복 실행
		for(int i=1; i<=5; i++) {
			int problemLocation = car.run();
			
		switch(problemLocation) {
		case 1: //앞왼쪽 타이어가 펑크 났을 때 HankookTire로 교체
			System.out.println("앞왼쪽 HankookTire로 교체");
			car.frontLeftTire = new HankookTire("앞왼쪽", 15);
			break;
		case 2: //앞오른쪽 타이어가 펑크 났을 때 KumhoTire로 교체
			System.out.println("앞오른쪽 KumhoTire로 교체");
			car.frontRightTire = new HankookTire("앞왼쪽", 13);
			break;
		case 3: //뒤왼쪽 타이어가 펑크 났을 때 HankookTire로 교체
			System.out.println("뒤왼쪽 HankookTire로 교체");
			car.backLeftTire = new HankookTire("뒤왼쪽", 14);
			break;
		case 4: //뒤오른쪽 타이어가 펑크 났을 때 KumhoTire로 교체
			System.out.println("뒤오른쪽 KumhoTire로 교체");
			car.backRightTire = new KumhoTire("앞왼쪽", 17);
			break;
		}
		//1회전 시 출력되는 내용을 구분한다.
		System.out.println("------------------------------");
		}
	}
}

결과)

[자동차가 달립니다.]
앞왼쪽 Tire 수명: 5회
앞오른쪽 Tire 수명: 1회
뒤왼쪽 Tire 수명: 2회
뒤오른쪽 Tire 수명: 3회
------------------------------
[자동차가 달립니다.]
앞왼쪽 Tire 수명: 4회
***앞오른쪽 Tire 펑크 ***
[자동차가 멈춥니다.]
앞오른쪽 KumhoTire로 교체
------------------------------
[자동차가 달립니다.]
앞왼쪽 Tire 수명: 3회
앞왼쪽 HankookTire 수명: 12회
뒤왼쪽 Tire 수명: 1회
뒤오른쪽 Tire 수명: 2회
------------------------------
[자동차가 달립니다.]
앞왼쪽 Tire 수명: 2회
앞왼쪽 HankookTire 수명: 11회
***뒤왼쪽 Tire 펑크 ***
[자동차가 멈춥니다.]
뒤왼쪽 HankookTire로 교체
------------------------------
[자동차가 달립니다.]
앞왼쪽 Tire 수명: 1회
앞왼쪽 HankookTire 수명: 10회
뒤왼쪽 HankookTire 수명: 13회
뒤오른쪽 Tire 수명: 1회
------------------------------

---

3) 매개 변수의 다형성 p. 345

void add(int x){

}
add(10)
//          부모 클래스의 참조 타입
void add(Car x){ 

}

//     자식 클래스의 참조 타입 (상속이 되어야 가능하다.)
add(HankookTire ht);
add(KumhoTire ht);

자동 타입 변환은 필드의 값을 대입할 때에도 발생하지만, 주로 메서드를 호출할 때 많이 발생한다.
메서드를 호출할 때에는 매개 변수의 타입과 동일한 매개값을 지정하는 것이 정석이지만,
매개값을 다양화하기 위해 매개 변수에 자식 객체를 지정할 수도 있다.

ex) Driver 클래스에는 drive() 메서드가 정의되어 있는데 Vehicle 타입의 매개 변수가 선언되어 있다.
drive() 메서드를 정상적으로 호출한다면 다음과 같다.

class Driver{
	void drive(Vehicle vehicle)
		vehicle.run();
    }
}

//참조 타입
Driver driver = new Driver();

//참조 타입
Vehicle vehicle = new Vehicle();

* Driver 클래스와 Vehicle 클래스 간의 상속이 아닌 경우 *
driver.drive(vehicle);(O) //driver 메서드의 매개변수 타입과 인수의 타입 일치 
driver.drive(driver);(X) //driver 메서드의 매개변수 타입과 인수의 타입 불일치

void drive(Vehicle vehicle)과 Vehicle 일치, Driver 불일치 
같은 타입이면 된다. 참조 변수는 상속을 통해서 된다. (상속을 하면 다형성이 안 되므로 위의 코드 예시와 같다.)

class Calculator{
          void add(int x){}
}
Car car = new Car();

Calculator cal = new Calculator();
cal.add(10) (O)
cal.add(10.5) (X)

//기본 타입
int a = 10;

//기본 타입
float b = 10.5; 

cal.add(a) (O) //같은 int 타입이므로 된다. 
cal.add(b) (X)

---

매개 변수의 타입이 클래스일 경우, 해당 클래스의 객체뿐만 아니라 자식 객체까지도 매개값으로 사용할 수 있다.
자식 객체가 부모의 메서드를 재정의했다면 메서드 내부에서 정의된 메서드를 호출함으로써 메서드의 실행 결과는 다양해진다.

상속관계 X -> 다형성 X
Vehicle vehicle = new Bus();는 Driver.java와 DriverExample.java에 들어가있다. 

예제 1) 부모 클래스 Vehicle.java

package ch07_2;
//[1]
public class Vehicle {
	public void run() {
		System.out.println("차량이 달립니다.");
	}
}

예제 2) Vehicle을 이용하는 클래스 Driver.java

package ch07_2;
//[2]
public class Driver {
	//					int		a
	//					타입 		변수명(바꿀 수 있다.)
	//public void driver(int a) {
	public void driver(Vehicle vehicle) {
		vehicle.run();
	}
}

예제 3) 자식 클래스 Bus.java

package ch07_2;
//[3]
public class Bus extends Vehicle {
	//public class Bus{
	//메서드 재정의(오버라이딩)
	public void run() {
		System.out.println("버스가 달립니다.");
	}
}

예제 4) 자식 클래스 Taxi.java

package ch07_2;
//[4]
public class Taxi extends Vehicle {
	//public class Taxi{
	//메서드 재정의(오버라이딩)
	public void run() {
		System.out.println("택시가 달립니다.");
	}
}

예제 5) 실행 클래스 DriverExample.java

package ch07_2;
//[5]
public class DriverExample {
	public static void main(String[] args) {
		Driver d = new Driver();
		Bus bus = new Bus();
		Taxi taxi = new Taxi();
		//Vehicle vehicle = new Vehicle();
		//d.driver(10);
		d.driver(bus); //Vehicle 클래스와 Bus 클래스가 상속관계가 아니면 X 자동타입변환: Vehicle vehicle = bus;
		d.driver(taxi); //Vehicle 클래스와 Taxi 클래스가 상속관계가 아니면 X 자동타입변환: Vehicle vehicle = taxi;
		//d.driver(vehicle); 
	}
}

결과) 

버스가 달립니다.
택시가 달립니다.

---

4) 강제 타입 변환(Casting) p. 348

강제 타입 변환: 부모 타입을 자식 타입으로 변환하는 것
자식 객체가 부모 타입으로 변환된 상태에서 다시 원래대로 자식 타입으로 변환하고자 할 때
캐스팅() 연산자를 사용해서 강제 타입 변환할 수 있다.

자식타입 변수 = (자식타입) 부모타입; //부모 타입을 자식 타입으로 변환

ex) 참조 타입: 자식 클래스 ← (자식 클래스) 부모 클래스

예제) p.355 3번 문제
A 부모 클래스, B 자식 클래스인 상황에서 
A a = new B(); //선행 후
B b = (B) a; 가능하다. 

byte → short → char → int → long → float → double
int a = 10;
//8 <- 4
long b = a; (자동)

char c = 'A'
//4 <- 2
int d = c; (자동)

int e = 65;
//2 <- 4
char d = (char)e; (강제)

---

예제 1) 부모 클래스 Parent.java

package ch07_2;

public class Parent1 {
	public String field1;
	
	public void method1() {
		System.out.println("Parent-method1()");
	}
	
	public void method2() {
		System.out.println("Parent-method1()");
	}
}

 

예제 2) 자식 클래스 Child.java

package ch07_2;

public class Child1 extends Parent1 {
	public String field2; 
	
	public void method3() {
		System.out.println("Child-method3()");
	}
}

 

예제 3) 강제 타입 변환 ChildExample.java

package ch07_2;

public class ChildExample1 {
	public static void main(String[] args) {
	//자동 타입 변환(참조 타입: 부모클래스 <- 자식 클래스)
	Parent1 parent = new Child1();
	parent.field1 = "data1"; //Parent1.java의 filed1 
	parent.method1(); //부모 클래스에 있다.
	parent.method2(); //부모 클래스에 있다. 
	
	//parent.field2 = "data2"; parent에 field2가 없으므로 사용X
	//parent.method3(); 부모 클래스에 없다. 
	
	//강제 타입 변환(참조 타입: 자식 클래스 <- (자식 클래스) 부모 클래스)
	Child1 child = (Child1) parent;
	child.field2 = "yyy";
	child.method3();
	}
}

결과)

Parent-method1()
Parent-method1()
Child-method3()

---

5) 객체 타입 확인 (instanceof)

강제 타입 변환은 자식 타입이 부모 타입으로 변환되어 있는 상태에서만 가능하기 때문에 처음부터 부모 타입으로 생성된 객체는 자식 타입으로 반환할 수 없다. 

Parent parent = new Parent();
Child child = (Child) parent; //강제 타입 변환 X

부모 변수가 참조하는 객체가 부모 객체인지 자식 객체인지 확인하는 방법: instanceof 연산자를 사용한다.
(연산자: 연산에 사용되는 표시나 기호)

연산자의 좌항에는 객체가 오고 우항에는 타입이 오는데, 좌항의 객체가 우항의 인스턴스이면, (즉 우항의 타입으로 객체가 생성되었다면) true를 리턴하고, 그렇지 않으면 false를 리턴한다. 

boolean result = 좌향(객체) instanceof 우향(타입)

instanceof 연산자는 주로 매개값의 타입을 조사할 때 사용한다.
메서드 내에서 강제 타입 변환이 필요할 경우 반드시 매개값이 어떤 객체인지 instanceof 연산자로 확인하고 안전하게 강제 타입 변환을 해야한다. 
만약 타입을 확인하지 않고 강제 타입 변환을 시도한다면 ClassCastException이 발생할 수 있다.

---

이러한 다형성으로 인해 런타임에 참조 변수가 실제로 참조하고 있는 인스턴스의 타입을 확인할 필요성이 생긴다. 자바에서는 instanceof 연산자를 제공하여, 참조 변수가 참조하고 있는 인스턴스의 실제 타입을 확인할 수 있도록 해준다.

자바에서 instanceof 연산자는 다음과 같이 사용한다.

참조변수 instanceof 클래스이름

왼쪽에 전달된 참조 변수가 실제로 참조하고 있는 인스턴스의 타입이 오른쪽에 전달된 클래스 타입이면 true를 반환하고, 아니면 false를 반환합니다. 만약에 참조 변수가 null을 가리키고 있으면 false를 반환합니다.

---

예제 1) 부모 클래스

public class Parent {
}

예제 2) 자식 클래스

public class Child extends Parent{
}

예제 3) 객체 타입 확인

public class InstanceofExample {
	public static void method1(Parent parent) { //static: new 안 쓰고 호출하려고 쓴다. 
		if(parent instanceof Child) {//검증: 맞으면 true, 틀리면 false
			Child child = (Child) parent;
			System.out.println("method1 - Child로 변환 성공");
		} else {
			System.out.println("method1 - Child로 변환되지 않음");
		}
	}

	public static void method2(Parent parent) {//검증X
			Child child = (Child) parent; //에러, 예외처리
			System.out.println("method1 - Child로 변환 성공");
	}
	
	public static void main(String[] args) { //먼저 실행
		//부모 클래스 		<- 자식 클래스
		Parent parentA = new Child();
		method1(parentA); //같은 클래스에서 호출이므로 클래스 이름 생략함.
		method2(parentA);
	
		Parent parentB = new Parent();
		method1(parentB); //false값 실행: "Child로 변환되지 않음"
		method2(parentB); //예외 발생
	}
}

결과)

method1 - Child로 변환 성공
method1 - Child로 변환 성공
method1 - Child로 변환되지 않음
Exception in thread "main" java.lang.ClassCastException: ch07_2_5.Parent cannot be cast to ch07_2_5.Child
	at ch07_2_5.InstanceofExample.method2(InstanceofExample.java:14)
	at ch07_2_5.InstanceofExample.main(InstanceofExample.java:25)

---

마무리 p. 353
5가지 키워드로 끝내는 핵심 포인트

1) 클래스 타입 변환: 다른 클래스 타입으로 객체를 대입하는 것을 말한다.

2) 자동 타입 변환: 자식 객체를 부모 타입 변수에 대입할 때에는 자동으로 타입이 변환된다.
(참조 타입: 부모클래스 ← 자식 클래스)

3) 강제 타입 변환: 자식 객체가 부모 타입으로 변환된 상태에서 다시 원래대로 자식 타입으로 변환하고자 할 때 캐스팅() 연산자를 사용해서 강제 타입 변환할 수 있다.
강제 타입 변환 (참조 타입: 자식 클래스 ← (자식 클래스) 부모 클래스)

예제) p.355 3번 문제
A 부모 클래스, B 자식 클래스인 상황에서 
A a = new B(); //선행 후
B b = (B) a; 가능하다. 

4) instanceof 연산자: 객체가 어떤 타입인지 조사할 때 instanceof 연산자를 사용한다. 주로 강제 타입 변환 전에 변환이 가능한지 조사할 때 사용한다.

5) 다형성: 객체 사용 방법은 동일하지만 실행결과가 다양하게 나오는 성질을 말한다.
다형성을 구현하는 기술은 1. 메서드 재정의와 2. 타입 변환이다.
자식 객체가 재정의된 메서드를 가지고 있을 경우, 부모 타입으로 자동 타입 변환 후에 메서드를 호출하면 재정의된 자식 메서드가 호출되면서 다양한 실행결과를 가져올 수 있다.

---

//부모 클래스
class Tire{
}
//자식 클래스
class HankookTire extends Tire{
}
//자식 클래스
class KumhoTire extends Tire{
}

class CarExample{
          public static void main(String[] args){
          //부모클래스 = 자식클래스
                    Tire t = new HankookTire

Q2) 출력 결과 알아보기
코드 1)

public class Tire {
	public void run() {
		System.out.println("일반 타이어가 굴러갑니다.");
	}
}

코드 2)

public class SnowTire extends Tire{
	//메서드 재정의(오버라이딩)
	public void run() {
		System.out.println("스노우 타이어가 굴러갑니다.");
	}
}

코드 3)

public class SnowTireExample {
	public static void main(String[] args) {
		SnowTire snowTire = new SnowTire();
		
		//참조 자동 타입 변환
		Tire tire = snowTire;
		
		snowTire.run();
		tire.run();
	}
}

결과)
자식 객체가 재정의된 메서드를 가지고 있을 경우, 부모 타입으로 자동 타입 변환 후에 메서드를 호출하면 재정의된 자식 메서드가 호출되면서 다양한 실행결과를 가져올 수 있다.

스노우 타이어가 굴러갑니다.
스노우 타이어가 굴러갑니다.

Q3) 
A 부모 클래스, B 자식 클래스인 상황에서 
A a = new B(); //선행 후
B b = (B) a; 가능하다.

---

Q5) service.login() 메서드를 호출하면 출력되는 내용을 구하라.
(부모) Service ← MemberService ← AService (자식)

전체 코드)

전체 코드

코드 1) Service.java

package ch07_exercise;
//[1]
public class Service {
	public void login() {
		System.out.println("로그인");
	}
}

코드 2) MemberSerive.java

package ch07_exercise;
//[2]
public class MemberService extends Service {
	public void login() {
		System.out.println("멤버 로그인");
	}
}

코드 3) AService.java

package ch07_exercise;
//[3]
public class AService extends MemberService {
	public void login() {
		System.out.println("A 로그인");
	}
}

코드 4) ServiceExample.java

		0x100
controller	0x100 <---	Controller
		service
		public void setService(MemberService service) { this.service = service; }

package ch07_exercise;
//[4]
public class ServiceExample {
	public static void main(String[] args) {
		Controller controller = new Controller();
		
		controller.setA(10);
		
		controller.setService(new MemberService());
		controller.service.login();//출력 결과: 멤버 로그인
		
		controller.setService(new AService());
		controller.service.login();//출력 결과: A 로그인
	}
}

코드 5) Controller.java

전체 코드

코드 [4]와 함께 보기 :)

int a = 10;
MemberService service = new MemberService()
MemberService service = new AService()

package ch07_exercise;
//[5]
public class Controller {
	public MemberService service;
	
	public void setA(int a) {
		this.a = a;
	}
	
	public void setService(MemberService service) {
		this.service = service;
	}
}

결과)

멤버 로그인
A 로그인

---