Java InheritanceTest(1~8)

InheritanceTest1

// 객체지향 구성 요소 : 캡슐화, 정보은닉, 상속, 다형성
// 객체지향에서 코드 재사용을 담당하는 요소 : 상속
// 부모 클래스, base 클래스, super 클래스
class Parent {
  int a;
  Parent(){
    System.out.printIn("부모 생성");
  }
}
// 자식 클래스, derived 클래스(파생 클래스), sub클래스
class Child extends Parent{
  int b;
  Child() {
    System.out.printIn("자식 생성");
  }
  public void print() {
    System.out.printIn(this.a);
    System.out.printIn(this.b;
    System.out.printIn(super.a);
  }
}
public class inheritanceTest1 {
  public static void main(String[] args){
    Child obj = new Child();
    // 부모 생성> 자식 생성. 자식안에 부모가 들어있다.
  }
}

InheritanceTest2

class Parent2 {
  int a = 10;
public void print(){
  System.out.printIn(a);
}
}
class Child2 extends Parent2 {
  int b =20;
// 부모 클래스와 똑같은 메소드를 작성한다.
public void print(){
  System.out.printIn(a+b);
}
// Child2가 상속에 의해 super.print()를 가진다. 이때 print()를
// 호출하면 super.print()를 실행
// Child2가 super.print()를 재정의하면 super.print, this.print()존재
// 이 경우 this.print()가 실행
}
public class IngeritanceTest2 {
  public static void main(String[] args){
    Child2 obj = new Child2();
    obj.print();
  }
}

InheritanceTest3

// 캡슐화, 정보은닉, 상속, 다형성 - overload(중복정의), override(재정의)
// → SOLID
// overload : 사람이 생각할 때 비슷한 동작이면 메소드 이름 같게하기
// 사진을 출력, 텍스트 파일을 저장, 성적표 출력
//  → print(사진), print(내용), print(성적)
// override : 상속 기반
// 부모와 자식이 동일한 메소드를 가진다. 이때 this의 메소드가 실행
// super의 메소드: 이름을 정한다(표준)
// S : 단일 책임 원칙 - 클래스는 1인분만 해야한다.
// O : 개방 폐쇄 원칙 - 기능의 개선에 대해서는 개방, 코드의 변경에 대해서는 폐쇄
// L : Liskov 치환원칙 - 부모와 자식은 똑같이 생겨야한다. extends금지
// I : 인터페이스 분리 원칙 - 부모를 작게 분해해라.
// D : 의존성 역전 원칙 - 스프링에서는 제어의 역전 원칙(부모로 작업)
class 도형 {
  public void paint() {
  }
}
class 삼각형 extends 도형 {
  public void paint(){
    System.out.printIn("삼각형 출력");
  }
}
class 사각형 extends 도형 {
  public void paint(){
    System.out.printIn("사각형을 그려요");
  }
}
class 원 extends 도형 {
  public void paint(){
    System.out.printIn("원 그리기");
  }
}
public class InheritanceTest3{
}

InheritanceTest4

class 부모 {
  int a;
}
class 자식 extends 부모{
  int b;
}
public class InheritanceTest4 {
 public static void main(String[] args){
   부모 ob1 = new 부모();
   // 부모 클래스의 참조변수는 자식을 가리킬 수 있다.
   // 우리가 사용하는 객체는 자식
   // 자식을 반드시 부모 클래스의 참조 변수로 가리키게 해야함
   부모 ob2 = new 자식();
   // 자식 ob3 = new 부모();
   자식 ob4 = new 자식();
   
   System.out.printIn(ob2.a);
   System.out.printIn(ob2.b;
   
   System.out.printIn(((자식)ob2).b);
 }
}

InheritanceTest5

class 고양이 {
  public void meow(){
    System.out.printIn("야옹~~~~~");
  }
}
class 개{
  public void bowwow(){
    System.out.printIn("멍멍");
  }
}
class 동물병원 {
  public void 예방접종(개 dog){
    dog.bowwow();
  }
  public void 예방접종(고양이 cat){
    cat.meow();
  }
}
public class InheritanceTest5 {
  public static void main(String[] args){
    // 부모 클래스의 참조 변수는 자식을 가리킬 수 있다.
    // 부모를 처리하는 함수는 자식도 처리할 수 있다.
  }
}

InheritanceTest6

class Livestock{
  public void cry(){
  }
}
class Cat extends Livestock{
  public void cry(){
     System.out.printIn("야옹~~~~~");
  }
}
class Dog extends Livestock{
  public void cry(){
    System.out.printIn("멍멍");
  }
}
class Hospital{
  public void injection(Livestock animal){
    // 1. 부모 클래스를 만들고
    // 2. 부모 클래스에 자식들이 오버라이드할 메소드의 이름을 정의
    // 이제 새로운 가축들을 계속 추가해도 injection에는 변화 없음
	animal.cry();
  }
}
public class InheritanceTest6 {
  public static void main(String[] args){
    Dog dog = new Dog();
    Hospital h = new Hospital();
    h.injection(dog);
    Livestock animal = new Dog();
    h.injection(animal);
  }
}

InheritanceTest7

import java.util.*;

class 정규직사원{
  public void 월급수령(){
    System.out.printIn("호봉과 보너스에 따라 급여가 지급됩니다.");
  }
}
class 계약직사원{
  public void salary() {
    System.out.printIn("정해진 급여가 지급됩니다.");
  }
}
class 파트타이머{
  public void pay() {
    System.out.printIn("근무시간*시급을 지급합니다.");
  }
}
class 부서 {
  // 정규직 1, 계약직 1, 파트타이머 1
  ArrayList list = new ArrayList();
public void init(){
  list.add(new 정규직사원());
  list.add(new 계약직사원());
  list.add(new 파트타이머());
}
public void 급여지급(){
  for(Object obj:list){
    if(obj instanceof 정규직사원) ((정규직사원)obj).월급수령();
    else if(obj instanceof 계약직사원) ((계약직사원)obj).salary();
    else if(obj instanceof 파트타이머) ((파트타이머)obj).pay();
  }
}
}
public class InheritanceTest7 {
  public static void main(String[] args){
  }
}

InheritanceTest8

import java.util.*;

abstract class Employee{
  // 함수는 {}가 있어야한다 - {} 생략? - 구현하지 않은 함수 - 추상 메서드
  // 추상 메소드를 가지는 클래스 - 추상클래스라고하고 new 불가능
  public abstract void pay();
}
// 추상 클래스를 상속하면 자식도 추상 클래스가 된다 -> 자식에서 구현해라
class FulltimeWoker extends Employee {
  @Override
  public void pay(){
    System.out.printIn("호봉과 보너스에 따라 급여가 지급됩니다.");
  }
}
class ContractWoker extends Employee {
  public void pay(){
    System.out.printIn("호봉과 보너스에 따라 급여가 지급됩니다.");
  }
}
class ParTimer extends Employee {
  public void pay(){
    System.out.printIn("호봉과 보너스에 따라 급여가 지급됩니다.");
  }
}
class Dept {
  // 정규직 1, 계약직 1, 파트타이머 1
  ArrayList<Employee> list = new ArrayList<>();
public void init(){
  list.add(new FulltimeWorker());
  list.add(new ContractWorker());
  list.add(new PartTimer());
}
public void 급여지급() {
  for(Employee e:list){
    e.pay();
  }
}
}
public class InheritanceTest8 {
  public static void main(String[] args(){
    Dept d = new Dept();
    d.init();
    d.급여지급();
  }
}