memory

//public class 

public static void exe(Calculator cal){

//static으로 class method 생성해 각각의 instance가 method를 공유한다

//부모타입으로 매개변수를생성해 data를 가져온다

cal.setNum(100,200); 
cal.calResult(); 
} 

//main
public static void main(String[] args) {
Calculator c1 = new Sum(); //부모type의 자식 instance를 생성
Calculator c2 = new Subtractor(); 

exe(c1); //sum 의 값을 출력한다
exe(c2); //subtractor의 값을 출력한다

//부모타입으로 매개변수를 받기때문에 각각의 인스턴스는 인자값을 받아온다

//이처럼 calculator 하나의 type 으로 기능이 다른동작을수행하는걸 다형성이라고한다 

Sum sum = new Sum();
sum.setNum(100,200);
sum.calResult();

Subtractor sub = new Subtractor();
sub.setNum(100,200);
sub.calResult();

//abstract class Calculator 

//abstract는 미완성클래스로 상속을 강요하는 class이다
int n1, n2;

public void setNum(int n1, int n2) {
this.n1 = n1;
this.n2 = n2;
}
public abstract void calResult(); 

//추상method는 overriding을 해줘야한다

//class Sum extends Calculator
public calResult(){ 
System.out.println(this.n1+this.n2);
} //추상method를 overriding해준다

//class Subtractor extends Calculator
public void calResult() {
System.out.println(this.n1-this.n2;)
} //추상method를 overriding해준다
----------

Calculator c1 = new Sum(); 
Calculator c2 = new Subtractor();

Calculator ca[] = new Calculator[2]; 
ca[0] = new Sum(); 
ca[1] = new Subtractor(); 
//서로 다른 객체를 이용해서 method를 호출할수있지만

//부모가 같을경우 배열을 이용하여 두객체를 하나의 객체로 선언할수있다

-----------

static int i = 0; //carArray가 static이기때문에 변수도 static으로 바꿔준다
static Calculator calArray[] = new Calculator[3];

//static으로 배열을 생성했기때문에 객체를생성할필요가없다

//public class

public static void exe(Calculator cal){

//static으로 class method 생성해 각각의 instance가 method를 공유한다

//부모타입으로 매개변수를생성해 data를 가져온다

calArray[i++] = cal;

//carArray배열에 car객체를 입력한다

cal.setNum(100,200); 
cal.calResult(); 

} //class method

//main
Sum sum = new Sum();  
Subtractor sub = new Subtractor(); 

exe(sum); 
exe(sub); 
exe(sum); 
exeSequence(); 

//같은 class이므로 바로불러올수있다

//exeSequence
public static void exeSequence() {
for(int i=0;i<calArray.length;i++) {
String str = calArray[i].operand();

//carArray[i]에 operand method를 호출
System.outprintln(str);
} //연산의 순서를 나타내기위한 class method

//abstract class Calculator 

//abstract는 미완성클래스로 상속을 강요하는 class이다
int n1, n2;

public void setNum(int n1, int n2) { 
this.n1 = n1; 
this.n2 = n2; 
} 
public abstract void calResult(); 

//추상method는 overriding을 해줘야한다 

public abstract String operand();

//연산의 순서를 나타내기위해 추상method를 만든다

//class Sum extends Calculator
public calResult(){ 
System.out.println(this.n1+this.n2); 
} //추상method를 overriding해준다

public String operand(){

return "plust";

} //추상method를 overriding해준다

//class Subtractor extends Calculator
public void calResult() { 
System.out.println(this.n1-this.n2;) 
} //추상method를 overriding해준다

public String operand(){

return "minus";

} //추상method를 overriding해준다

다형성이란 하나의 method나 class가 다양한 방법으로 동작하는것을말한다

하나의 참조변수로 여러타입의 객체를 참조할수있는것
즉 조상타입의 참조변수로 자손타입의 객체를 다룰수있는것이 다형성이다

조상타입의 참조변수로 자손타입의 인스턴스를 참조할수있지만
자손타입의 참조변수로 조상타입의 인스턴스를 참조할수없다.

//public class
//main
Super sp = new Super(); 
System.out.println(sp.x +sp.y);
sp.ss(); //일반적인 방법

Child ch = new Child();
System.out.println(ch.z+ch.j);
ch.getClass(); //일반적인 방법

//super type으로 참조변수로 child instance생성 
Super sp1 = new Child(); 
System.out.println(sp1.x+sp1.y); //super class내에 있어서 가능
System.out.println(sp1.z+sp1.j);  //참조할수 없다
//부모타입으로 자식인스턴스를 생성할경우 자식이가진 고유한 멤버는 접근할수없다
sp1.ss(); //super class에 method가 child class 에서 overriding된게 출력된다

//overriding이 됬을경우 overriding이 된 method를 우선순위로 출력한다
Child ch1 = new Super(); //자식타입의 참조변수는 부모인스턴스를 생성할수없다

//class Super
int x=200;
int y=200;
public void ss() {
System.out.println("parents class");
}

//class Child extends Super
int z = 1000;
int j = 2000;
public void ss() {
System.out.println("child class");
} //overriding해서 super class의 method를 재정의

참조변수의 형변환
서로 상속관계에 있는 타입간의 형변환만 가능하다
자손타입에서 부모타입으로 UpCasting 인경우 형변환생략 가능
부모타입에서 자손타입으로 DownCasting 인경우 형변환 생략 불가

참조변수의 형변환은 참조변수의 타입을 변환하는것으로 인스턴스에 영향을 주는것이 아니다.
참조변수의 형변환은 참조하고 있는 인스턴스에서 사용가능한 멤버의 개수를 조절하는 것이다.

//public class
//main
Car car = null;

FireEngine fe = new FireEngine(); //객체생성
fe.water(); //method 호출
Truck tr = new Truck();
tr.sand();

fe = (FireEngine)tr; 

//상속관계가 아니기때문에 tr을 FireEngine으로 형변환을할수없다

car = (Car)fe; //자식(fe)를 부모타입(Car)로 변환하는 upCasting으로 (Car) 생략가능 
car.water(); //자식 고유의 method로 사용할수없다

fe = (FireEngine)car; //부모타입(car)를 자식(FireEngine)으로 downCasting으로 (FireEngine) 생략불가 
fe.water(); //car의 null 값에 car=(Car)fe;를 했기때문에

//fe=(FireEngine)car은 결국 자기자신을 가리키게 되므로 실행이된다

//class Car
String color;
int door;

public void accel() {
System.out.println("dirve");
}
public void break() {
System.out.println("stop");
}

//class FireEngine extends Car
void water() {
System.out.println("water");
}

//class Truck extends Car
void sand() {
System.out.println("take sands");
}

----------

//class Car
String color;
int door;

public void accel() {
System.out.println("dirve");
}
public void break() {
System.out.println("stop");
}

//class FireEngine extends Car
void water() {
System.out.println("water");
}

//class Truck extends Car 
void sand() {
System.out.println("take sands");
}

//public class
//main 
Car car = new Car(); //car instance생성
Car car2 = null;
Truck tr = null; //tr이라는 참조변수는 null값을 가진다 

car.accel(); //drive 출력

//car 참조변수는 car instance를 가리키고있고 car instance내 method에 접근가능하다 

tr = (Truck)car; //자식 참조변수는 부모의 인스턴스를 참조할수없으므로 error가 난다
tr.accel(); //error가 난다

car2 = (Car)tr; //upCasting으로 (Car)생략가능
car2.accel(); //tr값이 null이기때문에 car2가 null값을 참조한것으로 error가 생긴다

instanceOf
참조변수가 참조하고있는 인스턴스의 실제타입을 알아보는 연산자로
연산결과로 boolean값 true, false를 리턴한다.
if(a instanceOf Car) 참조변수 a가 Car타입인지를 true, false값으로 return 

//public class

//main

Truck tr = new Truck();

if(tr instanceof Truck) {  
System.out.println("it is truck");
} //true값이 출력된다

if(tr instanceof Car) {  
System.out.println("it is car");
} //car는 truck의 부모로 true값 출력

if(tr instanceof Object) { 
System.out.println("it is Object");
} //object는 모든클래스의 부모로 true값 출력