TIL(Today I Learned)_230727

☝🏻오늘 배운 것

1. 상속

- 상속이란?

: 다른 클래스(부모클래스)가 가지고 있는 멤버(필드, 메소드)들을 새로 작성할 클래스(자식 클래스)에서 직접 만들지 않고 상속을 받음으로써 새 클래스가 자신의 멤버처럼 사용할 수 있는 기능
-> 부모 객체를 자식 객체 안에 생성하여 자식객체를 부모객체를 자신 것 처럼 사용할 수 있다.

- 상속의 목적과 장점

1. 목적 :
   클래스의 재사용, 연관된 일련의 클래스들에 대한 공통적인 규약 정의(오버라이딩)

2. 장점 :
   1) 보다 적은 양의 코드로 새로운 클래스 작성 가능
   2) 코드를 공통적으로 관리하기 때문에 코드의 추가 및 변경 용이
   3) 코드의 중복을 제거하여 프로그램의 생산성과 유지보수에 크게 기여

- 상속의 방법

1. 클래스 간의 상속 시에는 extends 키워드 사용
2. 표현식 :

• [접근제한자] class 자식 클래스명 extends 부모 클래스명 { }
• public class Academy extends Company { }

- 상속의 특징

1. 모든 클래스는 Object클래스의 후손이다.
   Object클래스가 제공하는 메소드를 오버라이딩하여 메소드의 재구현이 가능하다.
   ex) java.lang.String 클래스의 equals()와 toString()..

2. 부모클래스의 생성자, 초기화 블록은 상속 안 됨
   자식 클래스 생성 시, 부모 클래스 생성자가 먼저 실행된다.
   만약 자식 클래스 생성자 안에서 부모 클래스 생성자 호출을 명시하고 싶으면 super() 활용해야한다.

3. 부모의 private멤버는 상속은 되지만 직접은 접근 불가하다.
   자식 객체 생성 시에 부모의 필드 값도 전달 받은 경우,
   자식 생성자 안에서 부모의 private 필드에 직접 접근하여 대입 불가한데, 이럴 경우에는
   1) super() 이용하여 전달받은 부모 필드 값을 부모 생성자 쪽으로 넘겨서 생성하거나
   2) setter, getter 메소드를 이용하여 접근해야함.

- super() 생성자

: 부모 객체의 생성자를 호출하는 메소드이다.
: 후손 클래스 생성자 안에는 부모 생성자를 호출하는 super()가 첫 줄에 존재해야한다. (부모 생성자가 가장 먼저 실행되어야 하기 때문에 명시적으로 작성 시에도 반드시 첫 줄에만 작성)
: 매개변수가 있는 부모 생성자 호출은 super(매개변수, 매개변수...)를 넣으면 됨

- super. 참조 변수

: 상속을 통한 자식 클래스 정의 시 해당 자식 클래스의 부모 객체를 가리키는 참조변수
자식 클래스 내에서 부모 클래스 객체에 접근하여 필드나 메소드 호출 시 사용

2. 오버라이딩(Overriding)

- 오버라이딩이란?

: over - 위/상위 라는 뜻도 있음 -> overriding은 위에 올라탔다라고 생각하기
: 자식 클래스가 상속 받은 부모 메소드를 재작성 하는 것(재정의)
: 부모가 제공하는 기능을 후손이 일부 고쳐 사용하겠다는 의미로 자식 객체를 통한 실행 시 후손 것이 우선권을 가짐

- 오버라이딩 특징

1. 메소드 헤드라인 위에 반드시 Annotation(주석), @Override를 표시해야함
   : @Override 어노테이션 -> 해당 메소드가 오버라이딩 되었음을 컴파일러에게 알려주는 역할을 하며 컴파일러에게 문법 체크를 하도록 알린다.
   : 어노테이션(Annotation) -> 컴파일러에게 알려주기 위한 코드(컴파일러 인식용 주석)
