7/19 복습(overriding, 다형성,상)

오버로딩 : 한 클래스 내에서 같은 이름의 메서드를 정의 ( 받는 매개변수가 다르다)

이해가 안될때 가장 쉬운방법은 예제를 보는것이다.

      ex )

void calc( int a ){

system.out.println(a);

}

void calc( int a , int b){

system.out.println(a+b);

}

void calc( int a , string b){

system.out.println(a,b);

}

 

위와같이 메서드의 이름은 같으니 받는 매개변수의 개수나 타입이 다르면 오버로딩이다.

오버라이딩 : 상속받은 메서드의 내용을 변경  ( 메서드 이름과 매개변수는 같다)

 

class mainC{

void riding(int a){

system.out.println(a);

}

}

class subC extends mainC{

void rinding(int a){

a = a + a;

System.out.println(a);

 }

}

출처: http://kmj1107.tistory.com/entry/Java-오버라이딩-오버로딩-예제로-설명 [토순이네집]

package practice1;
class Tiger{
    int a, b, c;
// 생성자 삭제
    void func01() {
        System.out.println("함수 1번 콜");
    }    
}
 
public class practice1{
 
    public static void main(String[] args) {
 
        Tiger a = new Tiger();
        a.func01();
    }
}
 

Tiger 타입 a 객체 생성 ]

a.func01();로 함수 콜

package practice1;
class Tiger{
    int a, b, c;
    Tiger(){
        System.out.println("호랑이");
    } // 인수 없음
    Tiger(int num){
        System.out.println("코끼리");
    } // 인수 전달
    void func01() {
        System.out.println("함수 1번 콜");
    }
}
public class practice1 {
    public static void main(String[] args) {
        Tiger t1 = new Tiger(); // 인수 없음
        t1.func01();
        Tiger t2 = new Tiger(50); // 인수 필요
        t1.func01();
    }
 
}

생성자에서 인수 전달 받기 객체생성때 인수가 필요하다.

package practice1;
class Tiger{
    int a, b, c;
    Tiger(){
        //System.out.println("호랑이 콜");
    }
    void func01() {
        System.out.println("함수 1번 콜");
    }
    void func03() {
        System.out.println("부모의 함수 3번 콜");
    }
}
class Lion extends Tiger{ // 상속하는 방법 extends 사용// 자 extends 부
    int a, b, c;
    Lion(){
    //System.out.println("사자 콜");
    }
    void func02() {
        System.out.println("자식의 함수 2번 콜");
    }
    void func03() {
        System.out.println("자식의 함수 3번 콜");
    }
    void func04() {
        super.func03(); // 부모 클래스의 함수 3번 호출
    }
}
public class practice1 {
    public static void main(String[] args) {
//        Tiger t1 = new Tiger(); 
//        t1.func01();
        Lion l1 = new Lion();
        l1.func01();
        l1.func02();
        l1.func03(); // 직접적으로 부모의 함수 3변을 사용할 수 없다.
        l1.func04(); // 간접적으로 거쳐서 사용
    }
}

class 형식 자 extends 부 형식 

상속하고나면 부모의 함수이름 중복시 부모의 함수 사용x

but super.func03();처럼 간접적으로 super를 사용해 부모함수를 사용할수있다.

package practice1;
//super();가 생략 되어있다.
//부모 클래스
class Animal{
    int a, b, c;
    Animal(){
        //super();
        System.out.println("부모 생성자 콜");
    }    
    Animal(int a){
        System.out.println("부모 생성자 콜"+a);
    }
    Animal(int a, int b){
        System.out.println("부모 생성자 콜"+a+" "+b);
    }
}
class Tiger extends Animal { //extends 뒤에 부모 클래스
    int a, b, c;
    Tiger(){
//부모 생성자를 콜
//생성자를 골라서 쓰기 위해서        
//인수를 받으면 인수를 받는 생성자를 사용한다.        
        super(); // 이것은 적으나 안적으나 디폴트 되어있다.
        System.out.println("자식 생성자 콜");
    }
//super(); 가 생략 되면 기본 생성자만 출력
    Tiger(int a){
//super를 사용하여 인수를 두개 받는 부모 생성자를 받아온다.        
        super(300,400);
        System.out.println("자식 생성자 콜"+a);
    }
}
public class practice1{
    public static void main(String[] args) {
//자식 클래스부터 갔다가 부모 클래스를 본다.
//자식 클래스부터 가지만 super가 생략되어 있어서 부모 생성자가 먼저 나온다.
//객체 생성을 통해 원하는 자식 생성자를 만들 수 있다.        
        Tiger t1 = new Tiger(200); // 부모 생성자까지 출력
        System.out.println("------------------");
        Tiger t2 = new Tiger();
    }
}

