상속 Inheritance

• 클래스의 수직 구조 설계
• extends 예약어 사용
• 부모 클래스를 자식 클래스가 상속받으면 부모 클래스의 변수와 메서드가 상속됨
• 부모 클래스의 변수와 메서드를 자신의 것처럼 사용 가능
• 부모클래스는 슈퍼(super), 상위, 베이스 클래스 라고도 부름
• 자식클래스는 서브, 하위, 파생 클래스 라고도 부름

부모클래스

package chapter08;

public class Phone {

    String name;
    String color;
    String company;

    void call() {
        System.out.println("전화를 건다");
    }

    void receive() {
        System.out.println("전화를 받다");
    }

}

자식클래스

package chapter08;

public class SmartPhone extends Phone {

    public void installApp() {
        System.out.println("앱 설치");
    }

}

클래스 사용

package chapter08;

public class SmartPhoneMain {

    public static void main(String[] args) {

        Phone p = new Phone();
        p.name = "전화기";
        p.company = "현대";
        p.color = "화이트";

        System.out.println("Phone 출력");
        System.out.println(p.name);
        System.out.println(p.company);
        System.out.println(p.color);
        p.call();
        p.receive();

        SmartPhone sp = new SmartPhone();
        sp.name = "갤럭시";
        sp.company = "삼성";
        sp.color = "블랙";

        System.out.println("SmartPhone 출력");
        System.out.println(sp.name);
        System.out.println(sp.company);
        System.out.println(sp.color);
        sp.call();
        sp.receive();
        sp.installApp();

    }
}

super

• 부모 인스턴스 : 자식 클래스에서 super.변수 접근 가능
• super() : 상속 받은 부모의 인스턴스 생성자
• 상속 받은 자식클래스 인스턴스 생성시 부모 클래스가 먼저 만들어 저야 함
• 부모와 자식 클래스 모두 기본생성자 만 있으면 모두 생락 가능
• 부모의 클래스에 오버로딩된 생성자가 있다면 자식 클래스에서 super()로 먼저 호출 해 주어야 함

부모 클래스 기본 생성자

부모클래스

package chapter08;

public class Phone {

    // 기본 생성자 생략    
    public Phone() {
    }

}

자식클래스

package chapter08;

public class SmartPhone extends Phone {

    // 기본생성자 생략가능
    public SmartPhone () {
        // super() -> 부모기본생성자 생략가능
        super() {
        }
    }
}

클래스 사용

package chapter08;

public class SmartPhoneMain {

    public static void main(String[] args) {

                // SmartPhone() -> super() --> 부모인스턴스 생성 --> 자식인스턴스 생성
        SmartPhone sp = new SmartPhone();        
    }
}

부모 클래스 오버로딩 생성자만 있을 때

부모클래스

package chapter08;

public class Phone {

    String name;
    String color;
    String company;

       //  오버로딩 생성자
    public Phone(String name, String color, String company) {
        this.name = name;
        this.color = color;
        this.company = company;
    }
}

자식클래스

• 부모클래스 생성자 super() 생략 불가

package chapter08;

public class SmartPhone extends Phone {


    public SmartPhone() {
               // 부모 클래스 생성자 호출 
        super("갤럭시", "블랙", "삼성");
    }
}

클래스 사용

package chapter08;

public class SmartPhoneMain {

    public static void main(String[] args) {

        // SmartPhone() -> super() --> 부모인스턴스 생성 --> 자식인스턴스 생성
        SmartPhone p = new SmartPhone();        
    }
}

메서드 재정의 overriding

• 상속관계에서 부모 클래스의 메서드를 자식 클래스에서 다시 정의 하는 것
• 자식클래스 인스턴스에서는 재정의된 메서드 호출됨
• 다형성에서도 참조된 참조변수에서도 재정의된 자식 메서드 호출됨

부모클래스

package chapter08;

public class Car {

    String color;
    String name;

    public void go() {
        System.out.println("전진");
    }

    void back() {
        System.out.println("후진");
    }
}

자식클래스

package chapter08;

public class Taxi extends Car {

    public void go() {
        System.out.println("미터기를 켜고 전진");
    }
}

클래스 실행

package chapter08;

public class TaxiMain {

    public static void main(String[] args) {

        Taxi t = new Taxi();
        t.go();    

    }
}

final

• final 변수 : 변수값 변경불가 - 상수
• final 메서드 : 오버라이딩 불가
• final 클래스 : 상속 불가