2. 접근 제어자를 부모 것보다 같거나 넓은 범위로 변경 가능
3. 부모 메소드의 예외처리 클래스 처리범위보다 좁은 범위로 예외처리 클래스 수정 가능

- 성립 조건

: 메소드 이름이 동일해야함
: 매개변수의 개수, 타입, 순서 모두 동일해야함
: 리턴 타입이 동일해야함
: 📌private 메소드는 오버라이딩 불가함.

- 오버라이딩/ 오버로딩 비교

- 상속 예제

✅ Person 클래스(부모 클래스)

package edu.kh.inheritance.model.vo;

public class Person {
	
	// 필드
	private String name; // 이름 
	private int age; // 나이
	private String nationality; // 국적
	
	// 생성자
	public Person() {} // 기본생성자
	
	public Person(String name, int age, String nationality) { // 매개변수 생성자 -> 오버로딩
		this.name = name;
		this.age = age;
		this.nationality = nationality;
	}
	
	// 메서드(getter/setter)

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getNationality() {
		return nationality;
	}

	public void setNationality(String nationality) {
		this.nationality = nationality;
	}
	
	public void breath() {
		System.out.println("사람은 코나 입으로 숨을 쉰다");
		
	}
	
	public void move() {
		System.out.println("사람은 움직일 수 있다.");
	}

	@Override
	public String toString() {
		return name + "/" + age + "/" + nationality;
	}
	
}

✅ Student 클래스(자식 클래스)

package edu.kh.inheritance.model.vo;

public class Student extends Person {
	// Student 클래스에 Person 클래스의 내용을 연장한다.
	// Student 클래스에 Person 클래스의 내용(필드, 메서드)을 추가하여 확장한다.
	
	// ***상송***
	// extends : 확장하다, 연장하다...
	
//	private String name;
//	private int age;
//	private String nationality;
	private int grade; // 학년
	private int classRoom; // 반
	
	
	public Student() {
		
		// Student() 객체 생성 시 
		// 내부에 상속받은 Person 객체를 생성하기위한
		// Person 생성자 호출 코드 필요하다!
		
		// super : 상위
		// 현재 Student의 suepr == Person
		super(); // super() 생성자
		// 부모의 생성자를 호출하는 코드로
		// 반드시 자식의 생성자 최상단에 작성되어야한다.
		// 부모의 생성자 실행(필드 초기화+특정기는 수행)
		
		// * super() 생성자 떄문에
		// 자식 객체 내부에 부모객체가 생성된다!
		
		// * super() 생성자 미작성시
		// 컴파일러가 컴파일 단계에서 자동으로 추가해줌.
	
	}
	
	
	public Student(String name, int age, String nationality, int grade, int classRoom) {
//		this.name = name;
//		this.age = age;
//		this.nationality = nationality;
		// 왜? 부모의 필드에 private 접근제한자가 있어서
		// 아무리 물려받은 자식이라도 다른 객체이기 때문에 직접접근 불가
		
		// 부모의 setter를 이용할 수 있지만 모두 작성하기에는 비효율적이다.
		
		super(name, age, nationality); // 부모의 매개변수 생성자 호출
		
		this.grade = grade;
		this.classRoom = classRoom;
	}

	
//	public String getName() {
//		return name;
//	}
//
//	public void setName(String name) {
//		this.name = name;
//	}
//
//	public int getAge() {
//		return age;
//	}
//
//	public void setAge(int age) {
//		this.age = age;
//	}
//
//	public String getNationality() {
//		return nationality;
//	}
//
//	public void setNationality(String nationality) {
//		this.nationality = nationality;
//	}

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = grade;
	}

	public int getClassRoom() {
		return classRoom;
	}

	public void setClassRoom(int classRoom) {
		this.classRoom = classRoom;
	}
	
	@Override
	public String toString() {
		return super.toString() + "/" + grade + "/" + classRoom;
	}
}

✅ Employee 클래스(자식 클래스)

package edu.kh.inheritance.model.vo;

