210421_5~8(오버라이딩Overriding,객체형변환, Object클래스)

메서드 오버라이딩

 

오버라이딩

Overriding ===> 재정의 ==> 처리 하는 일을 바꿈

 

상위클래스에 정의된 메서드를 상속받아서 하위클래스에서 재정의 하여 사용하는것

상속관계에서만 성립된다.

접근자는 같거나 넓어져야한다

 

------------------------------------Super

public int a add(int a, int b){ 

          return a+ b

}

 

-------------------------------------Sub

public int a add(int a, int b){ 원형(protoType)은 바뀌지않는다.

          a++;

          b++;   //  내용만 바꾼다

   return a+ b

}

 원형 : 반환형+함수명+인자 를 비교

 

-------------------------------비교 오버로딩 Overloading

class A{

public int add(int a ){ }    동일클래스/이름만같고 / 인자형, 인자수는 다름

public int add(int a, int b) { }

public int add(byte a, float b) { }

}

 

상속에서 주의점

1. 상위 객체인지 하위 객체인지 구별해야한다.

   기본적으로 상위객체는 상위멤버를 호출하고, 하위객체는 하위멤버를 호출한다.

   그리고 하위 객체는 상속받은 상위 멤버를 호출 할 수 있다. 하지만 상위객체는 하위 멤버를 호출 할 수 없다.

package chapter12;
class OverA{
	void show(String str) {
		System.out.println("상위클래스의 메소드 show(show str)수행" + str);
	}
}
class SubOverA extends OverA{
	void show() {//오버라이딩이아니다.인자같아야한다
		//하위클래스입장에서보면 오버로딩으로보인다
		System.out.println("하위클래스의 메소드 show()수행");
	}
}

public class OverrideExam1 {

	public static void main(String[] args) {
		SubOverA over = new SubOverA();
		over.show("STUDY KOREA");
		over.show();  //오버로딩
		// TODO Auto-generated method stub

	}

}

package chapter12;
class OverB{
	void show() {
		System.out.println("부모클래스의 메소드 show() 수행");
	}
}
class SubOverB extends OverB{
	void show() { // 메서드오버라이딩 : 상위클래스의 메서드를 재정의 한다
		System.out.println("자식클래스의 메소드 show()수행");
	}
}

class OverrideExam2 {

	public static void main(String[] args) {
		OverB ob = new OverB();
		ob.show();
		
		SubOverB over = new SubOverB();
		over.show();

	}

}

package chapter12;

class OverC {
	int show(int k) {
		return k;
	}
}

class SubOverC extends OverC {
	int show(int i) {
		return i * 10; // 오버라이딩시 float show(int i) 반환형을 바꿀수 없다
	}
}

class OverrideExam3 {

	public static void main(String[] args) {
		OverC ob = new OverC(); //상위클래스 인스턴스화
		int i = ob.show(10);

		SubOverC over = new SubOverC(); // 상속받은 하위클래스 인스턴스화
		float j = over.show(20);

		System.out.println("i : " + i);
		System.out.println("j : " + j);

	}

}
//i : 10    상위클래스의 메소드값을 그대로 출력
//j : 200.0 하위클래스에서 오버라이딩되어 *10이 되었다.

---

 

2. 객체 형병환

OverD  --------------------------------- 

  (1) void show (i) ;

  (2)void prn(i);

 

SubOverD

  (3) void show(i);--------------- Override

  (4) void prn(s);  ---------------parameter가 다르기때문에  Override가아니다, 하위클래스 입장에서 보면 오버로딩이다

  (5) src( ); -------확장메서드

------------------------------------------

OverD od = new SubOverD() ; 상위클래스의 객체에 하위클래스의 생성자가 왔다.

                                         상위클래스 상객 = new 하위생성자();

         od.show(i) ------->(1)호출 ------>(3)응답 (override됐기때문에) <---다형성

         od.prn(i) ---------->(2)호출------>(2)응답

         od.prn(s) ---------->(4)호출------>응답X // 부모는 자식의 자원을 사용할 수없다.

         od.src(); ------------->(5)호출X

