Puter의 잡동사니

상속


  • 변수와 메소드를 다른 클래스가 물려 받는다
  • 기존의 클래스를 재활용 → 새로운 클래스 작성하는 기능
  • 기존 클래스에 변형을 가하지 않고 상속을 받은 후 변형
  • 두 클래스를 조상과 자손으로 관계
  • 코드의 추가 및 변경이 매우 용이
  • 유지보수 용이
  • 조상클래스 수정 시 적용 X, 대신 추가 시 적용 O
  • 다른 패키지에서도 상속이 가능
  • final 붙은 클래스는 상속이 불가능
  • 다중상속 허용하지 않음 - 인터페이스 사용
  • 자식클래스끼리는 new를 쓸 것
  • 생성자를 주지는 않는다

1
2
3
Class 자손 extends 조상 {
 
}
cs

포함 관계
  • 클래스의 멤버 변수로 다른 클래스를 선언
  • 선언된 클래스의 구성요소 사용 가능

  • 관계결정
  • 상속 (is-a)
  • ex) 버스는 자동차이다.

  • 포함 (has-a)
  • ex) 버스는 엔진을 가지고 있다.

단일상속
  • 인스턴스메서드의 경우 같은 두 메서드를 구별할 수 없음
  • 클래스간의 관계가 보다 명확함을 위해
  • 코드를 더욱 신뢰성 있게

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


오버로딩 & 오버라이딩

오버로딩
  • 기존에 없는 새로운 메서드를 정의
  • 같은 메서드를 파라미터의 유형과 갯수가 다르도록 정의.

오버라이딩
  • 상속받은 메서드의 내용을 변경하는 것
  • 조상 클래스가 가지고 있는 메서드를 자손 클래스가 재정의.
  • 상속 관계 필요.
  • 메서드의 선언부가 같다.
  • 메서드의 바디부(내용)가 같거나 변경이 가해진다.
  • 접근제어자 : 같거나 넓어진다.
  • super: 조상 클래스와 내 클래스의 멤버를 구별.

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

super
  • 상속하면서 조상/자손클래스의 멤버가 중복 정의되어 서로 구별해야 되는 경우에 사용
  • super를 쓰면 조상클래스(Super Class)의 값을 참조
  • 메서드도 super를 써서 호출 가능 (자손클래스가 조상클래스의 메서드를 오버라이딩한 경우)
  • 생성자 메서드 내 첫 줄에 놓임 (this()와 겹치면 new를 사용해보자)

super() - 조상 클래스의 생성자 호출 메서드
  • 기본 생성자에 항상 super();가 은닉되어 있음.
  • 따로 매개(파라미터) 변수로 쓰는 게 아니면 유의할 것.


부모 클래스
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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("부모");
    }
}
cs

자식 클래스
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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();
}
cs


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





1
2
3
4
5
6
7
8
9
10
11
12
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();
    }
}
cs


final - 변경 불가한 클래스
  • 다른 클래스의 조상이 될 수 없다.
  • 오버라이딩 불가
  • 처음 선언만 하고, 나중에 생성자에서 단 한번만 초기화할 수 있다.

abstract - 미완성
  • 선언부만 작성, 실제 수행내용은 구현하지 않음
  • 클래스: 추상 메서드가 선언되어 있음을 의미
  • 메서드: 구현부가 없는 메서드

static은 static 끼리 호출
static 안 붙으면 다 참조 가능


다형성_polymorphism

여러가지 형태를 가질 수 있는 능력을 의미
하나의 참조 변수로 여러가지 객체를 참조하는 것

Parent p = new Child();
  • p는 부모꺼 & 자식꺼
  • 부모 타입으로 자식을 인스턴스화 시키는 것

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

부모가 자식에게 집과 집기를 물려줬더라도, 나중에 부모가 집으로 놀러와도 집기를 사용할 수 있다.
하지만, 자식이 부모가 모르는 새로운 집기를 사면, 부모는 띠요오오옹!!

메서드의 관련된 특징 중 오버로딩이 있는데,
이걸 클래스에서도 비슷하게 사용하도록 나온게 다형성

형변환
  • 조상타입의 인스턴스를 자손타입의 참조변수로 참조하는 것은 허용되지 않는다
1
2
3
Child c = new Child();
Parent p = new Child();
= (Child)p;
cs



[참조변수] instanceof [클래스이름]
  • 참조하고 있는 인스턴스의 실제 타입을 알아보기 위해
  • if문에서 형변환 확인용


Ch07PolyParent.java
1
2
3
4
5
6
7
8
9
10
11
public class Ch07PolyParent {
    int pnum = 100;
    
    public void pMethod() {
        System.out.println("부모 출력");
    }
    
    public void pAdd() {
        System.out.println("부모 add");
    }
}
cs


Ch07PolyChild.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
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() {}
}
cs



댓글 로드 중…

블로그 정보

잡다한 것이 한데 뒤섞인 곳

최근에 게시된 글