public class Employee extends Person{
	
//	private String name;
//	private int age;
//	private int nationality;
	private String company;
	
	
	public Employee() {}
	
	public Employee(String name, int age, String nationality, String company) {
//		this.name = name;
//		this.age = age;
//		this.nationality = nationality;
		this.company = company;
	}
	

//	public String getName() {
//		return name;
//	}
//
//	public void setName(String name) {
//		this.name = name;
//	}
//
//	public int getAge() {
//		return age;
//	}
//
//	public void setAge(int age) {
//		this.age = age;
//	}
//
//	public String getNationality() {
//		return nationality;
//	}
//
//	public void setNationality(String nationality) {
//		this.nationality = nationality;
//	}

	public String getCompany() {
		return company;
	}

	public void setCompany(String company) {
		this.company = company;
	}
	
	// Person으로 부터 상속받은 메서드 중 
	// move() 메서드를 Employee에 맞게 재정의(==오버라이딩)
	
	//@Override 어노테이션 : 해당 메소드가 오버라이딩 되었음을 컴파일러에게 알려주는 역할
							// -> 컴파일러에게 문법 체크를 하도록 알린다.
	// 어노테이션(Annotation) : 컴파일러에게 알려주기 위한 코드(컴파일러 인식용 주석)
	
	@Override
	public void move(){
		
		System.out.println("오버라이딩 된 move()");
		System.out.println("효율적으로 빨리 일하고 움직인다.");
		
	}
	
	@Override
	public String toString() {
		return super.toString() + "/" + company;
	}
}

✅ InheritanceService 클래스(실행클래스)

package edu.kh.inheritance.model.service;

import java.util.Scanner;

import edu.kh.inheritance.model.vo.Employee;
import edu.kh.inheritance.model.vo.Person;
import edu.kh.inheritance.model.vo.Student;

public class InheritanceService {
	
	public void ex1() { // 상속 확인 예제
		// Person을 상속받은 Student가 Person의 필드, 메소드를 사용할 수 있는가?
		
		
		Person p = new Person();
		
		//p.name = "홍길동"; // private 때문에 직접 접근 불가(에러발생) -> getter setter 사용해야함
		p.setName("홍길동");
		p.setAge(25);
		p.setNationality("대한민국");
		
		System.out.println(p.getName());
		System.out.println(p.getAge());
		System.out.println(p.getNationality());
		
		System.out.println("==============================");
		
		// Student 객체 생성
		Student std = new Student();
		
		// Student만의 고유 필드
		std.setGrade(3);
		std.setClassRoom(5);
		// Person 클래스로부터 상속받은 필드, 메서드
		std.setName("고길동");
		std.setAge(19);
		std.setNationality("대한민국");
		
		System.out.println(std.getGrade());
		System.out.println(std.getClassRoom());
		
		// Student가 Person의 메소드 뿐 아니라 필드도 상속 받았는지 확인
		System.out.println(std.getName());
		System.out.println(std.getAge());
		System.out.println(std.getNationality());
		
		System.out.println("==============================");
		
		Employee emp = new Employee();
		
		emp.setCompany("kh정보교육원");
		
		// Person클래스로부터 상속받은 메서드 
		emp.setName("최지은");
		emp.setAge(30);
		emp.setNationality("대한민국");
		
		System.out.println(emp.getCompany());
		System.out.println(emp.getName());
		System.out.println(emp.getAge());
		System.out.println(emp.getNationality());
		
		// 추가된 breath메서드 상속 확인하기
		p.breath();
		std.breath();
		emp.breath();
		// 상속의 특징 : 코드 추가 및 수정에 용이함
		// -> 부모에게 정의하면 상속받은 자식들은 모두 부모의 것을 그대로 받아서 쓸 수 있음
	}
	
	// super() 생성자 사용 방법
	public void ex2() {
		
		// Student 매개변수 5개짜리 생성자
		Student std = new Student("김철수", 17, "한국", 1, 3);
		
		System.out.println(std.getName());
		System.out.println(std.getAge());
		System.out.println(std.getNationality());
		
		System.out.println(std.getGrade());
		System.out.println(std.getClassRoom());
		
	}
	
