20일차 강의 정리


소스

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
class Am01{        //부모 클래스
    String msg="super";
    
    void func01(){
        System.out.println("super class");
    }
}
class Am11 extends Am01{        //Am01을 상속받는 자식클래스
    String msg="this";
    
    @Override
    void func01(){
        System.out.println("this class");
    }
}
 
public class Ex01 {    
    public static void main(String[] args) {
        Am11 me = new Am11();        //this
//        Am01 me = new Am11();        //super
        
        System.out.println(new Am01().msg);    //super
        System.out.println(me.msg);
        me.func01();
        
    }//main end
}//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
33
34
35
36
abstract class Am02 extends Object{
    String msg="super";
    public Am02(){
        super();
        System.out.println("Am02부모 class 생성자");
    }
    void func01(){
        System.out.println("부모 추상class func02()");
    }
    abstract void func02();
 
}
 
class Am22 extends Am02{
    String msg="this";
    public Am22(){
        super();
        System.out.println("Am22자식 class 생성자");
    }
    
    @Override
    void func02() {
        System.out.println("자식class 재정의 func02()");    
    }
    
}//Am22 class end
 
public class Ex02 {
    public static void main(String[] args) {
//        Am22 me = new Am22();    //msg가 this
        Am02 me = new Am22();    //msg가 super(받는게 부모라서)
        System.out.println("msg : "+me.msg);
        me.func01();
        me.func02();
    }//main end
}//class end
cs

결과2





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

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

DAY20 Calendar/Date/Random/Arrays Class  (0) 2016.08.02
DAY20 Object클래스,리플렉션  (0) 2016.08.02
DAY19 익명클래스  (0) 2016.08.02
DAY19 내부클래스,로컬클래스  (0) 2016.08.01
DAY19 예외처리2  (0) 2016.08.01

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

17일차 강의 정리


소스(super - 부모생성자의 명시적 호출)

오버라이드의 경우 접근제한자의 범위가 작아진경우 오류

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
//final class Pl01{        //final을 통하면 상속이 불가능
class Pl01{
    double pi=3.14;        //final이 필드에 붙으면 상수화. 상속가능
    
    Pl01(){
        System.out.println("Pi01 객체 생성");
    }
    Pl01(double pi){
        this.pi=pi;
        System.out.println(pi+"Pi01 객체 생성2");
    }
    
    public final void prn(){    //final을 통하면 오버라이드기능 금지.이대로 사용해라
        System.out.println("첫번째 기능");
    }
    public void prn(String st){
        System.out.println(st+"는(은) 두번째 기능");
    }
}
 
public class Ex01 extends Pl01{
 
    double pi=3.22222;        //상수화는 오버라이드 가능
    
    Ex01(){        //생성자
        super(3.3333);        //명시하지않으면 숨어있는다.부모생성자 명시적 호출
        System.out.println("Ex01 객체 생성");
//        super();        //생성자의 최상단에와야한다
    }
 
    public static void main(String[] args) {
        Ex01 me = new Ex01();
        me.prn();
        me.prn("이것");
        
    }//main end
 
    public void prn(String st){        //오버라이드이면 접근제한자 범위가 확장되어야한다 (줄어드는 경우 오류)
        System.out.println(pi+st+" 수정된 기능");
    }
}//class end
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
class Cl02{
    int a = 4;
    
    public Cl02(){        //생성자란 객체 생성하고 최초에 할일을 명시하는역할이다.(일반적으로 초기화작업)
        System.out.println("슈퍼클래스()~");
    }
    public Cl02(int a){
        this();        //없으면 Cl02()의 print는 사용하지않는다
        System.out.println("슈퍼클래스()~"+a);
    }
}//class Cl02 end
 
public class Ex02 extends Cl02{
    int a = 5;
    public Ex02(int a){
        super(a);
        System.out.println("내클래스");
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Ex02 me = new Ex02(2);
//        Ex02 me2 = new Ex02(3);
        System.out.println(me.getA());
 
    }//main end
    int getA(){
//        return super.a;    //4
        return this.a;    //5
    }
}//class end
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
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
class Man{        //사람 클래스
    String name;
    
    Man(String name){
        this.name=name;
    }
    void callByName(){
        System.out.println("나는 "+name+"입니다.");
    }
}
 
class Sol extends Man{    //군인 클래스,사람 클래스 상속
    String tree;
    Sol(String name,String tree){
        super(name);
        this.tree=tree;
    }
    void callbySol(){
        System.out.print(tree+",");
        callByName();
    }
}
 
class BMan extends Man{    //회사원 클래스,사람 클래스 상속
    String tel;
    String comp;
    String name;
    
    BMan(String name,String tel,String comp){
        super(name);
        this.tel = tel;
        this.comp = comp;
    }
    BMan(String name,String tel,String comp,String newName){
        this(name,tel,comp);
        this.name=newName;
    }
    void callByName(){    //오버라이드
        System.out.println("나는 "+name+"입니다.");
    }
    void yourPhone(){
        System.out.println(tel+"입니다.");
    }
    void yourComp(){
        System.out.println(comp+"에 근무중입니다.");
    }
    void info(){    //캡슐화(묶는다)
        super.callByName();
        this.yourPhone();
        yourComp();
    }
}
 
public class Ex03 {
    public static void main(String[] args) {
        //캡슐화
        BMan man1= new BMan("홍길동","010-1111-2222","한빛");
        man1.callByName();
        man1.yourPhone();
        man1.yourComp();
        System.out.println("-----------------------");
        BMan man2= new BMan("홍길자","010-3333-4444","한빛ENI","제니퍼홍");
//        man2.info();
        man2.callByName();
        System.out.println("-----------------------");
        Sol sol = new Sol("유승준","이병");
        sol.callbySol();
        System.out.println("-----------------------");
        
 
        //다형성
        Man man = new Man("홍길동");
        man.callByName();
        man = new Sol("가일","병장");    //다운 캐스팅
        man.callByName();
//        man.callbySol();        //오류,받는것이 Man이라
        man = new BMan("홍길자","010-3333-4444","한빛ENI","제니퍼홍");
        man.callByName();    //제니퍼홍 출력
        Object obj = new Man("홍홍ㅎ오");    //업 캐스팅
        obj = new Sol("가일","상병");
        Sol me = (Sol)obj;
        me.callbySol();
    }
}
cs

결과

*처음 이름에 null이 나오는 이유는 오버라이딩 때문이다.


은행소스

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
class BankDB{
    int money;
    BankDB(int money){
        this.money = money;
    }
    //입금
    void input(int money){
        this.money+=money;
    }
    //출금
    int output(int money){
        if(this.money>=money){
            this.money-=money;
            return money;
        }else{
            return 0;
        }
    }
}
 
class Bank extends BankDB{
    Bank(int money){
        super(money);    
    }
    void saveMoney(int money){
        input(money);
        System.out.println("현재잔고: "+super.money);
    }
    void getMoney(int money){
        int won = output(money);
        if(won==0){
            System.out.println("출금 실패");
        }else{
            System.out.println("현재잔고: "+super.money);
        }
    }
}
public class Ex04 {
    public static void main(String[] args) {
        Bank bank = new Bank(1000);
        bank.saveMoney(10000);
        bank.getMoney(5000);
        bank.getMoney(5000);
        bank.getMoney(1000);
    }
}
cs

결과


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

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

DAY18 예외처리  (0) 2016.08.01
DAY17 추상클래스&인터페이스  (0) 2016.07.26
DAY16 상속1  (0) 2016.07.26
DAY16 접근제한자  (0) 2016.07.26
회원가입 프로그램  (0) 2016.07.25

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

티스토리툴바