JAVA 08 객체지향 프로그래밍(2)

상속

• 변수와 메소드를 다른 클래스가 물려 받는다

• 기존의 클래스를 재활용 → 새로운 클래스 작성하는 기능

• 기존 클래스에 변형을 가하지 않고 상속을 받은 후 변형

• 두 클래스를 조상과 자손으로 관계

• 코드의 추가 및 변경이 매우 용이

• 유지보수 용이

• 조상클래스 수정 시 적용 X, 대신 추가 시 적용 O

• 다른 패키지에서도 상속이 가능

• final 붙은 클래스는 상속이 불가능

• 다중상속 허용하지 않음 - 인터페이스 사용

• 자식클래스끼리는 new를 쓸 것

• 생성자를 주지는 않는다

Class 자손 extends 조상 {
 
}

포함 관계

• 클래스의 멤버 변수로 다른 클래스를 선언

• 선언된 클래스의 구성요소 사용 가능

• 관계결정

• 상속 (is-a)

• ex) 버스는 자동차이다.

• 
  

• 포함 (has-a)

• ex) 버스는 엔진을 가지고 있다.

단일상속

• 인스턴스메서드의 경우 같은 두 메서드를 구별할 수 없음

• 클래스간의 관계가 보다 명확함을 위해

• 코드를 더욱 신뢰성 있게

Object 클래스 - 모든 클래스의 조상

• 모든 클래스들은 Object클래스로부터 상속받는다

---

오버로딩 & 오버라이딩

오버로딩

• 기존에 없는 새로운 메서드를 정의

• 같은 메서드를 파라미터의 유형과 갯수가 다르도록 정의.

오버라이딩

• 상속받은 메서드의 내용을 변경하는 것

• 조상 클래스가 가지고 있는 메서드를 자손 클래스가 재정의.

• 상속 관계 필요.

• 메서드의 선언부가 같다.

• 메서드의 바디부(내용)가 같거나 변경이 가해진다.

• 접근제어자 : 같거나 넓어진다.

• super: 조상 클래스와 내 클래스의 멤버를 구별.

구분	오버로딩	오버라이딩
메서드 이름	동일	동일
매개변수, 타입	다름	동일
리턴 타입	상관없음	동일

super

• 상속하면서 조상/자손클래스의 멤버가 중복 정의되어 서로 구별해야 되는 경우에 사용

• super를 쓰면 조상클래스(Super Class)의 값을 참조

• 메서드도 super를 써서 호출 가능 (자손클래스가 조상클래스의 메서드를 오버라이딩한 경우)

• 생성자 메서드 내 첫 줄에 놓임 (this()와 겹치면 new를 사용해보자)

super() - 조상 클래스의 생성자 호출 메서드

• 기본 생성자에 항상 super();가 은닉되어 있음.

• 따로 매개(파라미터) 변수로 쓰는 게 아니면 유의할 것.

부모 클래스

package com.test.hi;
 
public class Ch07Parent {
    public static int x;
    public static int y = 99;
    public static int y22 = 99;
    public Ch07Parent() {
        System.out.println("Parent 기본생성자");
    }
    
    public Ch07Parent(int initPort) {
        this(); //new Ch07Parent(); <- 자기 자신 호출, 문장 첫 행에 위치
        x = initPort;
        System.out.println(x + " + Parent 매개변수생성자");
    }
    
    
    public static void myPrint() {
        System.out.println("부모");
    }
}

자식 클래스

package com.test.hello;
 
import com.test.hi.Ch07Parent;
 
public class Ch07Child extends Ch07Parent {
    //static int x = 19;
    //부모 클래스이 은닉되어 있음.
    public Ch07Child() {
        //super(); <- 항상 숨어있음 //대체 소스 : new Ch07Parent();
        System.out.println("Child 기본생성자");
    }
    
    public Ch07Child(String a) {
        super(5000); // <- 매개변수 super시 super 등장
        new Ch07Child();
        System.out.println("Child 매개변수생성자");
    }
    // static int x = 19;
    public static int zz = 999;
    public static final double PI = 3.14;
    //overriding (오버라이딩) : 메서드의 선언부가 같다
    //메서드의 바디부(내용)가 같거나 변경이 가해진다
    //접근제어자 : 같거나 커진다.
    public static void myPrint() {
        System.out.println("자식");
    }
    
    public static void main(String[] args) {
        Ch07Child c = new Ch07Child(" ");
    // Integer num = 100;
    // String res = num.toString();
    // System.out.println(x); //19, 자신에게 없으면 부모꺼 가져옴
    // Ch07Child.myPrint(); //자식
    // Ch07Parent.myPrint(); //부모
    }
    // NoPackageClass np = new NoPackageClass();
}

---

Package & Import

Package

• 서로 관련된 클래스를 묶어 놓은것

• 클래스를 효율적으로 관리 가능

• 
  

• 자바 소스파일에서 첫 번째 문장으로 선언

• 단 한 번만 선언

• 패키지 이름은 소문자

Import

• Package를 가져다 쓸 때 사용