	public void ex3() { // 오버라이딩 확인 예제
		
		Student std = new Student();
		Employee emp = new Employee();
		
		std.move(); // 오버라이딩x -> Person의 메소드 수행
		emp.move(); // 오버라이딩ㅇ -> Employee의 메소드 수행
	
	}
	
	public void ex4() {
		// 모든 클래스는 Object 클래스의 후손
		// == 모든 클래스의 최상위 부모는 Object
		
		// class명에 Object에대한 상속구문이 없다면 컴파일러가 자동으로 extends Object구문을 추가해줌
		
		Person p = new Person();
		// Object 를 상속받은 Person 객체 생성
		
		Student std = new Student();
		// Person을 상속받은 Student 객체 생성
		
		// Object - Person - Student 
		
		System.out.println(p.hashCode());
		System.out.println(std.hashCode());
		// Person이 Object에서 물려받은 hashCode()를 Student가 또 물려받아 사용
		
		String str = "abc";
		Scanner sc = new Scanner(System.in);
		
		System.out.println(str.hashCode());
		// String이 Object 상속받음
		System.out.println(sc.hashCode());
		// Scanner가 Object 상속받음
		
	}
	
	public void ex5() { // toString 사용 예제
		
		Person p = new Person("김철수", 17, "한국");
		
		System.out.println(p.toString());

		System.out.println(p);
		// print 구문 수행 시 참조변수명을 작성하면
		// 자동으로 toString() 메소드를 호출해서 출력한다
		
		Student std = new Student("이백점", 18, "미국", 2, 6);

		System.out.println(std.toString());
		System.out.println(std);
		
		Employee emp = new Employee("최지은", 30, "한국", "kh정보교욱원");
		
		System.out.println(emp);
				
	}
}

3. 다형성

- 다형성이란?

: 객체 지향 언어의 특징 중 하나로 ‘다양한 형태를 갖는다’라는 뜻으로 하나의 행동으로 여러 가지 일을 수행하는 개념.
: 상속을 이용한 기술로 부모 클래스 타입 참조변수 하나로 상속 관계에 있는 여러 타입의 자식 객체를 참조할 수 있는 기술

- 업 캐스팅(Up Casting)

: 상속 관계에 있는 부모, 자식 클래스 간에
부모타입의 참조형 변수가 모든 자식 타입 객체의 주소를 참조할 수 있음
: 자식 -> 부모로 캐스팅

- 다운 캐스팅(Down Casting)

: 부모타입 참조변수가 자식 객체를 참조하는 기술로 업캐스팅 상태에서만 진행할 수 있다.
: 부모타입을 자식타입으로 "강제 형변환"해서 자식 객체의 본래 필드, 메소드를 사용 가능하게 한다.
: 주의할 점 -> 연산자가 형변환 연산자보다 우선순위가 높음 -> ()로 한 번 더 처리해줘야함
System.out.println(((Tesla)c1).getBatteryCapacity());
: 다운 캐스팅 시 형변환 예외(자식 <=> 자식 간)가 발생할 수 있는 문제가 있음. -> istanceof를 사용해 형변환(다운캐스팅)이 가능한지 확인해야한다!

- instanceof 연산자

: 객체의 자료형을 검사하는 연산자 -> 참조하는 객체가 특정 자료형이거나 부모 쪽 상속관계인지 확인
: 현재 참조형변수가 어떤 클래스 형의 객체주소를 참조하고 있는지 확인할 때 사용
: 클래스 타입이 맞으면 true, 맞지 않으면 false 반환

- 바인딩

: 실제 실행할 메소드 코드와 호출하는 코드를 연결 시키는 것
1. 정적바인딩
: "프로그램이 실행되기 전" 컴파일 단계에서 메소드와 메소드 호출부를 연결
2. 동적 바인딩
: "컴파일 시" 정적 바인딩된 메소드를 실행할 당시의 객체 타입을 기준으로 바인딩 되는 것

