분류

[static] : 바깥 클래스와 관련 없음, 인스턴스에 소속되지 않음

• static nested class

[non-static] : 바깥 클래스의 인스턴스에 소속, 구성요소

• inner class
• local class (inner + localVar에 접근)
• anonymous class (local + class에 이름이 없음)

주의점

같은 시그니처인 method

• inner class의 method가 불림
• outer class의 method를 사용할 수 없고, 새로 정의해야 함

public class OuterClass {
    private int outerValue = 10;

    // 외부 클래스의 메서드
    public void display() {
        System.out.println("Outer class display method. outerValue: " + outerValue);
    }

    public class InnerClass {
        private int innerValue = 5;

        // 내부 클래스의 메서드
        public void display() {
            System.out.println("Inner class display method. innerValue: " + innerValue);

            // 외부 클래스의 메서드를 호출
            OuterClass.this.display();
        }

        public void invokeOuterDisplay() {
            // 외부 클래스의 display 메서드를 호출하는 방법
            OuterClass.this.display();
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();

        // 내부 클래스의 display 메서드 호출
        inner.display();

        // 내부 클래스에서 외부 클래스의 display 메서드 호출
        inner.invokeOuterDisplay();
    }
}

Outer class 어디에 정의해도 무관

주로 helping class로 사용 (private으로 해야함)

inner, outer private 멤버는 서로 접근 가능

public class OuterClass {
    private int outerValue = 10;

    // 외부 클래스의 private 메서드
    private void outerPrivateMethod() {
        System.out.println("Outer class private method.");
    }

    public class InnerClass {
        private int innerValue = 5;

        // 내부 클래스의 private 메서드
        private void innerPrivateMethod() {
            System.out.println("Inner class private method.");
        }

        // 내부 클래스의 메서드
        public void innerMethod() {
            // 외부 클래스의 private 인스턴스 변수 참조
            System.out.println("Accessing outer class private variable: " + outerValue);

            // 외부 클래스의 private 메서드 호출
            outerPrivateMethod();
        }
    }

    // 외부 클래스의 메서드
    public void outerMethod() {
        InnerClass inner = new InnerClass();

        // 내부 클래스의 private 인스턴스 변수 참조
        System.out.println("Accessing inner class private variable: " + inner.innerValue);

        // 내부 클래스의 private 메서드 호출
        inner.innerPrivateMethod();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();

        // 내부 클래스의 메서드 호출
        inner.innerMethod();

        // 외부 클래스의 메서드 호출
        outer.outerMethod();
    }
}

compile시 두개가 별도의 .class파일로 생성됨

• ClassName.class
• ClassName$InnerClassName.class

상속과 nested class

outer class를 상속받은 class

• nested class를 가지게 됨
• outer class의 해당 nested class를 override할 수는 없음

inner class, outer class 모두 다른 클래스를 상속받을 수 있음

---

static nested class

static

outer class의 instance member 접근 불가
outer class의 class member 접근 가능

사용하는 상황

outer class의 static method에 static nested class의 객체를 이용할 때

static nested class가 static 멤버를 가져야 할 때

public class NestedOuter {  
  
    private static int outClassValue = 3;  
    private int outInstanceValue = 2;  
  
    static class Nested {  
        private int nestedInstanceValue = 1;  
  
        public void print() {  
            // 자신의 멤버에 접근  
            System.out.println(nestedInstanceValue);  
  
            // 바깥 클래스의 인스턴스 멤버에 접근에는 접근할 수 없다.  
            //System.out.println(outInstanceValue);  
            // 바깥 클래스의 클래스 멤버에는 접근할 수 있다. private도 접근 가능  
            System.out.println(NestedOuter.outClassValue); 
        }  
    }  
}
-----------------------------------------------------------
package nested.nested;  
  
public class NestedOuterMain {  
  
    public static void main(String[] args) {  
        Nested.StaticNestedClass nested = new Nested.StaticNestedClass();
        nested.print();  
  
        System.out.println("nestedClass = " + nested.getClass());  
    }  
}

(public) Inner class

정의

outer class의 instance 멤버에 직접 접근 가능

⟹ inner class 내부에서만 사용할 멤버를 public으로 만들 필요가 없음

inner class는 outer class를 reference함.

public class OuterClass {
    private int outerValue = 10;

    // Public method를 통해 내부 클래스의 메서드를 호출
    public void doSomething() {
        InnerClass inner = new InnerClass();
        inner.innerMethod();
    }

    // 내부 클래스
    private class InnerClass {
        // 외부 클래스의 메서드를 호출하여 특정 작업을 수행
        private void innerMethod() {
            System.out.println("Inner method is accessing outerValue: " + outerValue);
            helperMethod(); // 외부 클래스의 private 메서드 호출
        }
    }

    // 외부 클래스의 private 메서드; 이걸 public으로 안해도 됨
    private void helperMethod() {
        System.out.println("Helper method is doing some work.");
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.doSomething();
    }
}

anonymous class

사용

보통 인터페이스나 추상 클래스를 구현하거나 확장하기 위해 사용됨

interface Greet {
    void sayHello();
}

public class AnonymousClassExample {
    public static void main(String[] args) {
        // Greet 인터페이스를 구현하는 익명 클래스
        Greet greeter = new Greet() {
            @Override
            public void sayHello() {
                System.out.println("Hello from anonymous class!");
            }
        };

        // 익명 클래스 메서드 호출
        greeter.sayHello();

        // 또 다른 예제: 여러 메서드를 가진 사용자 정의 클래스를 확장한 익명 클래스
        GreeterClass greeterClass = new GreeterClass() {
            @Override
            public void greet() {
                System.out.println("Greetings from extended anonymous class!");
            }
        };

        greeterClass.greet();
        greeterClass.sayGoodbye();
    }
}

// 또 다른 사용자 정의 클래스
class GreeterClass {
    public void greet() {
        System.out.println("Hello from GreeterClass!");
    }

    public void sayGoodbye() {
        System.out.println("Goodbye from GreeterClass!");
    }
}