Java 문법 - Inner 클래스, 예외처리

Java Inner Class, Exception 처리

다양한 위치에서 Class 사용해보기

public class OuterClass {
    int a = 10;
    static int b = 20;
 
    void print(){ System.out.println("instance 메소드 : " + (a+b));    }
 
    static void print2(){ System.out.println("class 메소드 : " + b);   }
 
    class InnerClass1{ //instance 메소드와 변수만 사용할 수 있다.
        int c = 10;
        //static int d = 20; //class 변수 불가
        void print3(){
            System.out.println("instance 메소드 : " + (a+b));
        }
 
        /*static void print4(){ // class 메소드 불가하다.
            System.out.println("class 메소드 : " + (a+b));
        }*/
    }
 
    static class InnerClass2{
        int d = 40;
        static int e = 50;
 
        void print4(){ System.out.println("instance 메소드 : " + (d+e));  }
 
        static void print5(){ System.out.println("instance 메소드 : " + e); }
    }
 
    //7버전은 지역변수 앞에 final를 붙여 상수임을 명시해야한다.
    //8버전은 final 생략이 가능하다.
    void show(String msg){ //메소드 안에서 정의된 클래스는 '로컬 클래스'이다.
        String name = "ㅇㄱㅅ";
 
        //local class
        //로컬 클래스 경우 지역변수는 반드시 상수여야한다.
    //함수 안에서만 생성 할 수 있다.
        //내부 클래스에서 사용하는 변수는 final만 가능
        class InnerClass3{
            int i = 10;
            void print6(){
                System.out.println(i);
                System.out.println(name); //상수만 사용이 가능하다.
                System.out.println(msg);
            }
 
        }
        InnerClass3 inner = new InnerClass3();
        System.out.println("inner.i : " + inner.i);
        inner.print6();
    }
}

public class InnerClassTest {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        System.out.println(outer.a); //객체변수(instance 변수)
        System.out.println(OuterClass.b); //클래스 변수(static 변수)
        outer.print(); //instatnce 메소드
        OuterClass.print2(); //class 메소드
 
        OuterClass.InnerClass1 inner1 = outer.new InnerClass1();
        System.out.println(inner1.c); //instance 변수
        inner1.print3(); //instance 메소드
 
        OuterClass.InnerClass2 inner2 = new OuterClass.InnerClass2();
        System.out.println(inner2.d);
        System.out.println(OuterClass.InnerClass2.e); //class 변수
        inner2.print4(); //instance 메소드
        OuterClass.InnerClass2.print5(); //class 메소드
 
        //Local Class Test
        outer.show("점심시간");
    }
}

익명 클래스 사용

• 상속을 통해 재정의 하는 과정을 피하기 위함

public class AnonymousClass {
 
    public static void main(String[] args) {
        MyClass a = new Child();
        a.print();
 
        MyClass b = new MyClass(){
            //재정의 할 수 있는 구역 -> 익명 클래스
            public void print(){
                System.out.println("재정의된 3 print 메소드");
            }
        };
        b.print();
        method(new MyClass(){
            //익명 클래스를 바로 정의할 수 있다.
            public void print(){
                System.out.println("재정의된 4 print 메소드");
            }
        }); //재정의된 메소드가 실행됨
    }
    public static void method(MyClass my){
        my.print();
    }
}
 
class MyClass{
    void print(){
        System.out.println("부모 클래스 함수");
    }
}
class Child extends MyClass{
    void print(){
        System.out.println("재정의된1 함수 호출");
    }
}
class Child2 extends MyClass{
    void print(){
        System.out.println("재정의된2 함수 호출");
    }
}

예외처리하는 이유

• 예외처리와 비지니스 로직을 분리하기 위해 수행

Exception 처리 방법

1. 직접 처리하는 방법

try {
  //Exception 발생 가능성 있는 문장
} catch(Exception e){
  //Exception 발생 시 수행
} finally {
  //error 상관없이 반드시 수행되는 문장 -> 정상 동작
}
//정상 동작

2. 떠넘기는 방법

• 나를 호출한 메서드로 떠넘긴다.

• 함수 선언 부에 Throws Exception 사용하여 에러를 떠넘긴다.

• 함수 호출한 부분에서 error를 예외처리 한다.

void method() throws Exception{
   // ~~~
}
==========================================
try {
  method();
} catch(Exception e){
 
}