Java2 day10

[10일차 수업내용]
1. 내부클래스 ( inner class )
2. 익명클래스 (anonymous class )
3. 예외처리 ( exception handling ) <- 오늘의 주 내용
=====================================================================
1. 내부클래스 ( inner class )
            - 내부클래스는 클래스 내에 클래스가 선언된다는 점을 제외하고는 일반적인 클래스와
              다르지 않다.
            - 내부클래스는 사용빈도가 높지 않으므로 내부클래스의 기본원리와 특징을 
              이해하는 정도만 알아보자
            - 내부클래스는 클래스 내에 선언된 클래스로서 외부클래스와 서로 긴밀한 관계가 있기 때문에
              사용한다.
            - 내부클래스의 장점은 다음과 같다.
                        ① 내부클래스에서 외부클래스의 멤버들을 쉽게 접근할 수 있다.
                        ② 코드의 복잡성을 줄일 수 있다.

            1-1 ) 내부클래스의 종류와 특징
                        - 내부클래스의 종류는 변수의 선언위치에 따른 종류와 같다
                        - 내부클래스는 마치 변수를 선언하는 것과 같은 위치에 선언할 수 있으며
                          변수의 선언위치에 따라 인스턴스변수, 클래스변수, 지역변수로 구분되는 것과 같이
                          내부클래스도 다음과 같이 구분되어 진다.

                        내부클래스의 종류                                          특징

                        인스턴스클래스                         외부클래스의 멤버변수 선언위치에 선언하며, 
                        (Instance class)                        외부클래스의 인스턴스처럼 다뤄진다.
                                                                    주로 외부클래스의 인스턴스멤버들과 관련된 작업에 
                                                                    사용될 목적으로 선언된다.

                        스태틱클래스                            외부클래스의 멤버변수 선언위치에 선언하며, 
                        (Static class)                            외부클래스의 static 멤버처럼 다뤄진다.
                                                                    주로 외부클래스의 static멤버, 
                                                                    특히 static 메소드에서 사용될 목적으로 선언된다.

                        지역클래스                              외부클래스의 메소드 내에 선언하며,  
                        (Local class)                            선언된 영역 내부에서만 사용될 수 있다.

            1-2 ) 내부클래스의 제어자와 접근성
                        - 인스턴스클래스와 스태틱클래스는 외부클래스의 멤버변수와 같은 위치에 선언되며,
                          또한 멤버변수와 같은 성질을 가진다.
                        - 즉, 내부클래스가 외부클래스의 멤버와 같이 간주되고 인스턴스 멤버와 static멤버간의 규칙이
                          내부클래스에서도 똑같이 적용된다.

                        O/X
                        인스턴스 메소드에서 클래스변수(스태틱변수)를 사용할 수 있다? O
                        스태틱 메소드에서 인스턴스변수를 사용할 수 있다? X

                        - 내부클래스 중에서 스태틱클래스만 static 멤버를 가질 수 있다.
                        - 다만 final과 static이 동시에 붙은 변수는 상수이므로 모든 클래스에서 정의가 가능하다.
                        - 인스턴스멤버는 같은 클래스에 있는 인스턴스멤버와 static 멤버 모두 직접 호출이 가능하지만,
                          static멤버는 인스턴스멤버를 직접 호출할 수 없는 것처럼
                          인스턴스클래스는 외부클래스의 인스턴스멤버를 객체생성없이 바로 사용할 수 있지만
                          스태틱클래스는 외부클래스의 인스턴스멤버를 객체없이 바로 사용할 수 없다.
                        - 마찬가지로 인스턴스클래스는 스태틱클래스의 멤버들을 객체없이 바로 사용할 수 있지만,
                          스태틱클래스에서는 인스턴스클래스의 멤버들을 객체없이 사용할 수 없다.

-----------------------------------------------------------------------------------------------------------------------------------
package example01;

public class InnerEx01 {
            // *** 내부클래스도 하나의 멤버처럼 생각하자 ***

            class InstanceInner{ // 인스턴스클래스
                        int iv = 100;
                        // static int cv = 100; 인스턴스클래스 내부에 static 변수를 선언할 수 없다.
                        final static int CONST = 100; // 상수는 허용
            }

