chapter13 : inheritance_annotation

1.1 상속 (Inheritance)
 - 부모가 자식에게 물려주는 행위를 말한다.
 - 기존 클래스를 재활용 하는 것이다.
 - 기존 클래스를 확장(extends)하는 것이다.
 - 상속을 이용하면 동일한 내용을 여러 번 작성 할 필요가 없다.(중복 제거)
 - private 접근 제한을 갖는 필드와 메소드는 상속 대상에서 제외된다.

1.2 상속이 가능한 경우
 - IS-A 관계가 성립할 때 (A는 B다.)
 	ex) 전기차는 자동차이다.
 		학생은 사람이다.
 		extend

 - HAS-A 관계가 성립할 때 (A는 B를 가지고 있다.)(비추천!!)
 	ex) 자동차는 핸들을 가지고 있다.
 		사람은 가방을 가지고 있다.
 		객체 생성

1.3 상속 문법
	class 부모클래스(=슈퍼클래스) {
	}
	class 자식클래스(=서브클래스) extends 부모클래스 {
	}

1.4 상속 특징
 - 서브클래스는 슈퍼클래스의 멤버(필드,메소드)를 사용 할 수있다.
 - 한 개의 클래스만 상속 할 수 있다. (다중 상속이 불가능 하다.)-> c++은 가능! java는 불가능!
 - 상속 횟수는 제한이 없다.
 - 자바의 모든 클래스는  java.lang.Object 클래스를 슈퍼클래스로 가진다.
   ★★Object(최상위클래스,부모)
 (java.lang.Object 클래스 = 단군할배)
	class Person {   }
	자바에 의해 다음의 형태로 해석
	class Person extends Object {   } : Object 클래스의 멤버를 사용할 수 있다.

1.5 메소드 오버라이드 (Method Override) -> 오버로딩과 헷갈리지 말자!★★
 - 부모 클래스가 가지고 있는 메소드를 자식 클래스가 다시 만드는 것을 말한다.
 - 부모 클래스가 가지고 있는 메소드와 완전히 동일한 원형으로 다시 만든다.
	(리턴타입 + 메소드명 + 매개변수 => 모두  동일하다.)
 - 자식 클래스에서 부모클래스의 메소드를 다른 방식으로 재정의 하기 위해 사용
 	ex) 부모 : 자동차 문이 있다.
 		자식 : 자동차 문이 2개 있다.
 - 어노테이션 "@Override"를 붙이면 개발자의 실수를 줄일 수 있다.
	(동일한 원형이 아니면 에러 발생 시켜준다.)


*오버로딩- 메소드 똑같은기능 여러개 만드는것(중복가능)
*메소드 오버라이드- 부모의클래스를 받아서 자식이 입맛대로 변경이 가능하다

Q1. Test01.java 상속 관계로 구현하시오.

Student.java				- 필드 : String name, int age, String School
							- 메소드 : Constructor, output()
Worker.java					- 필드 : String name, int age, String job
							- 메소드 : Constructor, output()
→ 부모클래스는 알아서 만들어보자!(Human)
package org.joonzis.test;

class Human{
	String name;
	int age;
	public Human() {}
	public Human(String name, int age) {
		this.name = name;
		this.age = age;
	}
	void output() {
		System.out.println("이름 : " + name);
		System.out.println("나이 : " + age);
	}
}
class Student extends Human{
	String school;
	
	public Student() {}

	public Student(String name, int age, String school) {
		super(name, age);
		this.school = school;
	}
	@Override
	void output() {
		super.output();
		System.out.println("학교 : " + school);
	}
}


class Worker{
	
}
public class Test01 {
	public static void main(String[] args) {
		Student stu = new Student("김씨", 20, "대학교");
		stu.output();
	}
}
Q2. Test02.java 상속 관계로 구현하시오.
Notebook.java				- 필드 : String model, int price, int battery
							- 메소드 : Constructor, output()
Tablet.java					- 필드 : String model, int price, int battery, String pen
							- 메소드 : Constructor, output()
