[Java] 중첩 클래스

 

 

중첩 클래스는 클래스 내부에 선언한 클래스를 말하며 중첩 클래스를 사용하면 두 클래스의 멤버들을 서로 쉽게 접근할 수 있고, 외부에는 불필요한 관계 클래스를 감춤으로써 코드의 복잡성을 줄일 수 있다는 장점이 있다.

class ClassName{
    class Name{ // 중첩 클래스
    }
}

 

 

인터페이스도 클래스 내부에 선언할 수 있는데, 이런 인테페이스를 중첩 인터페이스라고 한다. 인터페이스를 클래스 내부에 선언하는 이유는 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들 수 있기 때문이다.

class ClassName{
    interface Name{ // 중첩 인터페이스
    }
}

 

 

---

 

 

내부 클래스(Inner Class)

내부 클래스는 static 키워드 없이 중첩 선언된 클래스를 말하며, 클래스 또는 메소드 안에 또 다른 클래스를 만드는 것으로 인스턴스 필드와 메소드만 선언이 가능하고 정적 필드와 메소드는 선언할 수 없다.

class OuterClass {
    private int num1 = 10;

    public void method1() {
        System.out.println("num1 : " + num1);
    }

    class InnerClass {  // innerClass 생성
        private int num2 = 20;

        public void method2() {
            System.out.println("InnerClass.num1 : " + num1);
            // InnerClass.num1 : 10
            System.out.println("InnerClass.num1 : " + num2);
            // InnerClass.num1 : 20
        }
    }

    public void printInner() {
        InnerClass innerClass = new InnerClass();
        innerClass.method2();
    }
}

public class InnerClass {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.method1();  // num1 : 10
        outerClass.printInner();
        System.out.println();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        // innerClass 선언 방법
        innerClass.method2();
    }
}


/* 실행결과
num1 : 10
InnerClass.num1 : 10
InnerClass.num1 : 20

InnerClass.num1 : 10
InnerClass.num1 : 20
*/

 

 

로컬 클래스(Local Class)

중첩 클래스를 메소드 내에서도 선언할 수 있는데, 이것을 로컬클래스라고 함. 로컬 클래스는 접근 제한자 및 static를 붙일 수 없고 로컬 클래스 내부에는 인스턴스 필드와 메소드만 선언할 수 있고 정적 필드와 메소드는 선언할 수 없다. 지역 변수는 접근 할 수 없지만, final로 선언된 상수는 접근 가능하다.

public class LocalClass {
    private int num1 = 10;

    public void method1() { // 3번. 메소드 내
        int num2 = 20;

        class Local { // 로컬 클래스 생성
            private int num3 = 30;  // 인스턴스 필드

            public void method2() {  // 6. 인스턴스 메소드
                System.out.println("num1 : " + num1); // num1 : 10
                System.out.println("num2 : " + num2); // num1 : 20
                System.out.println("num3 : " + num3); // num1 : 30
            }
        }
        Local local = new Local(); // 4. 로컬 클래스 객체 선언
        local.method2(); // 5. method2() 호출
        local.num3 = 10;
    }

    public static void main(String[] args) {
        LocalClass localClass = new LocalClass(); // 1. 객체 선언
        localClass.method1();  // 2번. method1() 호출
    }
}


/* 실행결과
num1 : 10
num2 : 20
num3 : 30
*/

 

 

Static 클래스

static 클래스는 static 키워드로 선언된 클래스를 의미하며, 모든 종류의 필드와 메소드를 선언할 수 있고 외부 클래스에 관계없이 객체를 생성할 수 있다.

public class StaticClass {
    static class Static{  // static 클래스 생성
        int num = 0;  // 인스턴스 필드
        public void plus(){ // 3. 인스턴스 메소드
            num++;
        }
    }

    public static void main(String[] args) {
       StaticClass.Static Static = new StaticClass.Static(); 
        // 1. static 클래스 객체 생성
       Static.plus();  // 2. 메소드 호출
       System.out.println(Static.num); // 4. 1
    }
}


/* 실행결과
1
*/

 

 

익명 클래스(Anonymous Class)

익명 클래스는 클래스를 정의하지 않고 객체를 정의할 때 사용되며, 1회용 클래스이므로 재활용이 불가능하다.

interface Inter2{
    String method2();
}
class TestClass2 implements Inter2 {
    public String method2(){
        return "실명 클래스";
    }
}
class TestClass3{
    public void method3(Inter2 inter2){     
    // 인터페이스인 Inter2를 구현한 객체(TestClass2)만 진입 가능
        System.out.println(inter2.method2());
    }
}
public class Anonymous {
    public static void main(String[] args) {
        TestClass2 testClass2 = new TestClass2();
        TestClass3 testClass3 = new TestClass3();
        testClass3.method3(testClass2);

        testClass3.method3(new TestClass2(){
        // 참조변수 없이 직접 구현하는 방법
            @Override
            public String method2() {
                return "익명객체";
            }
        });
    }
}


/* 실행결과
실명 클래스
익명객체
*/