            static class StaticInner{ // 스태틱클래스
                        int iv = 200;
                        static int cv = 200; // static클래스만 static멤버를 정의할 수 있다.
            }

            void method() {
                        class LocalInner{ // 로컬클래스, 로컬클래스는 static을 붙일 수 없다.
                                    int iv = 300;
                                    final static int COST = 300;
                                    // static int cv1 = 300;
                        }
                        LocalInner li = new LocalInner();
                        System.out.println(li.iv);
                        System.out.println(LocalInner.COST); 
            }
            public static void main(String[] args) {
                        System.out.println(InnerEx01.InstanceInner.CONST); //클래스명.내부클래스명.상수
                        System.out.println(InstanceInner.CONST); // 위와 동일
                        System.out.println();
                        System.out.println(InnerEx01.StaticInner.cv);
                        System.out.println(StaticInner.cv); // 위와 동일

                        InnerEx01.InstanceInner ic = new InnerEx01().new InstanceInner();

                        StaticInner si = new StaticInner();
                        System.out.println(si.iv);
                        System.out.println();

                        InnerEx01 it = new InnerEx01();
                        it.method();
            }
}
------------------------------------------------------------
package example01;

public class InnerEx02 {
            class InstanceInner{ int number; } // 인스턴스클래스
            static class StaticInner{};        // 스태틱클래스

            // 인스턴스 멤버간에는 서로 직접 접근이 가능하다.
            InstanceInner iv = new InstanceInner();

            // static 멤버간에는 서로 직접 접근이 가능하다.
            static StaticInner cv = new StaticInner();

            static void staticMethod() {
                        StaticInner obj0 = new StaticInner();
                        // InstanceInner obj = new InstanceInner();
                        /*
                         *  static 멤버는 인스턴스멤버에 직접 접근할 수 없다.
                         *  굳이 접근하려면 아래와 같은 방법을 사용하자
                         */
                        InnerEx02 outer = new InnerEx02();
                        InstanceInner obj2 = outer.new InstanceInner();
                        obj2.number = 30;
            }
            void instanceMethod() {
                        // 인스턴스메소드에서는 인스턴스멤버와 static멤버 모두 접근이 가능하다? O
                        InstanceInner obj1 = new InstanceInner();
                        StaticInner obj2 = new StaticInner();

                        //static <=> class 
            }
}
------------------------------------------------------
package example01;

public class InnerEx03 {
            private int outerIv = 0;
            static int outerCv = 0;

            class InstanceInner{
                        int iiv = outerIv;
                        int iiv2 = outerCv;
                        // 인스턴스클래스는 외부클래스의 멤버(인스턴스변수, 클래스변수)에 접근이 가능하다.
            }
            static class StaticInner{
                        // int siv = outerIv;
                        // static 클래슨ㄴ 외부클래스의 인스턴스멤버에 접근할 수 없다.
                        static int scv= outerCv;
                        int scv2 = outerCv;
            }

            class Parent{};
            Parent p = null;

            void method() {
                        int lv = 0;
                        final int Lv = 0;

                        class LocalInner extends Parent{
                                    int liv = outerIv;        // final int liv = outerIv;
                                    int liv2 = outerCv;       // final int liv2 = outerCv;
                                    int liv3 = lv;            // final int liv3 = lv;
                                    int lv4 = Lv;             // final int liv4 = Lv;

                                    /*
                                     *  로컬크래스에서는 상수만 사용이 가능하다.
                                     *  지역변수는 닫는 중괄호를 만나면 메모리에서 해제된다.
                                     *  그러나, 내부클래스의 객체는 메소드가 끝나도 생존이 가능하다.
                                     */
                        }
                        LocalInner li = new LocalInner();
                        p = li;
            }
}
-----------------------------------------------------------------
package example01;

public class InnerEx04 {
            public static void main(String[] args) {
                        // 내부클래스 중 인스턴스클래스의 인스턴스를 생성하려면
                        // 외부클래스의 인스턴스를 먼저 생성해야 한다.
                        Outer oc = new Outer();
                        Outer.InstanceInner li = oc.new InstanceInner();
                        System.out.println("li.iv : " + li.iv);
                        li.method();
                        System.out.println();

                        // static 내부클래스의 인스터스는 외부클래스를 먼저 생성하지 않아도 된다.
                        Outer.StaticInner si = new Outer.StaticInner();
                        System.out.println("si.iv : " + si.iv);
                        System.out.println("si.cv : " + si.cv);
                        System.out.println(Outer.StaticInner.cv); // 위와 동일하나 좀 더 static한 방법
                        System.out.println(); 

                        // 로컬클래스를 사용해보자
                        Outer outer = new Outer();
                        outer.localMethod();
                        Outer.localMethod2();
            }
}
class Outer{
            int value = 10;

