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
28
29
30
31
32
33
class Pm01{//extends Object
//    public Pm01(){    //숨어있는 아가들
//        super();
//        System.out.println("pm01 클래스 생성자");
//    }
    void func01(){
        System.out.println("Pm01 class func01() call");
    }
}
 
public class Ex01 {
    public static void main(String[] args) throws Exception {
        //Object
        Object obj = new Object();
        Pm01 pm01 = new Pm01();
        
        System.out.println(pm01.toString());
        System.out.println(pm01);
        System.out.println("pm01클래스의 해시코드: "+pm01.hashCode());
        System.out.println("pm01클래스의 경로: "+pm01.getClass());
        pm01.func01();
        System.out.println("------------------------");
        
        //리플렉션
        Class info = Class.forName("com.hb.pm.Pm01");
        Object obj2 = info.newInstance();
        Pm01 pm02 = (Pm01)obj2;
        
        System.out.println(pm02.getClass());
        pm02.func01();
 
    }//main end
}//class end
cs

결과



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

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

DAY21 싱글톤 패턴  (0) 2016.08.02
DAY20 Calendar/Date/Random/Arrays Class  (0) 2016.08.02
DAY20 this/super  (0) 2016.08.02
DAY19 익명클래스  (0) 2016.08.02
DAY19 내부클래스,로컬클래스  (0) 2016.08.01

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

19일차 강의 정리


1. 익명클래스(Anonymous Class)

익명이란 이름이 없는 것을 의미 - 한번만 사용하고 버려지는 객체를 사용할때 유용

참조할 수 있는 참조변수가 없어서 객체가 생성되고 두번다시 객체에 접근불가

클래스 이름이 없어서 생성자 또한 없다

- 인터페이스

소스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
public class Ex01 {
 
    interface Inner{
        int a=11;
        void inFunc01();
        void inFunc02();
    }
    
    public static void main(String[] args) {
        // 익명클래스-찍어낸 객체만필요 ,이름이 필요없다.
        Ex01 me = new Ex01();
        Inner inn = me.func01();
        inn.inFunc01();
        inn.inFunc02();
        System.out.println(inn.a);
 
    }//main end
    public Inner func01(){
        System.out.println("func01 start");
        System.out.println("func01 end");
        return new Inner(){
            int a=88;        //(자료,정보)은닉성
            public void inFunc01(){
            System.out.println(a+"내부클래스의 메소드 호출1");    
            }
            @Override
            public void inFunc02() {
                System.out.println(a+"내부클래스의 메소드 호출2");    
            }
        };
    }//func01() end
 
}//class end
cs

결과1

소스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
interface Anony01{
    void func01();
}
 
public class Ex02 {
    public static void main(String[] args) {
        Anony01 me = new Anony01(){
            @Override
            public void func01(){
                System.out.println("인터페이스를 통한 객체 생성1");
            }
        };        //;반드시 필요
        me.func01();
        
        System.out.println("----------------------------------");
        new Anony01(){
            @Override
            public void func01(){
                System.out.println("인터페이스를 통한 객체 생성2");
            }
        }.func01();
    
    }//main end
 
}//class end
cs

결과2


- 추상클래스

소스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
abstract class Anony02{        //추상클래스
    int a=1000;
    public Anony02(){}
    void func02(){
        System.out.println("추상클래스입니다");
    }
    abstract void func02(int a);
    
}
 
public class Ex02 {
    public static void main(String[] args) {
 
        System.out.println("----------------------------------");
        Anony02 me2 = new Anony02(){//생성자를 호출하면서 구현도 함께하기위해{};한다
            int a=4;                    //필드는 공용값 사용하지말아라 여기서
            void func02(int a){        //구현과 실행문장
                System.out.println("인자"+a+",,"+this.a+"를 전달 받은 추상클래스의 메소드");
            }
        };        //객체 생성
        me2.func02();    //참조변수(객체의 주소)를 통해서 기능 호출
        me2.func02(3);
        System.out.println(me2.a);        
    }//main end
 
}//class end
cs

결과1

소스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
abstract class Am03 extends Object{
    String msg="super";
    public Am03(){
        super();
        System.out.println("Am03 class 생성자 호출");
    }
    void func01(){
        System.out.println("추상class(Am03) func03()");
    }
    abstract void func02();        //추상 메소드
}
 
public class Ex03 {
    
    public static void main(String[] args) {
        Am03 me = new Am03(){
            String msg="this";    //이것을 가리킬수있는 방법이없다(필드는 오버라이드가 되지않아서)
            @Override
            void func02() {
                System.out.println("자식class 재정의func03()");                
            }
            void func03(){}        //없는 기능 구현해도 사용x
            
        };
        me.func01();
        me.func02();
        System.out.println("msg:"+me.msg);
    }//main end
}//Ex03class end
cs

결과2



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

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

DAY20 Object클래스,리플렉션  (0) 2016.08.02
DAY20 this/super  (0) 2016.08.02
DAY19 내부클래스,로컬클래스  (0) 2016.08.01
DAY19 예외처리2  (0) 2016.08.01
숫자 입력시 천단위 정규식  (0) 2016.08.01

19일차 강의 정리


1. 내부클래스 (클래스 안의 클래스)

소스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
public class Ex03 {    
    
    static class Inner03{    //내부클래스
        static int a=100;
        int b=50;
        static class Inin03{
            static int a=10;
        }
        public Inner03(){    //내부클래스 생성자
        }
        