- 다형성 예제

✅ Car 클래스 (부모)

package edu.kh.poly.ex1.mode.vo;

public class Car {
	
	private String engine; // 엔진
	private String fuel; // 연료
	private int wheel; // 휠개수
	
	public Car() {}

	// 매개변수 생성자 단축키 : alt + shift + s -> o -> enter
	public Car(String engine, String fuel, int wheel) {
		super(); // Object 상속
		this.engine = engine;
		this.fuel = fuel;
		this.wheel = wheel;
	}

	
	
	public String getEngine() {
		return engine;
	}

	public void setEngine(String engine) {
		this.engine = engine;
	}

	public String getFuel() {
		return fuel;
	}

	public void setFuel(String fuel) {
		this.fuel = fuel;
	}

	public int getWheel() {
		return wheel;
	}

	public void setWheel(int wheel) {
		this.wheel = wheel;
	}
	
	
	// Object.toString() 오버라이딩
	@Override // 오버라이딩 했다는걸 알려주는 Override Annotation
	public String toString() {
		return engine + "/" + fuel + "/" + wheel;
	}

}

✅ Telsa 클래스 (자식)

package edu.kh.poly.ex1.mode.vo;

public class Tesla extends Car{ // 전기차
	
	private int batteryCapacity;// 배터리용량
	
	
	public Tesla() {}

	// alt + shift + s -> o -> 아래방향키 -> enter
	// 매개변수 생성자 + 상속받은 것도 포함
	public Tesla(String engine, String fuel, int wheel, int batteryCapacity) {
		super(engine, fuel, wheel);
		this.batteryCapacity = batteryCapacity;
	}

	
	public int getBatteryCapacity() {
		return batteryCapacity;
	}


	public void setBatteryCapacity(int batteryCapacity) {
		this.batteryCapacity = batteryCapacity;
	}

	@Override // Car.toString을 오버라이딩한 것
	public String toString() {
		return super.toString() + batteryCapacity;
	}
	
}

✅ Spark 클래스 (자식)

package edu.kh.poly.ex1.mode.vo;

public class Spark extends Car{ // 경차
	
	
	private double discountOffer; // 할인혜택
	
	
	public Spark() {}


	public Spark(String engine, String fuel, int wheel, double discountOffer) {
		super(engine, fuel, wheel);
		this.discountOffer = discountOffer;
	}


	public double getDiscountOffer() {
		return discountOffer;
	}


	public void setDiscountOffer(double discountOffer) {
		this.discountOffer = discountOffer;
	}

	
	
	@Override
	public String toString() {
		return super.toString() + discountOffer;
	}
}

✅ PolyService 클래스 (실행클래스)

package edu.kh.poly.ex1.model.service;

import java.nio.file.spi.FileSystemProvider;

import edu.kh.poly.ex1.mode.vo.Car;
import edu.kh.poly.ex1.mode.vo.Spark;
import edu.kh.poly.ex1.mode.vo.Tesla;

public class PolyService {
	