final 메서드 : 오버라이딩 불가

class MethodSuper{
    final void superMethod(){
        System.out.println("super method");
    }
}
class MethodChild extends MethodSuper{
    void superMethod(){
        System.out.println("child method");
    }
}
public class FinalMethod{
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}

final 클래스 : 상속 불가

public final class FinalClass {
    int x;
}
class ChildClass extends FinalClass{
}

다형성 polymorphism

• 하나의 참조(레퍼런스) 변수가 여러 타입의 객체 참조
• 부모 클래스 타입의 참조 변수로 자식 클래스 참조
• 참조된 자식 클래스는 자동으로 부모 클래스 타입으로 변환(UpCasting)
• 다시 자식 클래스가 부모 클래스 참조 시는 명시적으로 캐스팅 해야함(DownCasting)
• 다형성에서도 참조된 참조변수에서도 재정의된 자식 메서드 호출됨
• 부모의 참조변수는 메서드의 인자로 전송등에 활용 됨(매개변수의 다형성)
• 향후 인터페이스에서도 다형성 가능

부모 클래스

package chapter08.poly;

public class Parent {

    String name;

    void walk() {
        System.out.println("부모가 걷는다.");
    }

    void run() {
        System.out.println("부모가 달린다.");
    }

}

자식 클래스

package chapter08.poly;

public class Child extends Parent {

    String name;

    // override
    void run() {
        System.out.println("자식 달리기");
    }

    // new
    void game() {
        System.out.println("자식 게임");
    }
}

다형성 확인 - 자동형변환

package chapter08.poly;

public class PolyEx {

    public static void main(String[] args) {

        Child c = new Child();

        c.run();

        // 부모클래스의 자료형으로 선언 (자동형변환)
        Parent p = new Child();
        p.run(); // 재정이된 메서드가 실행
        // p.game(); // 에러


    }

}

다형성 - 강제형변환

package chapter08.poly;

public class PolyEx2 {

    public static void main(String[] args) {

        Parent p = new Child();

        p.run();

        // 자식클래스의 자료형으로 변환 (강제형변환)
        Child c = (Child)p;
        c.game();

    }

}

다형성 활용

부모 클래스

package chapter08;

public class GraphicCard {
    public void process() {
        System.out.println("그래픽 처리");
    }
}

자식 클래스

package chapter08.poly;

public class Amd extends GraphicCard {

    public void process() {
        System.out.println("AMD 그래픽 처리");
    }

}

자식 클래스

package chapter08.poly;

public class Nvidia extends GraphicCard {

    public void process() {
        System.out.println("Nvidia 그래픽 처리");
    }

}

다형성 - 부품 교체 하듯 사용

package chapter08.poly;

public class Computer {

    public static void main(String[] args) {

        GraphicCard gc = new GraphicCard();
        gc.process(); // 원래 그래픽카드 process

        gc = new Amd();
        gc.process();

        gc = new Nvidia();
        gc.process();

    }

}

다형성 - 매개변수에서 사용

• 부모의 참조 변수로 모든 자식 클래스 처리

package chapter08.poly;

public class Game {

    void display(GraphicCard gc) {
        gc.process();
    }
}

package chapter08.poly;

public class Computer2 {

    public static void main(String[] args) {

        Game g = new Game();

        Amd gc2 = new Amd();
        g.display(gc2);

        Nvidia gc3 = new Nvidia();
        g.display(gc3);


        // 다형성으로 처리
        GraphicCard gc = new GraphicCard();
        g.display(gc);

        gc = new Amd();
        g.display(gc);

        gc = new Nvidia();
        g.display(gc);

    }

}

클래스간의 관계 - 포함관계(Composite)

• 포함관계 방법으로 클래스 재 사용 가능
• 한 클래스의 멤버변수로 다른 클래스 타입의 참조변수를 선언하는 것을 뜻 한다

원(Circle)을 나타내는 클래스

class Circle{
    int x; // 원점 x 좌표
    int y; // 원점 y 좌표
    int r; // 반지름
}

포인트(Point) 좌표상의 한점을 나타내는 클래스

class Point{
    int x; // x 좌표
    int y; // y 좌표
}

포함관계로 Circle 클래스 재작성

class Circle{
    Point p = new Point();
    int r; // 반지름
}

클래스간의 관계 결정하기

