Q. 숫자입력 : 

0000000 -> 0,000,000

소스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    
    System.out.print("숫자 입력 : ");
    String num = sc.nextLine(); 
 
    //반복문, StringBuffer이용
    StringBuffer sb = new StringBuffer(num);
    for (int i = sb.length() - 3; i > 0; i = i - 3) {
        sb.insert(i, ",");     //i위치에 콤마(,) 추가           
    }
    System.out.println("********결과********");
    System.out.println(sb.toString());
}
cs

결과


실수0000000.000 -> 0,000,000.000

소스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) {
 
    Scanner sc = new Scanner(System.in);
    System.out.print("숫자 입력 : ");
    String num = sc.nextLine();
    
    String[] s = num.split("\\.");    //'.' 기준으로 잘라서 저장
 
    num=s[0];
    for (int i = num.length()-3; i > 0; i-=3) {
        String tmp1 = num.substring(0, i);
        String tmp2 = num.substring(i);
        num=tmp1+","+tmp2;
    }
    System.out.println("********결과********");
    System.out.println(">>> "+num+"."+s[1]);    //실수입력시 
}
cs

결과


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

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

DAY19 내부클래스,로컬클래스  (0) 2016.08.01
DAY19 예외처리2  (0) 2016.08.01
DAY18 예외처리  (0) 2016.08.01
DAY17 추상클래스&인터페이스  (0) 2016.07.26
DAY17 상속2(+캡슐화, 다형성)  (0) 2016.07.26

18일차 강의 정리


1. 예외처리

try { 

~~~

}catch(에러 e){

~~~

}

소스1

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
    
    int[] arr = {1,2,3,4,5};
    
    try {
        for(int i=0; i<=10; i++) {
            System.out.println("arr[" + i + "]=" + arr[i]);
        }
    } catch (ArrayIndexOutOfBoundsException ex) {     //예외처리->배열 인덱스오류(RuntimeException 도 가능)
        System.out.println(ex);
    }    
}
cs

결과1

-> System.out.println(ex);

-> ex.printStackTrace(); //콘솔창에 에러이름과 에러난 줄등의 상세한 정보출력

-> System.out.println(ex.toString());

-> System.out.println(ex.getMessage());

소스2-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int input = 0;
        
        try{
        System.out.print("숫자를 입력해주세요>>");
            input = Integer.parseInt(sc.nextLine());
            System.out.println("input: "+3/input);
//        }catch(NumberFormatException ex){
        }catch(RuntimeException ex){        //catch도 순서중요, 넓은 범위로 내려가는것이 좋다
            System.out.println(ex.getMessage());
            System.out.println("숫자!!!!!!!!!!!!!");
//        }catch(ArithmeticException ex){        //0으로 나누는지
//            System.out.println("0으로 나눌수 없습니다");
//            ex.printStackTrace();
        }catch(Exception ex){
            ex.printStackTrace();
        }
        
}//main end
cs

결과2-1

소스2-2

catch 순서 중요 -> Exception 을 상속하는 하위의 오류가 아래에 나와있으면 오류

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int input = 0;
    
    try{
    System.out.print("숫자를 입력해주세요>>");
        input = Integer.parseInt(sc.nextLine());
        System.out.println("input: "+3/input);
//        }catch(NumberFormatException ex){
//        }catch(RuntimeException ex){        //catch도 순서중요, 넓은 범위로 내려가는것이 좋다
//            System.out.println(ex.getMessage());
//            System.out.println("숫자!!!!!!!!!!!!!");
    }catch(ArithmeticException ex){        //0으로 나누는지
        System.out.println("0으로 나눌수 없습니다");
        ex.printStackTrace();
    }catch(Exception ex){
        ex.printStackTrace();
    }
    
}//main end
cs

결과2-2

소스3 (메소드에서 오류 던지기)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) throws Exception {
    
    try {
        func01();
    } catch (NumberFormatException e) {        //다중
        System.out.println("오류-숫자값이 아닙니다");
    } catch (ArithmeticException e) {
        System.out.println("오류-0으로 나눌수없습니다");
    } catch (Exception e) {
        e.printStackTrace();
    }
}//main end
 
public static void func01() throws Exception {     //오류시 던져
    System.out.println(Integer.parseInt("a"));    
    System.out.println(3 / 0);
}//func01() end
cs

결과3

func01() 의 내용 변경

1
2
3
4
public static void func01() throws Exception {     //오류시 던져
    System.out.println(Integer.parseInt("1"));    
    System.out.println(3 / 0);
}//func01() end
cs

결과3-1

소스4 (finally)

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {
    try{
        System.out.println(3/0);
    }catch(Exception e){
        System.out.println("오류");
        return;
    }finally{    //반드시 실행한다
        System.out.println("1프로그램을 종료합니다.");
    }
    System.out.println("2프로그램을 종료합니다.");
}
cs

결과4

소스5

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
import java.util.Scanner;
 
class NumOutException extends Exception{        //Exception 을 상속하는 하위의 오류 class
    NumOutException(String msg){
        super(msg);
    }
}
 
public class Ex04 {
    public static void main(String[] args) {
        try{
            func01();
        }catch(NumOutException e){
            System.out.println("나이입력오류");
            e.printStackTrace();
        }
    }//main end
    
    public static void func01() throws NumOutException{
        Scanner sc = new Scanner(System.in);
        
        System.out.print("나이를 입력 : ");
        int age = Integer.parseInt(sc.nextLine());
        
        if(age<1){
            throw new NumOutException("나이를 " + age+"살로 입력했음");
        }
        
        System.out.println("당신의 나이는 "+age+"세 입니다");
    }//func02 end
}//class end
cs

결과5


*내가 만든 에러

소스

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
class Am05 extends Exception{
    public Am05(){
        super("내가만든에러");
    }
    @Override
    public String toString(){
        return "오류메시지";
    }
    public void func01(){
        System.out.println("이렇게도 가능");
    }
}
 
public class Ex05 {
    public static void main(String[] args) {
        Ex05 me = new Ex05();
        try{
            me.func01(1);
            System.out.println("여기까지 수행");
        }catch(Am05 e){
            System.out.println(e.toString());
            System.out.println(e.getMessage());
            e.func01();
            e.printStackTrace();
        }catch(Exception e){
            System.out.println("~~");
            e.toString();
        }
    }//main end
    void func01(int a) throws Am05{
//        System.out.println(3/0);
        Am05 ex = new Am05();
        throw ex;
    }//func01() end
}//class end
cs

결과


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

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

DAY19 예외처리2  (0) 2016.08.01
숫자 입력시 천단위 정규식  (0) 2016.08.01
DAY17 추상클래스&인터페이스  (0) 2016.07.26
DAY17 상속2(+캡슐화, 다형성)  (0) 2016.07.26
DAY16 상속1  (0) 2016.07.26

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

티스토리툴바