• import 사용 시, Package 이름 생략 가능

• 
  

• Package문과 Class 선언문 사이에 위치

• 다른 종류로 여러 번 선언 가능

• 
  

• import java.util.Scanner;

• import java.util.*

• 위의 둘은 성능 상의 차이는 없음

---

제어자

캡슐화를 이용한 데이터 은닉

PPDP

Public - 그냥 어디든 다 씀

Protected - 같은 패키지 내에서 사용, 해당 클래스를 상속받은 외부 패키지의 클래스에서 사용

Default - 같은 패키지 내에서만 씀

Private - 같은 클래스에서만

제어자	같은 클래스	같은 패키지	자손 클래스	전체
public	○	○	○	○
protected	○	○	○ (api 따라 다름)
default	○	○
private	○

public class Ch06AccessModifier {
 
    private String ssn = "920707";
    
    protected boolean ssnCheck(String ssn) {
        // public int aa = 0; // 오류! - 지역변수는 접근제어자 못 씀
    return true;
    }
    public static void main(String[] args) {
        Ch06AccessModifier m = new Ch06AccessModifier();
    }
}

final - 변경 불가한 클래스

• 다른 클래스의 조상이 될 수 없다.

• 오버라이딩 불가

• 처음 선언만 하고, 나중에 생성자에서 단 한번만 초기화할 수 있다.

abstract - 미완성

• 선언부만 작성, 실제 수행내용은 구현하지 않음

• 클래스: 추상 메서드가 선언되어 있음을 의미

• 메서드: 구현부가 없는 메서드

static은 static 끼리 호출

static 안 붙으면 다 참조 가능

---

다형성_polymorphism

여러가지 형태를 가질 수 있는 능력을 의미

하나의 참조 변수로 여러가지 객체를 참조하는 것

Parent p = new Child();

• p는 부모꺼 & 자식꺼

• 부모 타입으로 자식을 인스턴스화 시키는 것

Shape s = new Triangle();

• 부모 클래스인 Shape의 참조변수 s에 자식 클래스인 Triangle 인스턴스를 할당

부모가 자식에게 집과 집기를 물려줬더라도, 나중에 부모가 집으로 놀러와도 집기를 사용할 수 있다.

하지만, 자식이 부모가 모르는 새로운 집기를 사면, 부모는 띠요오오옹!!

메서드의 관련된 특징 중 오버로딩이 있는데,

이걸 클래스에서도 비슷하게 사용하도록 나온게 다형성

형변환

• 조상타입의 인스턴스를 자손타입의 참조변수로 참조하는 것은 허용되지 않는다

Child c = new Child();
Parent p = new Child();
c = (Child)p;

[참조변수] instanceof [클래스이름]

• 참조하고 있는 인스턴스의 실제 타입을 알아보기 위해

• if문에서 형변환 확인용

Ch07PolyParent.java

public class Ch07PolyParent {
    int pnum = 100;
    
    public void pMethod() {
        System.out.println("부모 출력");
    }
    
    public void pAdd() {
        System.out.println("부모 add");
    }
}

Ch07PolyChild.java

public class Ch07PolyChild extends Ch07PolyParent {
    int pnum = 200;
    int cnum = 1; //신규
    
    @Override
    public void pMethod() {
        System.out.println("부모 -> 자식 출력");
    }
    // @Override
    // public void pAdd() {
    // super.pAdd();
    // }
    public void cMethod() { //신규
        System.out.println("자식 신규");
    }
    
    public static void main(String[] args) {
    
        Ch07PolyParent p = new Ch07PolyParent();
        System.out.println(p.pnum);
        p.pAdd();
        p.pMethod();
    
        /*============*/System.out.println();/*============*/
    
        Ch07PolyChild c = new Ch07PolyChild();
        System.out.println(c.pnum);
        System.out.println(c.cnum);
        c.pAdd();
        c.pMethod();
        c.cMethod();
    
        /*============*/System.out.println();/*============*/
    
        Ch07PolyParent pc = new Ch07PolyChild();
        System.out.println(pc.pnum);
        // System.out.println(pc.cnum); //error -> 자식의 신규를 못씀
        pc.pAdd();
        pc.pMethod();
        // pc.cMethod(); //error -> 자식의 신규를 못씀
        
        /*============*/System.out.println();/*============*/
        
        /*<!-- 다형성 찬양 예제 --!>*/
        Child1 c1 = new Child1();
        c1.myPrint("aa");
        c1.myPrint(45.2);
        c1.myPrint(true);
    
        /*============*/System.out.println();/*============*/
    
        Child1 c2 = new Child1(new Good());
        c2.myPrint("bb");
    }
}
class Child1 {
    public Child1() {
        super();
    }
    
    public Child1(GCInter i) {
        i.method();
    }
    
    public void myPrint(Object a) {
        System.out.println(a);
    }
}
 
interface GCInter { 
    public abstract void method();
}
 
class Pay implements GCInter {
    public void method() {}
}
 
class Good implements GCInter {
    public void method() {}
}
 
class Cart implements GCInter {
    public void method() {}
}