[Java] 내부 클래스(Inner class)에 대해

내부 클래스는 무엇인가?

내부 클래스(Inner class)는 클래스 내부에 선언된 또 다른 클래스를 말합니다.

public class Outer {

    private String OuterA;
    private String OuterB;

    public class Inner {
        private String innerA;
        private String innerB;
    }
    
}

• 이너 클래스에서는 인스턴스 멤버에 접근할 수 있습니다. (static inner class는 인스턴스 멤버에 접근 불가능)

---

내부 클래스 언제 사용할까?

1. 두 클래스가 긴밀한 관계에 있을 때 클래스 내에 클래스를 선언하곤 합니다. 
2. 하나의  클래스 또는 메소드에서만 사용되는 클래스를 사용하고 싶을 때 내부 클래스를 사용합니다.

GUI 애플리케이션의 이벤트 처리 외에는 잘 사용하지 않기 때문에, 우선 내부 클래스의 사용법과 특징 정도만 가볍게 알아보겠습니다.

 

---

내부 클래스의 장점

1. 접근 제어자를 타이트하게 잡아도 같은 패키지, 같은 클래스 level에 있기 때문에 두 클래스의 멤버들 간 서로 쉽게 접근할 수 있습니다.
   
   1. 같은 패키지/클래스에서 읽을 수 있어, 시각적으로 가독성이 높고 유지보수에 있어서도 이점을 가지게 됩니다.
2. 외부적으로 불필요한 클래스를 감춤으로, 코드의 복잡성을 줄일 수 있습니다. (캡슐화, 은닉화)

 

내부에 정의된다는 점을 제외하면 일반적인 클래스와 다른 점은 없습니다. 우리가 어느 클래스에 변수나 상수가 필요하면 클래스 멤버로서 클래스 내에서 선언하고 사용한 것처럼, 선언 주체를 변수에서 클래스로 바꾼것이 내부 클래스라고 보시면 됩니다.

 

---

내부 클래스 종류

클래스의 멤버 변수도 선언되는 위치, 접근 제어자에 따라 역할과 이름이 달라지듯이, 내부 클래스도 똑같습니다.

내부 클래스 종류	특징
내부 인스턴스 클래스 ( instance Class )	외부 클래스의 멤버변수 선언위치에 선언되며, 외부 클래스의 인스턴스 멤버 처럼 다루어집니다.  - 외부 클래스의 인스턴스 멤버들과 관련된 작업에 사용될 목적으로 선언됩니다.
내부 스태틱 클래스 ( static class )	외부 클래스의 멤버변수 선언 위치에 선언하며, 외부 클래스의 static 멤버처럼 다루어 집니다.  - 주로 외부 클래스의 static 멤버와 관련된 작업에 사용될 목적으로 선언됩니다. - 다만 static 이라고 해서, new 생성자 초기화를 못하는 것은 아니다. - 일반적인 static 필드나, static 메소드와 달리 내부 static 클래스는 같은 static이지만, 외부 클래스의 인스턴스 없이도 직접 생성할 수 있습니다. - 즉, 내부 클래스의 인스턴스와는 다르게 Inner static class의 인스턴스는 외부 클래스의 인스턴스와 독립적으로 메모리에 존재합니다.
내부 로컬 클래스 ( local class )	외부 클래스의 메소드나 초기화 블록 안에 선언하여, 선언된 블록 안에서만 사용 할 수 있습니다.
내부 익명 클래스 ( anonymous class )	클래스의 선언, 인스턴스의 생성을 동시에 하는 이름없는 클래스 - 주로 클래스를 일회용으로 사용할 때 자주 이용됩니다.

public class Outer {
    
    class InstanceClass{} // 내부 인스턴스 클래스
    
    static class StaticClass{} // 내부 스태틱 클래스
    
    void method() {
        class LocalClass{}  // 내부 로컬 클래스
    }
}

---

내부 인스턴스 클래스 ( Inner Instace class ) 

• 클래스의 멤버 변수 선언부에 위치하고, static 키워드가 없는 클래스
• 외부 클래스의 멤버로 취급되므로, 외부 클래스의 인스턴스를 먼저 생성하고 난 뒤, 내부 클래스의 인스턴스를 생성할 수 있습니다.
• 내부 인스턴스 클래스 내부에는 static 멤버 선언이 불가능합니다.
  • 하지만 상수인 static final은 가능하다는 점 
• 주로 외부 클래스의 멤버들과 관련된 작업에 사용될 목적으로 선언합니다.
• 클래스 안의 클래스 형태이므로 컴파일 시 "외부클래스$내부클래스.class" 형태로 생성됩니다.

public class Bag {

    private String name;
    private Long price;


    public Bag(String name, Long price) {
        this.name = name;
        this.price = price;
    }