            class InstanceInner{
                        int iv = 100;
                        int value  = 20;

                        void method() {
                                    int value = 30;
                                    System.out.println("value : " + value);   // 30
                                    System.out.println("this.value : " + this.value);   // 20
                                    System.out.println("Outer.this.value : " + Outer.this.value);  //10
                        }
            }
            static class StaticInner{
                        int iv = 200;
                        static int cv = 300;
            }
            void localMethod() {
                        class LocalInner{
                                    int iv = 400;
                        }
                        LocalInner li = new LocalInner();
                        System.out.println("li.iv : " + li.iv);
            }
            static void localMethod2() {
                        class LocalInner{
                                    int iv = 400;
                        }
                        LocalInner li = new LocalInner();
                        System.out.println("li.iv : " + li.iv);
            }
}
============================================================================
2. 익명클래스 ( anonymous class )
            - 익명클래스는 특이하게도 다른 클래스와 달리 이름이 없다.
            - 클래스의 선언과 객체의 생성을 동시에 하기 때문에 단 한번만 사용될 수 있고
              오직 하나의 객체만을 사용할 수 있는 일회용 클래스이다.

--------------------------------------------------------------------------------------
package example01;

public class AnonymousEx {
            public static void main(String[] args) {
                        // 1번째 활용
                        AnonymousInterface ai = new A();
                        AnonymousInterface ai2 = new AnonymousInterface() {
                                    // 이름이 없는 클래스 = anonymous클래스
                                    @Override
                                    public void method() {
                                                System.out.println("anonymous method()"); // 일회용 클래스
                                    }
                        };
                        ai2.method();
                        ai.method();
                        System.out.println();

                        // 2번째 활용
                        C c = new C();
                        c.method(new A());
                        c.method(new AnonymousInterface() {

                                    @Override
                                    public void method() {
                                                System.out.println("anonymousEx");
                                    }
                        });
                        c.method(new AnonymousInterface() {

                                    @Override
                                    public void method() {
                                                System.out.println("anonymousEx2");
                                    }
                        });
                        System.out.println();

                        // 3번째 활용

                        B b = new B();
                        b.method();

                        B b1 = new B() { // 일회성으로 쓰는 어나니머스 클래스
                                    @Override
                                    public void method() {
                                                System.out.println("Overrided method()");
                                    }
                        };
                        b1.method();
                        B b2 = new B();
                        b2.method();
            }
}
interface AnonymousInterface{ void method(); }