	public void ex1() { // 다형성 확인 예제
		
		// Car 객체 생성
		Car car = new Car(); 
		// 부모 타입 참조변수 = 부모 객체
		
		// Tesla 객체 생성
		Tesla tesla = new Tesla();
		// 자식타입 참조변수 = 자식 객체
		
		// *******************다형성*********************
		
		Car car2 = new Tesla();
		// 부모타입 참조변수 = 자식 객체
		// Tesla 객체를 참조하는 변수의 타입이 Car(부모)이기 때문에
		// Tesla 객체가 Car(부모)객체로 변화함
		
		Spark spark = new Spark();
		
		Car car3 = new Spark();
		// 부모타입 참조변수 = 자식 객체 
		
		// ****다형성(업케스팅)작성 방법*****
		// 1) 자식객체가 부모객체로 변하였기 때문에
		// 자식만의 고유한 필드, 메소드를 사용할 수 없다.
		
		// 1-1) car(부모 = 부모)
		car.setEngine("v6 6기통 엔진");
		car.setFuel("휘발유");
		car.setWheel(4);
		// Car 메소드 모두 사용 가능
		
		// 1-2) tesla (자식 = 자식)
		tesla.setEngine("전기모터");
		tesla.setFuel("전기");
		tesla.setWheel(4);
		tesla.setBatteryCapacity(1000000);
		// Tesla 메소드 모두 사용 가능
		
		// 1-3) car2 (부모 = 자식(Tesla))
		car2.setEngine("전기모터");
		car2.setFuel("전기");
		car2.setWheel(4);
		//car2.setBatteryCapacity(1000000);
		// Tesla 본연의 메소드 사용 불가
		//The method setBatteryCapacity(int) is undefined for the type Car
		
		car3.setEngine("경차 엔진");
		car3.setFuel("휘발유");
		car3.setWheel(4);
		//car3.discountOffer(4);
		// Spark 본연의 메소드 사용 불가
		
		//**************************************
		
		// 2) 다형성을 이용한 객체 배열
		
		// 객체 배열 : 같은 객체 참조 자료형의 변수를 하나의 묶음으로 다루는 것
					// 부모타입 참조 자료형의 변수를 하나의 묶음으로 다루는 것
		
		Car[] arr = new Car[3]; // 부모타입 참조변수 배열 선언 및 할당
		// 각 배열의 요소가 Car 타입
		
		arr[0] = car; // Car 주소
		arr[1] = car2; // Tesla 주소
		arr[2] = car3; // Spark 주소
	
		for(int i = 0; i < arr.length; i++) {
			
			System.out.println(i + "번째 인덱스의 " + arr[i].getEngine());
			System.out.println(i + "번째 인덱스의 " + arr[i].getFuel());
		}
		
		// 상속 + 다형성이 되어있는 상태로
		// 상속특징 : Car 상속클래스는 모두 getEngine()을 가지고 있다를 정의
		// 다형성(업캐스팅) : 부모타입 참조변수 arr[i]로 자식 객체를 참조할 수 있다. 
		
		}
	
	
	public void ex2() { // 3) 다형성(업캐스팅)을 이용한 매개변수 사용법
		
		Tesla t = new Tesla("전기모터", "전기", 4, 1000000);
		
		Spark s = new Spark("경차엔진", "휘발유", 4, 0.5);
		
		Car c = new Car("경유엔진", "경유", 4);
		
		
		printCar(t);
		printCar(s);
		printCar(c);
		System.out.println("================================");
		
		// 4) 다형성을 이용한 변환형 사용법
		//Car[] arr = {new Car(), new Tesla(), new Spark()};
		
		Car[] arr = {createCar(1), createCar(2), createCar(3)};
					// Car			// Car		// Car
									// (Tesla)	// (Spark)
		
		// instanceof 연산자 : 객체의 자료형을 검사하는 연산자
		// -> 참조하는 객체가 특정 자료형이거나 부모쪽 상속관계인지 확인
		
		System.out.println( arr[1] instanceof Tesla ); // true
		System.out.println( arr[1] instanceof Spark ); // false
		System.out.println( arr[1] instanceof Car ); // true
		
	}
	
