17일차 강의 정리


1. 추상 abstract

추상 클래스,추상 메소드

소스

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
abstract class Pm01 extends Object{        //Object 를 상속받지 않는다는것은 객체를 생성할수없다는 뜻
    int i=0;
    Pm01(){
        super();    //Object class
        System.out.println("추상클래스 객체의 호출");
    }
    
    void func1(){
        System.out.println("Pm class - func1()");
    }
 
    //추상메소드 갖을수 있음
    abstract void func2();    //메소드 선언  '{}'구현 은 없음(구현없는것이 추상메소드임)
}
 
abstract class Pm11 extends Pm01{
    abstract void func2();        //abstract 가 반드시
}
 
public class Ex01 extends Pm01{        //Pm11을 상속받아도 추상메소드 구현은 반드시
 
    Ex01(){
        super();    //Pm01 class
        System.out.println("me class 객체생성");
    }//Ex01 생성자 end
    
    public static void main(String[] args) {
 
        Ex01 me = new Ex01();
        me.func1();
        me.func2();
//        Pm01 pm01 = new Pm01();    //원칙은 추상클래스는 객체생성이 불가능(기능없는 메소드때문에)
        
    }//main end
    @Override         //어노테이션 - 오버라이드
    void func2() {    //추상메소드 오버라이드(강제)
        
    }
}//Ex01 class end
cs

결과

소스2

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
abstract class Am01{        //추상클래스
    int a=5;
    static void func01(){
        System.out.println("func01() call");
    }
    static void func01(int a){    //오버로드
        System.out.println("오버로드 func01() call");
    }
    void func02(){
        System.out.println("원조 func02()");
    }
    abstract void func03();        //재정의해서 쓰세요
}
 
public class Ex01 extends Am01{
    public static void main(String[] args) {
//        Ex01.func01();
        Ex01 me = new Ex01();
        me.func01();
        me.func02();
        me.func03();
        
    }
    void func02(){        //오버라이드
        super.func02();    //원 기능에 더 추가할 경우 사용
        System.out.println("func02() call");    //추가된 내용
    }
 
    void func03(){        //강제 제정의 
        System.out.println("func03() call");
    }
}
cs

결과2


2. 인터페이스 Interface (상속이 목적)

소스1 (설명)

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
interface Inter01{
//    inter01(){}        //생성자를 갖을수 없다(클래스가 x)
//    int a;            //변수를 필드로 갖을수 없다
    public final int a=7;    //오직 상수형 변수만 가능(public, final 생략가능)
    
    public abstract void func1();    //추상 메소드 (public, abstract 생략가능)
    abstract void func1(int a);        //모든 메소드가 public, abstract
    public void func2();
    
}
interface Inter02{
     void func1();
     void func3();
}
class Pm02 implements Inter01, Inter02{        //인터페이스 상속은 implements, 다중상속 가능
 
    @Override
    public void func3() {
        // TODO Auto-generated method stub
    }
    @Override
    public void func1() {
        // TODO Auto-generated method stub
    }
    @Override
    public void func1(int a) {
        // TODO Auto-generated method stub
    }
    @Override
    public void func2() {
        // TODO Auto-generated method stub
    }    
}
 
class Pm22 implements Inter02{
 
    @Override
    public void func1() {        //상속받은 인터페이스는 무조건 오버라이드
        // TODO Auto-generated method stub
    }
    @Override
    public void func3() {
        // TODO Auto-generated method stub
    }    
}
 
public class Ex02 {
    public static void main(String[] args) {
        Inter02 in = new Pm02();    //다형성이 극대화
        in.func1();
        in.func3();
 
    }
}
cs

소스2 (활용)

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
import java.util.Scanner;
 
interface Machine{
    void on();
    void off();
}
 
class Tv implements Machine{
    Tv(){
        System.out.println("TV를 준비합니다");
    }
    public void on(){
        System.out.println("전원을 켭니다");
    }
    public void off(){
        System.out.println("전원을 끕니다");
    }
}//Tv class end
 
class Radio implements Machine{
    Radio(){
        System.out.println("라디오를 준비합니다");
    }
    public void on(){
        System.out.println("전원을 켭니다");
    }
    public void off(){
        System.out.println("전원을 끕니다");
    }    
}//Radio class end
 
class Audio implements Machine{
    Audio(){
        System.out.println("오디오를 구비합니다");
    }
    public void on(){
        System.out.println("전원을 켭니다");
    }
    public void off(){
        System.out.println("전원을 끕니다");
    }
}//Audio class end
 
public class Remote {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("------------------------------------------------");
            System.out.println("어떤 기계를 제어하시겼습니까?");
            System.out.print("1. TV\t2. Radio\t3. Audil\t0. OFF : ");
            int input = Integer.parseInt(sc.nextLine());
 