    class Pouch {
        private String pouchName;
        private String color;

//        static int k = 5; // static 멤버 사용 불가
        static final int cost = 5000; // 하지만 상수인 final static은 사용 가능

        public void printMember() {
            System.out.println("name = " + name); // 외부 클래스의 멤버에 접근 가능 ( private 여도 같은 클래스 내에서 접근하므로 ok )
            System.out.println("price = " + price); // 외부 클래스의 멤버에 접근 가능 ( private 여도 같은 클래스 내에서 접근하므로 ok )

            System.out.println("pouchName = " + pouchName); // 내부 클래스의 멤버
            System.out.println("color = " + color); // 내부 클래스의 멤버
        }
    }
}

 

외부 클래스가 인스턴스화 ▶︎ 외부 클래스가 메모리에 적재 ▶︎ 내부 클래스의 코드도 메모리에 적재

public static void main(String[] args) {
    Bag b = new Bag("bagPack", 500000L); // 외부 클래스 인스턴스 생성 -> 외부 클래스가 메모리에 적재 -> 내부 클래스의 코드도 메모리에 적재 
    Bag.Pouch p = b.new Pouch("pouch1", "white"); // 내부 클래스의 인스턴스 생성 가능
    
    // 위 두줄을 한 줄로 표현할 수 있습니다 (가독성은 좋지 않음)
    Bag.Pouch p2 = new Bag("backPack2", 300000L).new Pouch("pouch2", "red");
    
}

내부 클래스의 코드가 메모리에 적재된 이후(외부 클래스의 인스턴스가 생성되고 난 후)에야 내부 클래스의 인스턴스를 생성할 수 있습니다.

하지만 내부 클래스는 다른 클래스에서 인스턴스를 만들어서 직접 사용하기보다, 외부 클래스에서 멤버처럼 사용하는 것이 일반적이며 위와 같이 내부 클래스의 인스턴스를 직접 사용하는 경우는 드뭅니다.

 

 

외부 클래스의 메소드명 = 내부 클래스의 메소드명일 때 외부 클래스의 메소드를 호출하기

• 상속 관계일 때는 super 키워드로 가능. But 외/내부 클래스 관계는 상속관계가 X

public class Parent {
    public void print() {
        System.out.println("PARENT");
    }
}

public class Child extends Parent{
    public void print() {
        super.print();
    }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Parent();
        p.print();

        Child c = new Child();
        c.print();
    }
}

실행 결과 PARENT PARENT

• 상속 관계에서는 메소드명이 같은 경우 'super' 키워드로 부모 메소드의 메소드를 호출할 수 있습니다. 

 

하지만 외부-내부 클래스의 관계는 상속 관계가 아니기 때문에 super 키워드를 이용한 부모 메소드 호출이 불가능합니다.

외부/내부 클래스에서는 이럴 때 정규화된 this를 사용하면 바깥 인스턴스의 메소드를 호출하거나 참조할 수 있습니다.

 

정규화 된 this란 "클래스명.this" 형태로 바깥 클래스의 이름을 명시하는 용법

public class Outer1 {

    public void print(String s) {
        System.out.println("외부 클래스의 print method 실행 결과 " + s);
    }

    class Inner1 {
        public void print(String s) {
//            System.out.println("내부 클래스의 print method 실행 결과 " + s);
            Outer1.this.print(s);
        }
    }
}

---

내부 로컬 클래스 ( Inner local class )

• 메소드 내부에 위치하는 클래스로 지역 변수와 마찬가지로 메소드 내부 블록에서만 한정적으로 사용됩니다.
• 마찬가지로 static inner class 가 아니기 때문에 static 멤버는 사용할 수 없지만, 상수 static final은 사용할 수 있습니다.
• 메소드가 실행될 때 사용되고 실행을 마치면 사라지는 지역 변수처럼 지역 클래스 자료형을 사용하고 버리는 느낌이라고 보시면 됩니다.
• 내부 지역 클래스는 컴파일 시 "외부클래스$1내부클래스.class"로 생성됩니다.

 

public class Bag {

    private String name;
    public Bag(String name) {
        this.name = name;
    }

    public void method() {

        class Pouch {
            private String color = "RED";
            //            static int k = 5; // static 멤버 사용 불가
            static final int cost = 5000; // 하지만 상수인 final static은 사용 가능


            public void printMember() {
                System.out.println("name = " + name); // 외부 클래스의 멤버에 접근 가능 ( private 여도 같은 클래스 내에서 접근하므로 ok )
                System.out.println("color = " + color); // 내부 클래스의 멤버
            }
        }

        new Pouch().printMember();
    }
}

public class Main {
    public static void main(String[] args) {
        Bag b = new Bag("BAG1");
        b.method();
    }
}

실행 결과 name = BAG1 color = RED

 

