java :: OOP-3, 상속, 다형성, pakage(패키지)

상속
상속이란?
코드의 재활용을 보다 체계적으로 하기 위한 하나의 방법으로 나온 개념.
(부모의 재산을 물려받는 것을 의미)

상속의 장점
1. 개발시간을 단축
2. 코드의 재활용

상속관계(... is a 관계가 성립해야한다.)
extends를 통해 상속받는다.
자바는 단일 상속 개념

상속형식

Class 자식클래스 extends 부모클래스{

내용 기술;

} 

상속예제-1
(Itest.java)

class Super{
	int a=10;
	double b=20.0;
	
	public void fun(){
		System.out.println("fun메소드호출됨~");
	}
}

class Sub extends Super{  //super 클래스  상속
	int a=100;  
	//부모랑 중첩되는 변수들을 "중첩변수"라고 부른다. 중첩될 경우 자기자신의 변소를 먼저 사용한다.
	int c=30;
	
	public void sub(){  //대소문자가 다르므로 생성자 아님
		System.out.println("sub메소드호출됨~");
	}
	
	public void fun(){  //오버라이딩
		System.out.println("재정의한 fun()메소드가 호출됨");
		System.out.println("c="+c);
	}
}

public class ITest {
	public static void main(String[] args) {
		
		//부모객체 생성
		System.out.println("--Super객체--");
		Super sp=new Super();
		System.out.println("sp.a="+sp.a);
		System.out.println("sp.b="+sp.b);
		sp.fun();
		
		//자식객체생성
		System.out.println("--sub객체--");
		Sub sb=new Sub();
		System.out.println("sb.a="+sb.a);
		System.out.println("sb.b="+sb.b);
		System.out.println("sb.c="+sb.c);
		sb.sub();
		sb.fun();
		
		System.out.println("부모의 이름으로 자식 객체생성하기");
		Super s1=new Sub(); 
		System.out.println("s1.a="+s1.a);  //a값은 10을 호출함
		System.out.println("s1.b="+s1.b);  //
		//System.out.println("s1.c="+s1.c);  <-에러 Sub이라는 객체는 생성하지만 변수나 메소드는 사용할 수 없다.
		s1.fun();  //자식의 fun메소드를 호출하면서 위 줄에서 부르지 못한 c값까지 불러오는 것을 볼 수 있다.
		
		Sub s2=(Sub)s1;  //다운캐스팅 부모클래스에 있었던 s1을 자식클래스에 있는 s2로 옮김
		System.out.println("s2.c="+s2.c);
		s2.sub();
		
		Super arr[]=new Super[3];  //Super 배열을 만듬, 안에 공간만 만들어진 상태
		arr[0]=new Super();
		arr[1]=new Sub();
		arr[2]=new Super();
		//이렇게 하면 arr 공간 안에 Super클래스(부모), Sub클래스(자식) 모든 클래스를 관리할 수 있게 된다.
		
		for(int i=1;i<arr.length;i++){
			arr[i].fun();
		}
	}
}

상속예제-2
부모클래스
(BaseCar.java)

//부모클래스
public class BaseCar {

	String name;
	int maxspeed;
	
	public BaseCar(){
		//인자를 가진 생성자를 만들면 의무적으로 기본생성자를 만들어준다.
	}
	
	public BaseCar(String name, int speed){  
		//인자생성자를 하나라도 만들어주면 jvm에서 생성자를 만들어 주지 않는다.
		// 즉 기본 생성자가 없기 때문에 CarTest의 BaseCar c1=new BaseCar(); 구문 실행시 에러가 난다.
		this.name=name;
		maxspeed=speed;
	}
	
	public void getInfo(){
		System.out.println("이름:"+name);
		System.out.println("최고속도:"+maxspeed);
	}
}

자식클래스
(Gadian.java)

//BaseCar 클래스를 상속받는 자식 클래스
public class Gadian extends BaseCar {  //extends BaseCar를 적어 상속받을 클래스를 적는다.
	
	String item;
	
	public Gadian(String name, int speed, String item){
		//super()  이라는 자동으로 키워드를 호출하게 된다. <-부모의 생성자를 호출함
		super(name,speed);  // 직접 처리 방법
		this.name=name;
		maxspeed=speed;
		this.item=item;
	}
	
	public void getInfo(){  //다형성 OverRiding
		//System.out.println("이름은:"+name);
		//System.out.println("최고속도:"+maxspeed);
		super.getInfo();  //자기자신을 가르킬땐 this, 부모와 자식간에 부모를 가르킬땐 super를 사용
		System.out.println("아이템:"+item);
	}
	
	public void getInfo(String title){
		System.out.println(title);
		this.getInfo();  //위의 getInfo 메소드를 부르고 위의 getInfo메소드는 부모클래스의 getInfo를 호출
	}
}

자식클래스2
(BlackS.java)

public class BlackS extends BaseCar{
	
	String skill;
	
	public BlackS(String name,int speed, String skill){
		this.name=name;
		maxspeed=speed;
		this.skill=skill;
	}
	
	public void getInfo(){
		super.getInfo();
		System.out.println(skill);
	}
	
	public void getInfo(String title){
		System.out.println(title);
		this.getInfo();
	}
}

출력부분
(CarTest.java)

public class CarTest {
	public static void main(String[] args) {
		
		BaseCar c1=new BaseCar();
		c1.name="연습카트";
		c1.maxspeed=160;
		c1.getInfo();
		
		System.out.println("========================");
		
		Gadian c2=new Gadian("가디언",200,"황금아이템");  //BaseCar 클래스에서 Gadian이 상속받아 자기것 처럼 사용 함
		c2.getInfo();
		
		System.out.println("========================");
		
		c2.getInfo("슈퍼카아~!~~");
		
		System.out.println("========================");
		
		BlackS c3=new BlackS("블랙샤크",210,"물폭탄피하기");
		c3.getInfo();
		
		System.out.println("========================");
		
		c3.getInfo("블랙샤크!!");
	}
}

상속예제-3
(KakaTest.java)

class Kaka{
	public void kakaOpen(){
		System.out.println("과자를 뜯어 먹습니다.");
	}
}

class Prin extends Kaka{
	public void kakaOpen(){
		System.out.println("프링글스의 뚜껑을 열어먹습니다.");
	}
}

class Banana extends Kaka{
	public void kakaOpen(){
		System.out.println("바나나킥의 봉지를 뜯어먹습니다.");
	}
}

class Sea extends Kaka{
	public void kakaOpen(){
		System.out.println("고래밥의 상자를 뜯어 먹습니다.");
	}
}

public class KakaTest {
	public static void main(String[] args) {
		
		//일일이 접근해서 사용해서 출력하는 방법
		Banana ba=new Banana();
		ba.kakaOpen();
		Prin pr=new Prin();
		pr.kakaOpen();
		Sea s=new Sea();
		s.kakaOpen();
		
		System.out.println("=========================");
		
		//부모의 이름으로 가져와서 출력하는 방법
		Kaka ka[]=new Kaka[3];  //까까 클래스를 상속받은 자녀클래스를 담을 수 있는 공간 3개를 만든다
		ka[0]=ba;
		ka[1]=pr;
		ka[2]=s;
		
		for(int i=0;i<ka.length;i++){
			ka[i].kakaOpen();
		}
	}
}

다형성(OverRiding part)
OverRiding 이란?
부모클래스로부터 사용해 온 메소드를 더 이상 상속 받지 않고 자식클래스에서 새롭게 정의해서 메소드를 사용하도록 하는 것.