SubOveD sod = new SubOverD() ; // new를 사용하여 od와 sod가 다른 객체가 되었다

        sod.prn(s) ;

        sod.src();

SubOverD sod = (SubOverD) od; // (SubOverD)객체 형변환이라고한다

            sod.prn(s) ; // 사용 할수없는 자식의 멤버를 호출하기 위해 객체 형변환을했다.

            sod.src();

 

기본 형변환 : 크기가 큰값을 작게 바꾸는것

객체 형변환 : 상위객체(작은면적)를 하위객체(크게)로 바꾸는 것

-----------------------------

od는 new SuvOverD() ; 됐다가, new OverD(); 되기도한다. 이런현상을 다형성이라고 한다.

 

package chapter12;

class OverD {
	void show(int k) {
		System.out.println("OverD :" + (k * 10));
	}

	void prn(int i) {
		System.out.println("OverD : prn() :" + i);
	}
}

class SubOverD extends OverD {
	void show(int i) { //overriding O
		System.out.println("SubOverD :" + (i * 10000));
	}

	void prn(String s) { // 인자의 형이 다르기때문에 overridingX / Overloading
		System.out.println("SubOverD : prn(String s) : " + s);
	}

	void scr() { // overloading
		System.out.println("src() : ");
	}
}

class OverrideExam4 {

	public static void main(String[] args) {
		OverD od = new SubOverD(); // 상위클래스의 객체에 하위클래스의 생성자가 왔다.
        // Over의 멤버를 호출하지만, 오버라이딩이되어있다면 하위클래스의 멤버가 응답한다.


		od.show(2); // subOverD의 show가 와야한다. 4열호출->14열응답
		od.prn(3); // String 사용불가 //OverD의 prn이 온다. 8열호출->8열응답
		
        //하위클래스의 멤버를 직접호출하는 방법
		// subOverD sod = new SubOveD new를 사용하면 od와 sod가 다른 객체가 된다
		SubOverD sod = (SubOverD) od; // 객체형변환

		sod.show(1);
		sod.prn("AAA");
		sod.scr();

	}

}

---

클래스 객체 생성 방법

1.상위객체      = 상위생성자(); ------------가능 // 기본적인 객체 생성법

OverD od       = new OverD();

2.하위객체      = 하위생성자(); ------------가능 // 상속받은 자원을 사용할수있다.

SubOverD sod = new SubOverD ();

3.상위객체      = 하위생성자(); ------------가능 // 다형성으로활용하고자 할때/오버라이딩된 하위자원호출가능/

OverD od       = new SubOverD ();//override

4.하위객체      = 상위생성자(); ------------불가능// 무조건 오류발생,

SubOverD sod  = new OverD ();

5.-1하위객체       = 상위객체; ---------------- 상위객체가 1번출신이면 : 불가능

SubOverD sod  =OverD od //불가능 

 5.-2 하위객체  =  상위객체;->(형변환) 하위생성자();  -- 상위객체가 3번출신이면 : 가능 / 객체 형변환 /

SubOvderD sod = OverD(SubOverD) od;= new SubOverD ();//override

 

원인

 --------------------------

예시...이해하기힘든..

 

객체                생성자

가르키는영역    할당된영역

1. [ㅁ] = [ㅁ]

2. [ㅁ][ㅁ] = [ㅁ][ㅁ]

3. [ㅁ] = [ㅁ][ㅁ]

4. [ㅁ][ㅁ] = [ㅁ]

5. [ㅁ][ㅁ] = [ㅁ]->[ㅁ][ㅁ]

 

---

 

Object클래스

Object는 모든 클래스의 조상 클래스이다.

따라서 자동으로 상속이 된다. hashcode() , finalize(), toString() 등등의 

 멀티스레드 - wait(), notify() ...들어있다.

package chapter12;

//public class ObjecTest extends Object : 자동상속됨
public class ObjectTest {

	public static void main(String[] args) {
		ObjectTest ot = new ObjectTest();
		
		System.out.println(ot.hashCode()); // 상속받은 메서드를 이용함
		System.out.println(ot.toString());

	}

}