        static void func01(){
            System.out.println("Inner class func01() call");
        }
        void func02(){
            func();
            System.out.println("Inner class func02() call");
        }
        
    }//Inner03 class end
    
    public static void main(String[] args) {
        
//        com.hb.am.Ex03 me = new com.hb.am.Ex03();    //패키지 경로가 숨겨져있다
//        com.hb.am.Ex03.func();        //패키지 경로,내클래스명 숨겨있다
        Ex03.Inner03.func01();
        Inner03 in = new Inner03();    //내부클래스 객체생성
        in.func02();
        System.out.println(Ex03.Inner03.a);
        System.out.println(in.b);    //non-static
        System.out.println(Ex03.Inner03.Inin03.a);    //static 이면 접근 쉽다
        
    }//main end
 
    public static void func(){
        System.out.println("Ex03 class func02() call");
    }//func() end
 
}//Ex03 class end
cs

결과1

소스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
public class Ex04 {    
    int a = 4;
    int b = 5;
 
    class Inner04{    //내부클래스
        int a=100;
//        static int b=50;    //static은 class가 static일경우에 사용가능
        
        public Inner04(){    //생성자
        }
        void func01(){
            System.out.println("Inner04 class func01()");
            System.out.println("Ex04-b :"+b);
            func02();
        }
//        static void func02(){
//            System.out.println("Inner04 class func02()");
//        }
    }
    
    public static void main(String[] args) {
        Ex04 me = new Ex04();
        Ex04.Inner04 inme;
        inme = me.new Inner04();        //Inner클래스의 생성자 객체 생성
        System.out.println(inme.a);        //Inner클래스의 변수 출력
        inme.func01();                    //Inner클래스의 메소드 호출
        
    }//main end
    
    public void func02(){
        System.out.println("Ex04 class func02");
    }
 
}
cs

결과2

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
public class Ex05 {
    int a=5;
    public Ex05(){    }    //Ex05 생성자
    
    public static void main(String[] args) {
        Ex05 me = new Ex05();
        me.func01();
        me.func02(4);
 
    }//main end
 
    void func01(){
        System.out.println("Ex05-func01()");    
    }
    
    void func02(final int m){    //인자도 상수화시키면 LocalC에서 사용가능
        System.out.println("Ex05-func02()");
        int i=10;    //LocalC에서 사용이 불가능(but 상수화(final)시키면 가능
        
        //LocalClass
        class LocalC{
            int i=11;    //오류가 나지 않는다
            LocalC(){
                
            }
            void func03(){
                System.out.println("로컬class-func03()-"+m);    //인자를 받은 지역변수를 사용할수없다(자바 ver.1.8에서는 가능)
            }
            void func04(){
                System.out.println("로컬class-func04()-"+a);    //필드 사용가능
            }
            void func05(){
                System.out.println("로컬class-func04()-"+i);    
            }
        }//LocalC class end
        
        LocalC inn = new LocalC();
        inn.func03();
        inn.func04();
        inn.func05();
        
        return;        //return 해서 메인에서 사용하고싶은 경우에 interface를 사용해서한다(소스 가져오기!!)
    }//func02() end
}//Ex05 class end
cs

결과


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

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

DAY20 this/super  (0) 2016.08.02
DAY19 익명클래스  (0) 2016.08.02
DAY19 예외처리2  (0) 2016.08.01
숫자 입력시 천단위 정규식  (0) 2016.08.01
DAY18 예외처리  (0) 2016.08.01

19일차 강의 정리


예외처리 다른소스

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
import java.util.Scanner;
 
public class Ex01 {
    public static void main(String[] args) {
 
        System.out.println(">>>"+func1());
        
    }//main end
 
    public static String func1(){
        Scanner sc = new Scanner(System.in);
        System.out.print("금액 : ");
        int won=0;
        String input=null;
        String output=null;
        try{
            input=sc.nextLine();
            won = Integer.parseInt(input);
            output = won+"원";
        }catch(Exception e){
            e.printStackTrace();
            return input;
        }
        return output;
    }//func1() 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
import java.util.Scanner;
 
public class Ex02 extends Exception{
    public Ex02(){
        super("내클레스로 에러처리");
    }
    public Ex02(String s){
        super(s);
    }
    public static void main(String[] args) throws Exception{    //try 쓰지않아도 throws Exception이 생략된것이라 오류처리가 된다
        System.out.print("숫자 입력 : ");
        try{
            func01();
        }catch(NumberFormatException e){
            System.out.println("NumberFormatException에러 처리 완료");
        }catch(Exception e){
            System.out.println(e.getMessage());
        }
    }//main end
 
    public static void func01() throws Exception{
        Scanner sc;
        sc = new Scanner(System.in);
        String input = sc.nextLine();
        int su = Integer.parseInt(input);
        System.out.println("입력한수는 "+su);
        Ex02 exc = new Ex02("Ex02클래스는 에러처리가능");
//        Exception exc = new Exception();
        throw exc;    //Exception에러를 던진다
    }//func01() end
}//class end
cs

결과2


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

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

DAY19 익명클래스  (0) 2016.08.02
DAY19 내부클래스,로컬클래스  (0) 2016.08.01
숫자 입력시 천단위 정규식  (0) 2016.08.01
DAY18 예외처리  (0) 2016.08.01
DAY17 추상클래스&인터페이스  (0) 2016.07.26

+ Recent posts

티스토리툴바