• 상속 관계: is-a 관계 (~은 ~이다)
• 포함 관계: has-a 관계 (~은 ~을 ~가지고 있다)
• 원(Circle)은 점(Point) 이다 : 상속(x)
• 원(Circle)은 점(Point)을 가지고 있다 : 포함(o)
• 스포츠카(SprotsCar)는 차(Car)다 : 상속

포인트 클래스

class Point {
    int x;
    int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    Point() {
        this(0,0);
    }

    String getXY() {  
        return "("+x+","+y+")"; // x와 y의 값을 문자열로 반환
    }
}

도형 클래스

class Shape {
    String color = "black";
    void draw() {
        System.out.printf("[color=%s]%n", color);
    }
}

원 클래스

class Circle extends Shape {
    Point center;    // 원의 원점좌표
    int r;            // 반지름

    Circle() {        
        this(new Point(0, 0), 100); // Circle(Point center, int r)를 호출
    }

    Circle(Point center, int r) {
        this.center = center;
        this.r = r;
    }

    void draw() { // 원을 그리는 대신에 원의 정보를 출력하도록 했다.
        System.out.printf("[center=(%d, %d), r=%d, color=%s]%n", center.x, center.y, r, color);
    }
}

삼각형 클래스

class Triangle extends Shape {
    Point[] p = new Point[3];

    Triangle(Point[] p) {
        this.p = p;
    }

    void draw() { 
        System.out.printf("[p1=%s, p2=%s, p3=%s, color=%s]%n", p[0].getXY(), p[1].getXY(), p[2].getXY(), color);
    }
}

도형 그리기 테스트

class DrawShape {
    public static void main(String[] args) {
        Point[] p = {   new Point(100, 100),
                        new Point(140,  50),
                        new Point(200, 100)
                    };

        Triangle t = new Triangle(p);
        Circle   c = new Circle(new Point(150, 150), 50);

        t.draw(); // 삼각형을 그린다.
        c.draw(); // 원을 그린다.
    }
}

Object 객체

• 모든 클래스의 부모 클래스
• 모든 클래스 참조 가능

instanceof

• 참조변수가 참조하는 인스턴스 실체 타입 확인
• true 라는 것은 형변환이 가능

package chapter08.poly;

public class ObjectEx {

    public static void main(String[] args) {

        allObject(new GraphicCard());
        allObject(new Amd());
        allObject(new Nvidia());
        allObject("안녕");

    }

    public static void allObject(Object obj) {

        System.out.println(obj.toString());
        if(obj instanceof GraphicCard) {

            GraphicCard gc = (GraphicCard)obj;
            gc.process();
        }
    }

}

추상클래스

• 추상화: 클래스간의 공통부분을 뽑아내서 공통의 조상을 만드는 작업
• 추상메서드를 하나 이상 가지고 있는 클래스
• 미완성 메서드를 포함하고 있다는 의미
• 추상클래스의 인스턴스는 생성할 수 없으며 상속을 통해서 자손클래스에 의해서 완성됨
• 추상클래스 자체로는 클래스 역할을 못하지만 새로운 클래스를 작성하는데 있어 바탕이 되는 조상클래스로서의 중요한 의미를 갖음
• 추상클래스도 생성자가 있으며, 멤버변수와 메서드도 가질 수 있음
• 추상메서드를 가지고 있지 않아도 추상클래스로 만들 수 있으며 인스턴스 생성 불가 함
• 추상메서드로 선언하면 자손클래스에서는 반드시 구현해야 한다(구현을 강제 할 수 있다)

추상메서드

• 메서드는 선언부 + 구현부로 구성
• 추상메서드는 선언부만 작성
• abstract return_type method_name(); // {} 넣지 않음

도형클래스 설계

추상클래스

abstract class Shape {
    String type;
    Shape(String type) {
        this.type = type;
    }
    abstract double area();
    abstract double length();
}

추상클래스 상속 받아 구현 1

class Circle extends Shape{
    int r;
    Circle(int r) {
        super("원");
        this.r = r;
    }
    @Override
    double area() {
        return r * r * Math.PI;
    }
    @Override
    double length() {
        return 2 * r * Math.PI;
    }
    @Override
    public String toString() {
        return "Shape [type=" + type + ", r=" + r + "]";
    }
}

추상클래스 상속 받아 구현 2

class Rectangle extends Shape {
    int width, height;
    Rectangle(int width, int height) {
        super("사각형");
        this.width = width;
        this.height = height;
    }