→ 부모클래스는 알아서 만들어보자!(Computer)
package org.joonzis.test;
class Computer{
	String model;
	int price;
	public Computer() {}
	public Computer(String model, int price) {
		this.model = model;
		this.price = price;
	}
	void output() {
		System.out.println("모델명 : " + model);
		System.out.println("가격 : " + price);
	}
}
class Notebook extends Computer{
	int battery;
	public Notebook() {}
	public Notebook(String model, int price, int battery) {
		super(model, price);
		this.battery = battery;
	}
	@Override
	void output() {
		super.output();
		System.out.println("배터리 파워 : " + battery);
	}
}
class Tablet extends Notebook{
	String pen;

	public Tablet(String model, int price, int battery, String pen) {
		super(model, price, battery);
		this.pen = pen;
	}
	@Override
	void output() {
		super.output();
		System.out.println("펜 정보 : " + pen);
	}
}
public class Test02 {
	public static void main(String[] args) {
		Notebook notebook = new Notebook("MSI", 2000000, 65);
		notebook.output();
		
		System.out.println("--------------------");
		
		Tablet tablet = new Tablet("갤럭시탭S8", 665000, 45, "그냥 펜");
		tablet.output();
	}
}
Q3. Test03.java 상속 관계로 구현하시오.
SalaryWorker.java			- 필드 : String name, String dept, int salary
							- 메소드 : Constructor, int pay(), output()
SalesWorker.java			- 필드 : String name, String dept, int salary , double salesIncentive
							- 메소드 : Constructor, int pay(), output(), int salesPay()
PartTimeWorker.java			- 필드 : String name, String dept, int workTime, int payPerHour
							- 메소드 : Constructor, int pay(), output()
→ 부모클래스는 알아서 만들어보자!(Employee)
SalaryWorker extends Employee
SalesWorker extends SalaryWorker
PartTimeWorker extends Employee

String name : 이름
String dept : 부서
int salary : 기본급(월급)
double salesIncentive : 판매 인센티브
int workTime : 근무시간
int payPerHour : 시급

package org.joonzis.test;

class Employee{
	String name, dept;
	public Employee() {}
	public Employee(String name, String dept) {
		this.name = name;
		this.dept = dept;
	}
	void output() {
		System.out.println("이름 : " + name);
		System.out.println("부서 : " + dept);
	}
}
class SalaryWorker extends Employee{
	int salary;
	public SalaryWorker() {}
	public SalaryWorker(String name, String dept, int salary) {
		super(name, dept);
		this.salary = salary;
	}
	int pay() {
		return salary;
	}
	@Override
	void output() {
		super.output();
		System.out.println("급여 : " + pay());
	}
}
class SalesWorker extends SalaryWorker{
	double salesIncentive;
	
	public SalesWorker() {}
	public SalesWorker(String name, String dept, int salary, double salesIncentive) {
		super(name, dept, salary);
		this.salesIncentive = salesIncentive;
	}
	int salesPay() {	// 수당
		return (int)(salary * salesIncentive);
	}
	@Override
	int pay() {
		return salary + salesPay();	// 기본급 + 수당
	}
	@Override
	void output() {
		super.output();
		System.out.println("수당 : " + salesPay());
	}
}
class PartTimeWorker extends Employee{
	int workTime, payPerHour;
	public PartTimeWorker() {}
	public PartTimeWorker(String name, String dept, int workTime, int payPerHour) {
		super(name, dept);
		this.workTime = workTime;
		this.payPerHour = payPerHour;
	}
	int pay() {
		return workTime * payPerHour;
	}
	@Override
	void output() {
		super.output();
		System.out.println("급여 : " + pay());
	}
}
public class Test03 {
	public static void main(String[] args) {
		SalaryWorker sal = new SalaryWorker("김씨", "개발부", 1000);
		sal.output();
		
		System.out.println("--------------------");
		
		SalesWorker sales = new SalesWorker("박씨", "영업부", 1000, 0.1);
		sales.output();
		
		System.out.println("--------------------");
		
		PartTimeWorker part = new PartTimeWorker("이씨", "판매원", 276, 10000);
		part.output();
	}
}