class A implements AnonymousInterface{
            @Override
            public void method() {
                        System.out.println("method() in A Class");
            }
}
class B{
            public void method() {
                        System.out.println("method() in B Class");
            }
}
class C{
            void method(AnonymousInterface a) {
                        a.method();
            }
}
============================================================================
3. 예외처리 ( exception handling )
            3-1 ) 프로그램 오류
                        - 프로그램 실행 중 어떤 원인에 의해서 오작동을 하거나 비정상적으로 종료되는 경우가 있다.
                        - 이러한 결과를 초래하는 원인을 프로그램 에러 또는 오류라고 한다.
                        - 이를 발생시점에 따라 '컴파일에러(complie error)' 와
                          '런타임에러(runtime error)'로 나눌 수 있다.
                          컴파일에러는 컴파일할 때 발생하는 에러이고 
                          프로그램 실행 중에 발생하는 에러를 런타임에러라고 한다.
                                    * 컴파일에러            : 컴파일시에 발생하는 에러( 주로 문법 )
                                    * 런타임에러            : 실행 시에 발생하는 에러( Ex. 배열 범위를 벗어남 )
                                    * 논리적에러            : 실행은 되지만 의도와 다르게 동작하는 것 

                        - 자바에서는 실행 시(runtime) 발생할 수 있는 프로그램 오류를 에러(error)와 예외(exception)
                          두가지로 구분하였다.
                        - 에러가 발생하면 프로그램의 비정상적인 종료를 막을 길이 없지만, 예외는 발생하더라도
                          프로그래머가 이를 적절한 코드를 미리 작성해 놓음으로써 비정상적인 종료를 막을 수 있다.
                                    * 에러(error)            : 프로그램 코드에 의해서 수습될 수 없는 심각한 오류
                                    * 예외(exception)      : 프로그램 코드에 의해서 수습될 수 있는 미약한 오류

            3-2 ) 예외처리 try-catch
                        - 프로그램 실행 도중에 발생하는 에러는 어쩔 수 없지만,
                          예외는 프로그래머가 이에 대한 처리를 미리 해주어야 한다.
                        - 예외처리란 프로그램 실행 시 발생할 수 있는 예기치 못한 예외의 발생에 대비한 코드를 

                          작성하는 것이며 예외처리의 목적은 예외의 발생으로 인한 실행 중인 프로그램의 

                          갑작스런 비정상적종료를 막고 정상적인 실행상태를 유지하도록 하는 것이다.

                        try{
                                    // 예외가 발생할 수 있는 코드
                        } catch(예외클래스 참조변수){
                                    // 예외가 발생했을 때 처리할 코드
                        } catch ...

                        ex)
                        try{
                                    4/0                                     // new ArithmeticException();
                                    int[] ar = new int[3];            
                                    ar[4] = 10;                            // new IndexOutOfBoundsException();
                        } catch(Exception e){
                                    // Exception e = new ArithmeticException();
                                    // Exception e = new IndexOutOfBoundsException();
                        }

                        ① try 블록 내에서 예외가 발생한 경우
                                    - 발생한 예외와 일치하는 catch 블록이 있는지를 확인한다.
                                    - 일치하는 catch블록을 찾게 되면 그 catch블록 내의 문장들을 수행하고
                                      전체 try-catch문을 빠져나가서 그 다음 문장을 수행한다.
                                    - catch문을 찾지 못하면 예외는 처리되지 않는다.

                        ② try 블록 내에서 예외가 발생하지 않는 경우
                                    - catch블록을 거치지 않고 try-catch문을 빠져나가서 수행을 계속한다.

            3-3 ) 예외의 발생과 catch 블록
                        - catch블록을 괄호()와 블록{} 두 부분으로 나누어져 있는데, 
                          괄호 내에는 처리하고자 하는 예외와 같은 타입의 참조변수를 선언해야 한다.
                        - 예외가 발생하면 발생한 예외에 해당하는 클래스의 인스턴스가 만들어진다.
                        - 또한 예외가 발생했을 때 생성되는 예외클래스와 인스턴스에는
                          발생한 예외에 대한 정보가 있으며 아래와 같다.
                                    * getMessage()       : 발생한 예외클래스의 인스턴스에 저장된 메시지를 얻을 수 있다.      
                                    * printStackTrace()  : 예외발생 당시에 호출스택에 있었던 정보와 
                                                                 예외 메시지를 화면에 출력한다.

            3-4 ) 예외 발생시키기
                        - 키워드 throw를 사용해서 프로그래머가 고의로 예외를 발생시킬 수 있으며
                          방법은 아래의 순서를 따르면 된다.
                                    ① 먼저 new를 이용해서 발생시키려는 예외클래스의 객체(인스턴스)를 만든 다음
                                    ② throw를 이용해서 예외를 발생시킨다.

            3-5 ) 메소드에 예외 발생시키기
                        - 예외를 try-catch문을 사용하는 것 외에 예외를 메소드에 선언하는 방법이 있다.
                        - 메소드에 예외를 선언하려면 메소드의 선언부에 throws를 사용해서
                          메소드 내에서 발생할 수 있는 예외를 적어주면 된다.
                        - 만약 예외가 여러개일 경우 쉼표로 구분해서 적어준다.

            3-6 ) finally 블록
                        - finally 블록은 예외 발생여부에 상관없이 실행되어야 할 코드를 포함시킬 목적으로 사용된다.
                        - try-catch-finally의 순서로 구성된다.

                        try{
                                    // 예외가 발생할 수 있는 코드
                        } catch() {
                                    // 예외가 발생했을 때 처리할 코드
                        } finally {
                                    // 예외 발생 유무에 상관없이 실행 될 코드
                        }

            3-7 ) 사용자 정의 예외 만들기
                        - 기존에 정의된 예외클래스 외에 필요에 따라 프로그래머가
                          새로운 예외 클래스를 정의하여 사용할 수 있다.
                        - 보통 Exception클래스 또는 RuntimeException 클래스로부터 상속받아 클래스를 만들지만
                          상황에 따라 알맞은 예외클래스를 선택할 수 있다.