            Machine m = null;
            if (input == 1) {
                m = new Tv();
            } else if (input == 2) {
                m = new Radio();
            } else if (input == 3) {
                m = new Audio();
            } else if (input == 0) {
                System.out.println("종료합니다");
                break;
            }
            m.on();
            m.off();
        }//while end
    }//main end
}//Remote class end
cs

결과2


저작자표시 비영리 변경금지

'* Programming > JAVA' 카테고리의 다른 글

숫자 입력시 천단위 정규식  (0) 2016.08.01
DAY18 예외처리  (0) 2016.08.01
DAY17 상속2(+캡슐화, 다형성)  (0) 2016.07.26
DAY16 상속1  (0) 2016.07.26
DAY16 접근제한자  (0) 2016.07.26

16일차 강의 정리


1. 상속

public 누구나

protected 디폴트와 동일,그러나 상속받을 경우는 가능

default 동일패키지

private 클래스내부

- 상속하기위한 class에 final 을 붙이면 상속이 불가능

- 그러나 필드에 있는경우에는 단순 상수화, 상속은 가능

- 상속할 class는 하나의 class 만



소스(패키지가 다른경우)

Ex01의 패키지는 package com.hb.pm;

1
2
3
4
5
6
7
8
9
10
public class Ex01 extends com.hb.am2.Temp{    
    public static void main(String[] args) {
        
//        com.hb.am2.Temp t = new com.hb.am2.Temp();    //이경로를통해서도 ok   
//        t.prn();                //prn()이 protected라서 불가능 
        Ex01 me = new Ex01();    //내가 상속을 받은 상태이기때문에 protected 가 가능
        me.prn();
 
    }//main end
}//class end
cs

상속하기위해서는 class 이름 뒤에 extends (클래스이름)

class Temp의 패키지는 package com.hb.am2;

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Temp {
 
    public static int a=0;
    public Temp(){
        
    }
    protected void prn(){
        System.out.println("상속으로 호출");
    }
    public void prn2(){
        System.out.println("상속으로 호출2");
    }
}
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
38
39
40
public class Ex01{
    public static void main(String[] args) {
        Son son = new Son();
        Son son2 = new Son();
        System.out.println(son.showMoney1());
        System.out.println(son.showMoney2());
        System.out.println(son.equals(son2));
    }//main end
}//class end
 
class Son extends Parent1{        //상속은 한 class만 가능
    int money=0;
    
    /////////////////////이안의 내용이 상속되는 것이다
//    int money1 = 3000;
//    int money2 = 5000;
//
//    int showMoney1() {
//        return money1;
//    }
//    int showMoney2() {
//        return money2;
//    }
    //////////////////////
}
 
class Parent extends Object{        //final 붙이면 상속  불가
    int money1 = 3000;
    
    int showMoney1(){
        return money1;
    }
}
class Parent1 extends Parent{
    int money2 = 5000;
    
    int showMoney2(){
        return money2;
    }
}
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
public class Ex02 {
    public static void main(String[] args) {
        // 오버로드&오버라이드
        Child ch = new Child();
        ch.prn();
        ch.prn("자식");
        Child ch2 = new Child();
        ch2.prn();
        ch2.prn("자식2");
        
    }//main end
}//class end
 
class Child extends Parent2{
    void prn(){                //오버 라이드 -> 상속은 받았지만 기능을 덮다
        System.out.println("Child prn 메소드 호출");
    }
    void prn(String st){    //오버로드
        System.out.println(st+"child prn 메소드 호출");
    }
}//class Child end
 
class Parent2{
    void prn(){
        System.out.println("Parent class prn 메소드 호출");
    }
}//class Parent2 end
cs

결과

소스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Ex03 {
 
    public static void main(String[] args) {
        Temp me = new Temp(3);
        Temp me2 = new Temp(3);
        
        System.out.println(me.equals(me2));
    }
}
 
class Temp{
    int a;
    Temp(int a){
        this.a = a;
    }    
    public int hashCode(){
        return a;
    }    
    public boolean equals(Object obj){
        return a==obj.hashCode();        //값을 비교하도록 변경
    }
}
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
public class Ex04 {
    public static void main(String[] args) {
        
        Child41 ch1 = new Child41();
        System.out.println(ch1.money);
        Child42 ch2 = new Child42();
        System.out.println(ch2.money);    
    }
}
 
class Child41 extends Parent4{
    int func1(){
        return money;
    }
}
class Child42 extends Parent4{
    int money = 3000;    //오버라이드
    int func1(){
        return money;
    }
}
class Parent4{
    int money = -5000;
}
cs

결과



저작자표시 비영리 변경금지

'* Programming > JAVA' 카테고리의 다른 글

DAY17 추상클래스&인터페이스  (0) 2016.07.26
DAY17 상속2(+캡슐화, 다형성)  (0) 2016.07.26
DAY16 접근제한자  (0) 2016.07.26
회원가입 프로그램  (0) 2016.07.25
DAY15 Wrapper class  (0) 2016.07.25

+ Recent posts

티스토리툴바