    @Override
    double area() {
        return width * height;
    }
    @Override
    double length() {
        return 2 * (width + height);
    }
    @Override
    public String toString() {
        return "Shape [type=" + type + ", width=" + width + ", height=" + height+"]";
    }

}

테스트

public class ShapeEx {
    public static void main(String[] args) {
        Shape[] shapes = new Shape[2];
        shapes[0] = new Circle(10);
        shapes[1] = new Rectangle(5,5);
        for(Shape s : shapes) {
            System.out.println(s);
            System.out.println("넓이:"+s.area()+" 둘레:"+s.length());
        }
    }
}

클래스 - 배열 Array 사용

부모 클래스 Animal

package chapter08;

public class Animal {

    String type;
    String name;

    Animal(String type, String name) {
        this.type = type;
        this.name = name;
    }

    void sleep() {
        System.out.println(this.name +"은(는) 잠을 잔다.");
    }
}

자식클래스 Eagle

package chapter08;

public class Eagle extends Animal {

    Eagle(String type, String name) {
        super(type, name);
    }

    void sleep() {
        System.out.println(this.name +"은(는) 하늘에서 잠을 잔다.");
    }


}

자식클래스 Tiger

package chapter08;

public class Tiger extends Animal {

    Tiger(String type, String name) {
        super(type, name);
    }

    void sleep() {
        System.out.println(this.name +"은(는) 산속에서 잠을 잔다.");
    }


}

자식클래스 Lion

package chapter08;

public class Lion extends Animal {

    Lion(String type, String name) {
        super(type, name);
    }

    void sleep() {
        System.out.println(this.name +"은(는) 숲속에서 잠을 잔다.");
    }


}

자식클래스 Shark

package chapter08;

public class Shark extends Animal {

    Shark(String type, String name) {
        super(type, name);
    }

    void sleep() {
        System.out.println(this.name +"은(는) 물속에서 잠을 잔다.");
    }


}

테스트

package chapter08;

public class AnimalMain {

    public static void main(String[] args) {

        Animal[] ani = new Animal[4];

        Animal eagle = new Eagle("조류", "독수리");
        Animal tiger = new Tiger("포유류", "호랑이");
        Animal lion = new Lion("포유류", "사자");
        Animal shark = new Shark("어류", "상어");

        ani[0] = eagle;
        ani[1] = tiger;
        ani[2] = lion;
        ani[3] = shark;

        for (int i=0; i<ani.length; i++) {
            ani[i].sleep();
        }

        System.out.println("=========================");

        for(Animal a : ani) {
            a.sleep();
        }
    }
}

클래스 - ArrayList 사용 1

• ArrayList 만 사용시 형변화 필요
• 다양한 자료형의 데이터를 추가 삭제 가능 객체
• 다양한 자료형은 Object 로 입/출력 됨
• 메서드를 통해 입/출력 add(), get()

package chapter08;

import java.util.ArrayList;

public class AnimalMain2 {

    public static void main(String[] args) {

        ArrayList ani = new ArrayList();

        Animal eagle = new Eagle("조류", "독수리");
        Animal tiger = new Tiger("포유류", "호랑이");
        Animal lion = new Lion("포유류", "사자");
        Animal shark = new Shark("어류", "상어");

        ani.add(eagle);
        ani.add(tiger);
        ani.add(lion);
        ani.add(shark);

        for (int i=0; i<ani.size(); i++) {
            Animal a = (Animal)ani.get(i);
            a.sleep();
        }

        System.out.println("=========================");

        for(Object o : ani) {
            Animal a = (Animal)o;
            a.sleep();
        }
    }
}

클래스 - ArrayList 사용 2

• ArrayList 자료타입 지정 : 자동 형변환

package chapter08;

import java.util.ArrayList;

public class AnimalMain2 {

    public static void main(String[] args) {

                // <자료타입지정> : 형변화 불필요
        ArrayList<Animal> ani = new ArrayList<Animal>();

        Animal eagle = new Eagle("조류", "독수리");
        Animal tiger = new Tiger("포유류", "호랑이");
        Animal lion = new Lion("포유류", "사자");
        Animal shark = new Shark("어류", "상어");

        ani.add(eagle);
        ani.add(tiger);
        ani.add(lion);
        ani.add(shark);

        for (int i=0; i<ani.size(); i++) {
            ani.get(i).sleep();;
        }

        System.out.println("=========================");

        for(Animal a : ani) {
            a.sleep();
        }
    }
}