-----------------------------------------------------------------------------------------
package example02;

public class ExceptionEx01 {
            public static void main(String[] args) {
                        try {
                                    // 예외가 발생할 수도 있는 코드
                                    try {

                                    } catch (Exception e) {
                                                // TODO: handle exception
                                    }
                        } catch (Exception e) {
                                    // 예외가 발생했을 시 처리할 코드
                                    try {

                                    } catch (Exception e2) {
                                                // TODO: handle exception
                                    }
                        }
            }
}
------------------------------------------------------------------------
package example02;

public class ExceptionEx02 {
            public static void main(String[] args) {
                        // 예외를 발생시켜보자.
                        int number = 100;
                        int result = 0;

                        for(int i = 0; i < 100; i++) { // 반복 횟수 : 100번
                                    result = number / (int)(Math.random() * 10);
                                    // (int)(Math.random() * 10) 범위 : 0 ~ 9
                                    System.out.println("result : " + result);
                                    // 생성된 인스턴스 : new ArithmeticException();
                        }
                        System.out.println("for문이 정상적으로 종료되었습니다.");
            }
}
----------------------------------------------------------------------
package example02;

public class ExceptionEx03 {
            public static void main(String[] args) {
                        int number = 100;
                        int result = 0;

                        for(int i = 0; i < 30; i++) { 
                                    try {
                                                result = number / (int)(Math.random() * 10);
                                                System.out.println("result : " + result);
                                                // 생성한 인스턴스 : new ArithmeticException();
                                    } catch (ArithmeticException e) {
                                                // Exception e = new ArithmeticException();
                                                System.out.println("###### 0으로 나눠서 예외가 발생했습니다. ######");
                                    } catch (Exception e){
                                                System.out.println("!!!!!! 0으로 나눠서 예외가 발생했습니다. !!!!!!");
                                    }
                        }
                        System.out.println("for문이 정상적으로 종료되었습니다.");
            }
}
-----------------------------------------------------------------------
package example02;

public class ExceptionEx04 {
            public static void main(String[] args) {
                        System.out.println(1);
                        System.out.println(2);

                        try {
                                    System.out.println(3);
                                    System.out.println(4);
                        } catch (Exception e) {
                                    System.out.println(5);
                        }
                        System.out.println(6);

                        // 1 2 3 4 5(X) 6
            }
}
-----------------------------------------------------------------------
package example02;

public class ExceptionEx05 {
            public static void main(String[] args) {
                        System.out.println(1);
                        System.out.println(2);

                        try {
                                    System.out.println(3);
                                    System.out.println(0/0);
                                    System.out.println(4);
                        } catch (ArithmeticException e) {
                                    System.out.println(5);
                        } catch (Exception e) {
                                    System.out.println(6);
                        }
                        // 1 2 3 4(X) 5 6(X)
            }
}
--------------------------------------------------------------------
package example02;

public class ExceptionEx06 {
            public static void main(String[] args) {
                        System.out.println(1);
                        System.out.println(2);

                        try {
                                    System.out.println(3);
                                    System.out.println(0/0); // new ArithmeticException();
                                    System.out.println(4);
                        } catch (Exception e) { // Exception e = new ArithmeticException();
                                    System.out.println("예외메시지 : " + e.getMessage());
                                    e.printStackTrace();
                        }
                        System.out.println("!!");
            }
}
------------------------------------------------------------------
package example02;