• 내부 지역 클래스는 지역 변수와 마찬가지로 Stack 영역에 저장되었다가 메소드가 종료되면 사라지므로 다른 곳에서 접근 및 사용자체가 불가능합니다. 오직 외부 클래스 인스턴스의 메소드 호출을 통해서만 접근/실행 가능.

 

+Tip) 내부 로컬 클래스에서는 같은 블럭 내의 지역 변수에 접근해서 값을 사용하려면 final 키워드가 붙어있어야 합니다.

public void method() {
    int k = 1;
    k = 4;

    class Pouch {
        private String color = "RED";
        //            static int k = 5; // static 멤버 사용 불가
        static final int cost = 5000; // 하지만 상수인 final static은 사용 가능


        public void printMember() {
            System.out.println("name = " + name); // 외부 클래스의 멤버에 접근 가능 ( private 여도 같은 클래스 내에서 접근하므로 ok )
            System.out.println("color = " + color); // 내부 클래스의 멤버
            System.out.println(k); // 컴파일 에러 
        }
    }

    new Pouch().printMember();
}

• 값을 변경하게 되면 컴파일 에러가 발생하는 것을 확인할 수 있습니다. 

JDK 1.8 ver 이후로는 지역 클래스에서 접근하는 지역 변수 앞에 컴파일러가 자동으로 final 키워드를 붙여주므로 아래와 같이 final 키워드를 생략할 수 있습니다.

public void method() {
    int k = 1; // 컴파일러가 자동으로 final을 붙여줍니다. 
    class Pouch {
        private String color = "RED";
        //            static int k = 5; // static 멤버 사용 불가
        static final int cost = 5000; // 하지만 상수인 final static은 사용 가능


        public void printMember() {
            System.out.println("name = " + name); // 외부 클래스의 멤버에 접근 가능 ( private 여도 같은 클래스 내에서 접근하므로 ok )
            System.out.println("color = " + color); // 내부 클래스의 멤버
            System.out.println(k);  
        }
    }

    new Pouch().printMember();
}

실행 결과 name = BAG1 color = RED 1

 

---

내부 스태틱 클래스 ( Inner static class )

• static 키워드가 붙은 내부 클래스로, 일반적인 클래스는 static이 불가능하지만 내부 클래스는 static 선언이 가능
• 일반적인 static 필드와, static 메소드와 달리 static class 내부에는 instance 멤버와 static 멤버 모두 선언할 수 있습니다.
  • 하지만 일반적인 static 메소드가 instance 멤버에 접근할 수 없듯이, 내부 static 클래스또한 외부 클래스의 instance 멤버에는 접근이 불가능하고, 외부 클래스의 static 멤버에만 접근이 가능합니다.
• static -> static (O)
• static -> instance (X)
• instance -> instance (O)
• instance -> static (O)
• 컴파일 시 인스턴스 내부 클래스와 동일하게 "외부클래스$내부클래스.class"로 생성됩니다.

public class Outer {
    int a = 1; // instane 멤버
    static int a2 = 3; // static 멤버
    static int a3 = new Inner().b; // static 멤버끼리는 접근 가능


    void print() { // instance 멤버 -> static 멤버 접근 가능
        a3 = 4;
        System.out.println(a3);
    }
    static class Inner {
        int b = 1; // instance 멤버

        static void print() {
//            System.out.println(b); // static 멤버 -> instance 멤버 접근 불가능
//            System.out.println(a); // static 멤버 -> instance 멤버 접근 불가능
            System.out.println(a2); // static 멤버 -> static 멤버 접근 가능
        }
    }
}

 

---

익명 클래스 ( Anonymous class )

• 익명 클래스는 이름이 존재하지 않는 이너 클래스.
• 클래스의 선언, 인스턴스의 생성이 동시에 이루어지는 일회용 클래스입니다.
• 생성자가 존재하지 X
• 기존에 존재하는 클래스를 메소드 내에서 일회용으로 내부 구성을 선언하여 필요한 메소드를 재정의하여 사용하는 기법
• 컴파일 시 "외부클래스$1.class", "외부클래스$2.class" 로 이름이 없기 때문에 아라비아 숫자만 표기하여 구분합니다.

public class Main {
    public static void main(String[] args) {
        Object o = new Object(){
            @Override
            public String toString() {
                return "HI!";
            }
        };

        System.out.println(o.toString());
    }
}

> 기존 자바에 있는 클래스인 Object의 toString 메소드를 오버라이딩하여 일회성으로 사용

public interface Printable {
    void print();
}

public class Main {
    public static void main(String[] args) {
        Printable a = new Printable() {
            @Override
            public void print() {
                System.out.println("HI");
            }
        };
        
        a.print();
    }
}

> 위와 같이 인터페이스를 구현하여 일회용으로 사용하는 것도 가능합니다.

---

<참고 자료>

 

내부 클래스 (Inner Class)

☕ 내부 클래스(Inner Class) 장점 & 종류 총정리