자식클래스부터 보고 부모클래스를 본다 but super가 default생략되어있어서 부모 생성자가 먼저 나온다.

밑에는 생성자에 인수를 넣은 순서대로 나옴.

package practice1;
             //final 
class Animal{//final class는 상속불가
    int a,b,c;
    Animal(){
        System.out.println("Animal call");
    }
    void func01() {
        System.out.println("부모함수 1번콜");
        func02();
        func03();
    }
    void func02() {
        System.out.println("부모함수 2번콜");
    }
    void func03() {
        System.out.println("부모함수 3번콜");
    }
}
class Tiger extends Animal{
    int a,b,c;
    Tiger(){
        System.out.println("Tiger call");
    }
    void func02() {//같은 모양의 함수를 넣으면 부모의 코드가 희미해져 사용x
                   //자식 때문에 부모 함수가 가려졌다.overriding = 상속이 나와야됨
        System.out.println("자식함수 2번콜");
    }
    void func03() {
        super.func03();
        //System.out.println("자식함수 3번콜");
    }
}
public class practice1 {
    public static void main(String[] args) {
        Tiger t1 = new Tiger();
        t1.func01();
    }
}
 

같은 모양의 함수, 함수 이름이 같을때 부모의 코드가 희미해져 사용할수없다. 이때를 자식때문에 부모가 가려졌다고 한다.

overriding 상속이 나와야된다. 앞서말했듯이 이경우 super.func03();이런식으로 간접적으로 사용가능하다. 

package practice1;
class Fruit{//다형성
    void eat() {
        System.out.println("먹습니다");
    }
    void make() {
        System.out.println("과일을 만듭니다.");
    }
    void show() {
        System.out.println("사과를 보여줍니다.");
    }
    void sell() {
        System.out.println("사과를 팝니다.");
    }
}
class Apple extends Fruit{
    void eat() {
        System.out.println("사과를 먹습니다.");
    }
    void sell() {
        System.out.println("사과를 팝니다.");
    }
}
class Banana extends Fruit{
    void eat() {
        System.out.println("바나나를 먹습니다.");
    }
    void sell() {
        System.out.println("바나나를 팝니다.");
    }
}
class Orange extends Fruit{
    void eat() {
        System.out.println("오렌지를 먹습니다.");
    }
    void sell() {
        System.out.println("오렌지를 팝니다.");
    }
}
class Kiwi extends Fruit{
    void eat() {
        System.out.println("키위를 먹습니다.");
    }
    void sell() {
        System.out.println("키위를 팝니다.");
    }
}
class Store{//이 부분이 다형성을 쓰는 이유 여러번 안써도 하나로 다 받아먹을수있다.
    /*void sell(Apple a) {
        a.eat();
    }
    void sell(Banana a) {
        a.eat();
    }
    void sell(Orange a) {
        a.eat();
    }*/
    void sell(Fruit a) {
        a.sell();
    }
}
public class practice1 {
    public static void main(String[] args) {
        Apple a1 = new Apple();
        Banana b1 = new Banana();
        Orange o1 = new Orange();
        Fruit f1 = new Apple();//왼쪽 부모 오른쪽 자식
        Fruit f2 = new Banana();        
        Store s1 = new Store();
        
        /*a1.eat();
        b1.eat();
        o1.eat();
        f1.eat();//a1.eat()와 결과가 같다.
        a1.make();*/
        //f1.show();//overriding 된것만 쓸수있다. or자식꺼
        
        s1.sell(a1);
        s1.sell(b1);
        s1.sell(o1);//함수를 추가할 필요가없다.
        s1.sell(new Apple());
        s1.sell(new Banana());
        s1.sell(new Orange());
        s1.sell(new Kiwi());
        
    }
}
 

한번더보기 객체받아주고 그것을 다시 넣어준다.

Store s1 = new Store(); -> s1.sell(new Apple());

Apple a1 = new Apple();s1.sell(a1);

개념만 보여주고 사용법은 다음부터