public class ExceptionEx07 {
            public static void main(String[] args) {
                        try {
                                    Exception e = new Exception("고의로 발생시킨 예외");
                                    throw e;
                        } catch (ArithmeticException e) {
                                    System.out.println("ArithmeticException");
                                    System.out.println("예외메시지 : " + e.getMessage());
                        } catch (Exception e) {
                                    System.out.println("Exception");
                                    System.out.println("예외메시지 : " + e.getMessage());
                        }

                        // ArithmeticException e = new Exception(); (X)
                        // 자식이 부모를 가리킬 수는 없다.

                        System.out.println();

                        try {
                                    throw new ArithmeticException("0으로 나눔");
                        } catch (ArithmeticException e) {
                                    System.out.println("예외메시지 : " + e.getMessage());
                        }
            }
}
--------------------------------------------------------------------
package example02;

public class ExceptionEx08 {
            public static void main(String[] args) {
                        // 필수적으로 예외처리가 필요한 예외가 필수가 아닌 예외
                        // throw new IOException(); // 사용만 해도 예외처리를 해줘야 하는 예외
                        throw new IndexOutOfBoundsException();
            }
}
--------------------------------------------------------------------
package example02;

public class ExceptionEx09 {
            public static void main(String[] args) {
                        try {
                                   method1();
                         } catch (Exception e) {
                                    System.out.println("main에서 예외처리");
                                    System.out.println(e.getMessage());
                        }
            }
            static void method1() throws Exception{
                        method2();
            }
            static void method2() throws Exception{
                        throw new ArithmeticException("0으로 나눔");
                        // throw : 예외발생시키기
                        // throws : 예외 던지기
            }
}
------------------------------------------------------------------
package example02;

public class ExceptionEx10 {
            public static void main(String[] args) {
                        try {
                                    startInstall();
                                    copyFiles();
                                    deleteTempFiles();
                        } catch (Exception e) {
                                    e.printStackTrace();
                                    deleteTempFiles();
                        }

                        try {
                                    startInstall();
                                    copyFiles();
                       } catch (Exception e) {
                                    e.printStackTrace();
                        } finally {
                                    deleteTempFiles();
                        }
            }
            static void startInstall() { /* 프로그램 설치에 필요한 준비를 하는 코드를 적는다. */ }

            static void copyFiles() { /* 파일을 복사하는 코드를 적는다. */ }

            static void deleteTempFiles() { /* 임시파일들을 삭제하는 코드를 적는다. */ }
}
-----------------------------------------------------------------------
package example02;

import java.io.IOException;

public class ExceptionEx11 {
            // 사용자 정의 예외클래스 만들기
            public static void main(String[] args) {
                        try {
                                    startInstall();
                                    copyFiles();
                                    throw new IOException(); // 주석처리 해보고 안해보면서 결과 확인해보기
                        } catch (SpaceException e) {
                                    System.out.println("에러메시지 : " + e.getMessage());
                                    System.out.println("공간을 확보한 후 다시 설치하시기 바랍니다.");
                        } catch (MemoryException e) {
                                    System.out.println("에러메시지 : " + e.getMessage());
                                    System.out.println("메모리 공간이 부족합니다.");
                        } catch (Exception e) {
                                    System.out.println("메모리, 공간 외의 예외 발생");
                        } finally {
                                    deleteTempFiles();
                                    System.out.println("임시파일 삭제 성공");
                        }
            }
            static boolean enoughSpace() {
                        // 설치에 필요한 공간이 있는지 확인
                        // true 혹은 false로 변경해서 결과 학인해보기
                        return true;
            }

            static boolean enoughMemory() {
                        // 설치에 필요한 메모리가 있는지 확인
                        // true 혹은 false로 변경해서 결과 확인해보기
                        return true;
            }

            static void copyFiles() { /* 파일을 복사하는 코드를 적는다. */ }
            static void deleteTempFiles() { /* 임시파일들을 삭제하는 코드를 적는다. */ }

            static void  startInstall() throws SpaceException, MemoryException{
                        if(!enoughSpace()) {
                                    throw new SpaceException("설치할 공간이 부족합니다.");
                        }
                        if(!enoughMemory()) {
                                    throw new MemoryException("메모리가 부족합니다.");
                        }
            }
}

// 사용자 정의 예외 클래스
class SpaceException extends Exception{ // 공간이 부족할 때 처리하는 예외 클래스
            public SpaceException(String msg) {
                        super(msg);
            }
}

class MemoryException extends Exception{ // 메모리가 부족할 때 처리하는 예외 클래스
            public MemoryException(String msg) {
                        super(msg);
            }
}