	// 전달받은 Car 또는 자식 객체의 엔진, 연료, 바퀴 개수를 출력하는 메서드
	// 매개변수에 부모타입 참조변수를 작성하면 모든 자식 객체를 전달받을 수 있다.
	// 부모타입 참조변수 = 자식타입 객체
	// 다형성의 업캐스팅 모양과 같다.
	// temp에는 Tesla, Spark, Car의 주소가 넘어와도 된다(업캐스팅)
	public void printCar(Car temp){
		
		System.out.println("엔진 : " + temp.getEngine());
		System.out.println("연료 : " + temp.getFuel());
		System.out.println("바퀴 갯수 : " + temp.getWheel());
		System.out.println();
		
	}

	
	public Car createCar(int num) {
		
		Car result = null;
		
		switch(num) {
		case 1 : result = new Car(); break;
		case 2 : result = new Tesla(); break;
		case 3 : result = new Spark(); break;
		}
		
		return result;
	}
	
	
	public void ex3() {
		
		// ********** 다형성 중 다운캐스팅 ***************
		
		// 다운 캐스팅이란?
		// 부모타입 참조변수가 자식 객체를 참조하는 기술로
		// 업캐스팅 상태에서만 진행할 수 있다.
		// 부모타입을 자식타입으로 "강제 형변환"해서
		// 자식 객체의 본래 필드, 메소드를 사용 가능하게 한다.
		
		Car c1 = new Tesla("전기모터", "전기", 4, 50000000);
		
		System.out.println(((Tesla)c1).getBatteryCapacity());
		// 주의!! . 연산자가 형변환 연산자보다 우선순위가 높음 -> ()로 한 번 더 처리해줘야함
		
		
		Tesla t1 = (Tesla)c1; // 다운캐스팅 후 얕은복사
		System.out.println(t1.getBatteryCapacity());
		
	}
	
	public void ex4() {
		// 다운 캐스팅 주의 사항!
		
		Car c1 = new Tesla();
		
//		Spark s1 = (Spark)c1;
		
		// c1이 참조하는 객체는 Tesla인데
		// Spark 참조변수로 Tesla를 참조하려고하면 문제가 있음.
		// java.lang.ClassCastException: : 형변환 예외
		
		// 해결방법 : istanceof와 같이 사용해야한다!
		
		if(c1 instanceof Spark) {
			Spark s1 = (Spark)c1; // 다운캐스팅
			System.out.println("성공");
		}
		
		System.out.println("실패 (Spark 타입이 아님)");
		
	}
	
	public void ex5() {
		// 바인딩 : 실제 실행할 메소드 코드와 호출하는 코드를 연결시키는 것
		
		
		Car c1 = new Car("경유엔진", "경유", 8);
		
		System.out.println(c1.getEngine());
		// Car 객체에 있는 getEngine() 메서드를 호출 == 바인딩
		
		// 프로그램 실행 전
		// 컴파일러는 getEngine() 메소드가 Car에 있는걸로 인식해서
		// c1.getEngine()호출코드와
		// edu.kh.poly.ex1.mode.vo.Car.getEngine() 메소드 코드를 연결
		// -> 정적 바인딩
		
		System.out.println(c1.toString());
		// String edu.kh.poly.ex1.mode.vo.Car.toString()
		// Car 참조변수 c1을 이용해서
		// Car 객체에있는 오버라이딩된 toString() 메소드를 호출
		
		// *** 다형성 적용 시 바인딩***
		Car c2 = new Spark("경차엔진", "휘발유", 4, 0.5);
		// 업캐스팅 적용 -> 부모 부분만 참조 가능한 상태
		
		System.out.println(c2.toString());
		// String edu.kh.poly.ex1.mode.vo.Car.toString()
		
		// 참조변수 c2가 Car타입 이므로
		// toString()도 Car의 toString()을 호출 - 정적 바인딩
		
		// 하지만 실행해보면 자식Spark의 toString이 호출되는 것을 확인할 수 있다.
		// -> 컴파일 시에는 부모(Car)와 바인딩
		// -> 실행 시에는 자식(Spark)에 오버라이딩된 메소드와 바인딩 == 동적 바인딩
		
	}
}

✅ PolyRun 클래스

package edu.kh.poly.ex1.run;

import edu.kh.poly.ex1.model.service.PolyService;

public class PolyRun {

	public static void main(String[] args) {
		
		PolyService service = new PolyService();
		
		service.ex1();
		service.ex2();
		service.ex3();
		service.ex4();
		service.ex5();
		
	}

}