** 📌1단계: 내부 클래스(Inner Class)란?**

✅ 1. 내부 클래스의 개념

• *내부 클래스(Inner Class)란 **다른 클래스 내부에 정의된 클래스를 의미합니다.

자바에서는 코드의 논리적인 그룹화, 캡슐화 강화, 가독성 향상을 위해 내부 클래스를 제공합니다.

내부 클래스는 외부 클래스와 강한 연관성을 가지며,

특정 클래스 내부에서만 사용되는 경우 유용하게 활용됩니다.

---

✅ 2. 내부 클래스를 사용하는 이유

왜 내부 클래스를 사용할까요?

다음과 같은 장점이 있기 때문입니다.

내부 클래스를 사용하는 이유	설명
캡슐화(Encapsulation) 강화	외부 클래스에서만 사용되도록 숨길 수 있음
코드 가독성 향상	관련된 코드들을 한 곳에 모아 유지보수 용이
외부 클래스와의 강한 결합	내부 클래스는 외부 클래스의 멤버(변수, 메서드)에 자유롭게 접근 가능
이름 충돌 방지	내부 클래스는 외부 클래스와 관련된 특정 작업에만 사용되므로, 불필요한 네이밍 충돌을 방지할 수 있음

예제 1: 내부 클래스 기본 구조

class OuterClass { // 외부 클래스
    class InnerClass { // 내부 클래스
        void display() {
            System.out.println("내부 클래스 호출!");
        }
    }
}

---

✅ 3. 내부 클래스의 주요 특징

📌 내부 클래스는 일반적인 클래스와 다르게 다음과 같은 특징을 가집니다.

1. 내부 클래스는 외부 클래스의 모든 멤버(변수, 메서드)에 접근할 수 있음
2. 내부 클래스는 외부 클래스 없이 독립적으로 존재할 수 없음
3. 내부 클래스 내부에서 this는 내부 클래스를 가리키며, OuterClass.this를 사용하면 외부 클래스를 참조 가능

예제 2: 내부 클래스에서 외부 클래스 멤버 접근하기

class Outer {
    private String message = "Hello from Outer Class!";

    class Inner {
        void printMessage() {
            System.out.println(message); // 내부 클래스에서 외부 클래스 멤버 접근 가능
        }
    }
}

---

✅ 4. 내부 클래스의 종류

자바의 내부 클래스는 4가지 종류로 구분됩니다.

내부 클래스 종류	설명	주요 특징
인스턴스 내부 클래스	외부 클래스의 객체를 생성한 후에만 사용 가능	외부 클래스의 멤버 변수 & 메서드에 접근 가능
정적(static) 내부 클래스	외부 클래스의 인스턴스 없이 사용 가능	static 키워드를 사용하며, 외부 클래스의 static 멤버만 접근 가능
지역(Local) 내부 클래스	특정 메서드 내부에서만 선언 & 사용 가능	메서드가 끝나면 함께 소멸됨
익명(Anonymous) 내부 클래스	이름이 없는 일회성 클래스	주로 인터페이스 또는 추상 클래스 구현에 사용됨

---

✅ 5. 내부 클래스 사용 시 주의할 점

1. 내부 클래스가 불필요하게 많으면 코드가 복잡해질 수 있음
2. 메모리 누수를 방지하기 위해 내부 클래스의 라이프사이클을 고려해야 함
3. static 내부 클래스와 일반 내부 클래스의 차이를 반드시 이해해야 함

---

📌 1단계 정리

✅ 내부 클래스는 클래스 내부에서 정의된 또 다른 클래스이다.

✅ 코드 가독성과 캡슐화를 강화하는 역할을 한다.

✅ 내부 클래스는 외부 클래스의 멤버(변수, 메서드)에 자유롭게 접근할 수 있다.

✅ 내부 클래스는 크게 4가지 종류(인스턴스, 정적, 지역, 익명)로 나뉜다.

이제 2단계에서는 내부 클래스의 구체적인 종류와 사용법을 학습합니다. 🚀

📌 2단계: 내부 클래스의 종류와 사용법

자바의 내부 클래스는 4가지 종류로 나뉘며, 각각의 특징과 사용법이 다릅니다.

이 단계에서는 각 내부 클래스의 개념, 특징, 코드 예제를 통해 차이점을 명확히 이해합니다.

---

✅ 1. 인스턴스 내부 클래스 (Instance Inner Class)

“외부 클래스의 인스턴스를 생성해야 사용할 수 있는 내부 클래스”

📌 특징

• 외부 클래스의 모든 멤버(변수, 메서드)에 접근 가능
• 외부 클래스의 객체가 먼저 생성되어야 사용 가능
• 보통 외부 클래스의 기능을 보조하는 역할

📌 코드 예제

class OuterClass {
    private String message = "Hello from Outer!";

    // 📌 인스턴스 내부 클래스
    class InnerClass {
        void display() {
            System.out.println(message); // 외부 클래스의 private 멤버 접근 가능
        }
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass(); // 외부 클래스 객체 생성
        OuterClass.InnerClass inner = outer.new InnerClass(); // 내부 클래스 객체 생성
        inner.display(); // 출력: Hello from Outer!
    }
}

---

✅ 2. 정적(static) 내부 클래스 (Static Inner Class)

“외부 클래스의 인스턴스 없이도 사용 가능한 내부 클래스”

📌 특징

• static 키워드를 사용하여 선언
• 외부 클래스의 인스턴스가 필요 없음
• 외부 클래스의 static 멤버만 접근 가능
• 주로 외부 클래스와 강하게 결합되지 않은 독립적인 유틸리티 역할

📌 코드 예제

class OuterClass {
    private static String staticMessage = "Hello from Static Inner!";

    // 📌 정적 내부 클래스
    static class StaticInner {
        void display() {
            System.out.println(staticMessage); // static 멤버 접근 가능
        }
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass.StaticInner inner = new OuterClass.StaticInner(); // 직접 생성 가능
        inner.display(); // 출력: Hello from Static Inner!
    }
}

---

✅ 3. 지역(Local) 내부 클래스

“메서드 내부에서 선언되며, 해당 메서드가 실행될 때만 존재하는 클래스”

📌 특징

• 특정 메서드 안에서만 선언 & 사용 가능
• 메서드 실행이 끝나면 지역 내부 클래스도 사라짐
• 외부 클래스의 멤버 변수 & 메서드에 접근 가능하지만, 메서드의 final 지역 변수만 접근 가능(Java 8부터는 암묵적 final 허용)

📌 코드 예제

class OuterClass {
    void outerMethod() {
        int localVar = 100; // Java 8 이후 암묵적으로 final

        // 📌 지역 내부 클래스 (메서드 내부에서만 사용됨)
        class LocalInner {
            void display() {
                System.out.println("Local variable: " + localVar);
            }
        }

        LocalInner localInner = new LocalInner();
        localInner.display(); // 출력: Local variable: 100
    }
}

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

---

✅ 4. 익명(Anonymous) 내부 클래스

“이름 없이 한 번만 사용되는 클래스”

📌 특징

• 클래스 선언과 객체 생성을 동시에 수행
• 일반적으로 인터페이스나 추상 클래스의 구현에 사용됨
• 오직 한 번만 사용할 클래스일 경우 유용함

📌 코드 예제 (인터페이스 구현 예시)

interface Greeting {
    void sayHello();
}

public class Main {
    public static void main(String[] args) {
        // 📌 익명 내부 클래스 사용 (인터페이스 구현)
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello from Anonymous Inner Class!");
            }
        };

        greeting.sayHello(); // 출력: Hello from Anonymous Inner Class!
    }
}

---

📌 2단계 정리

내부 클래스 종류	특징	사용 예시
인스턴스 내부 클래스	외부 클래스의 인스턴스가 필요	외부 클래스의 멤버에 접근 가능
정적(static) 내부 클래스	외부 클래스의 인스턴스 없이 사용 가능	static 멤버만 접근 가능
지역(Local) 내부 클래스	특정 메서드 내에서만 선언 & 사용	메서드 종료 시 함께 소멸
익명(Anonymous) 내부 클래스	이름 없이 한 번만 사용되는 클래스	인터페이스 또는 추상 클래스 구현

---

##

📌 3단계: 내부 클래스의 메모리 구조 & this, super 키워드 활용

내부 클래스는 외부 클래스와 강하게 연결되어 있기 때문에

메모리 구조와 this, super 키워드를 이해하는 것이 중요합니다.

이 단계에서는 메모리에서 내부 클래스가 어떻게 동작하는지

그리고 this, super 키워드를 사용하여 외부 클래스와 내부 클래스를 구분하는 방법을 배웁니다.

---

✅ 1. 내부 클래스의 메모리 구조 (Heap & Stack)

자바에서 객체는 힙(Heap)과 스택(Stack)에 저장됩니다.

내부 클래스가 어떻게 메모리에 배치되는지 살펴보겠습니다.

📌 메모리 구조 개념

1. 외부 클래스(OuterClass)는 힙(Heap) 영역에 저장됨
2. 내부 클래스(InnerClass)도 힙(Heap) 영역에 저장됨
3. 내부 클래스는 외부 클래스의 참조를 암묵적으로 포함하고 있음
4. 지역(Local) 내부 클래스와 익명(Anonymous) 내부 클래스는 메서드 실행 시 생성되며, 종료 시 소멸됨

---

✅ 2. 내부 클래스 메모리 구조 예제

다음 코드에서 외부 클래스와 내부 클래스가 메모리에 어떻게 저장되는지 분석해보겠습니다.

class Outer {
    private String message = "Hello from Outer!";

    class Inner {
        void display() {
            System.out.println(message);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer(); // 힙(Heap)에 저장됨
        Outer.Inner inner = outer.new Inner(); // 힙(Heap)에 저장됨
        inner.display();
    }
}

📌 메모리 흐름

1. Outer outer = new Outer();
   • outer 객체가 힙(Heap)에 생성됨
2. Outer.Inner inner = outer.new Inner();
   • inner 객체가 힙(Heap)에 생성됨
   • 내부 클래스는 외부 클래스를 참조(Outer.this)함
3. inner.display(); 실행
   • 내부 클래스는 외부 클래스의 message 변수에 접근 가능
   • 외부 클래스 객체(Outer.this)를 암묵적으로 저장하고 있음

---

✅ 3. this 키워드를 활용한 내부 & 외부 클래스 구분

내부 클래스와 외부 클래스에는 모두 this 키워드가 존재합니다.

때때로 내부 클래스와 외부 클래스의 멤버 변수를 구분해야 할 때

다음과 같이 this를 활용할 수 있습니다.

class Outer {
    String message = "Outer Message";

    class Inner {
        String message = "Inner Message";

        void display() {
            System.out.println(message); // 내부 클래스의 message
            System.out.println(this.message); // 내부 클래스의 message
            System.out.println(Outer.this.message); // 외부 클래스의 message
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.display();
    }
}

📌 실행 결과

Inner Message
Inner Message
Outer Message

💡 핵심 포인트

• this.message → 내부 클래스의 멤버 변수
• Outer.this.message → 외부 클래스의 멤버 변수

---

✅ 4. super 키워드를 활용한 상속 관계에서의 내부 클래스 접근

내부 클래스가 외부 클래스를 상속받을 경우,

super 키워드를 사용하여 외부 클래스의 메서드나 변수에 접근할 수 있습니다.

📌 코드 예제

class Outer {
    void show() {
        System.out.println("Outer Class Method");
    }

    class Inner extends Outer {
        void show() {
            super.show(); // 외부 클래스의 show() 호출
            System.out.println("Inner Class Method");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.show();
    }
}

📌 실행 결과

Outer Class Method
Inner Class Method

💡 핵심 포인트

• super.show();를 사용하면 외부 클래스의 메서드를 호출 가능
• 내부 클래스가 외부 클래스를 상속받을 수도 있음

---

📌 3단계 정리

✅ 내부 클래스는 메모리에서 외부 클래스를 암묵적으로 참조하고 있음 (Outer.this 포함)

✅ this 키워드를 사용하면 내부 & 외부 클래스의 변수를 구분할 수 있음

✅ super 키워드를 사용하면 내부 클래스에서 외부 클래스의 메서드를 호출할 수 있음

✅ 내부 클래스는 외부 클래스의 모든 멤버에 접근 가능하지만, static 내부 클래스는 static 멤버만 접근 가능

📌 4단계: 내부 클래스의 실제 활용 예제

이제까지 내부 클래스의 개념과 구조를 배웠다면,

이번 단계에서는 실무에서 내부 클래스가 어떻게 활용되는지 살펴봅니다.

실제 프로젝트에서 내부 클래스가 왜 유용한지, 언제 사용하면 좋은지를 이해하는 것이 목표입니다.

---

✅ 1. 내부 클래스의 주요 활용 예시

내부 클래스는 다음과 같은 경우에 유용하게 사용할 수 있습니다.

내부 클래스 활용 사례	설명
GUI 프로그래밍 (이벤트 처리)	버튼 클릭 같은 이벤트 처리를 쉽게 구현
컬렉션 클래스의 반복자 (Iterator 구현)	Iterator를 내부 클래스로 만들어 사용
캡슐화 강화 & 가독성 향상	특정 클래스 내부에서만 사용될 경우 코드 정리
멀티스레드 프로그래밍 (Runnable)	간단한 스레드를 만들 때 익명 내부 클래스로 구현

---

✅ 2. GUI 프로그래밍에서 내부 클래스 활용

“이벤트 처리를 내부 클래스로 구현하면 코드가 간결해지고 가독성이 좋아진다!”

📌 예제: 버튼 클릭 이벤트 처리

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

class GUIExample {
    private JFrame frame;
    private JButton button;

    GUIExample() {
        frame = new JFrame("내부 클래스 예제");
        button = new JButton("클릭하세요!");

        // 📌 내부 클래스 활용: 버튼 이벤트 처리
        button.addActionListener(new ButtonClickListener());

        frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }

    // 📌 인스턴스 내부 클래스: 버튼 클릭 이벤트 처리
    class ButtonClickListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("버튼이 클릭되었습니다!");
        }
    }

    public static void main(String[] args) {
        new GUIExample();
    }
}

📌 실행 결과

• 버튼을 클릭하면 “버튼이 클릭되었습니다!” 출력

💡 내부 클래스를 사용한 이유:

• ButtonClickListener가 GUIExample과 강한 연관성이 있음
• 외부에서 사용할 필요가 없는 클래스이므로 내부 클래스로 선언하여 캡슐화 강화

---

✅ 3. 컬렉션 프레임워크의 Iterator 패턴

“내부 클래스는 컬렉션 프레임워크에서도 활용된다!”

ArrayList 같은 컬렉션 클래스는 반복자(Iterator)를 내부 클래스로 구현합니다.

이유는 반복자는 컬렉션과 강한 연관성을 가지며, 외부에서 직접 접근할 필요가 없기 때문입니다.

📌 예제: 직접 Iterator 구현하기

import java.util.Iterator;

class CustomList<T> implements Iterable<T> {
    private T[] items;
    private int size;

    public CustomList(T[] items) {
        this.items = items;
        this.size = items.length;
    }

    @Override
    public Iterator<T> iterator() {
        return new CustomIterator();
    }

    // 📌 내부 클래스: 반복자 구현
    private class CustomIterator implements Iterator<T> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < size;
        }

        @Override
        public T next() {
            return items[index++];
        }
    }
}

public class Main {
    public static void main(String[] args) {
        CustomList<String> list = new CustomList<>(new String[]{"A", "B", "C"});

        for (String item : list) {
            System.out.println(item);
        }
    }
}

📌 실행 결과

A
B
C

💡 내부 클래스를 사용한 이유:

• CustomIterator는 CustomList와 강하게 연결된 기능이므로,
• 외부에서 Iterator를 직접 조작하지 않도록 내부 클래스로 구현하여 캡슐화

---

✅ 4. 멀티스레드 프로그래밍에서 익명 내부 클래스 활용

“간단한 스레드 실행을 위해 익명 내부 클래스를 사용한다!”

📌 예제: Runnable을 익명 내부 클래스로 구현

public class AnonymousThreadExample {
    public static void main(String[] args) {
        // 📌 익명 내부 클래스 활용: Runnable 구현
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("익명 내부 클래스 실행 중: " + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        thread.start();
    }
}

📌 실행 결과

익명 내부 클래스 실행 중: 1
익명 내부 클래스 실행 중: 2
익명 내부 클래스 실행 중: 3
익명 내부 클래스 실행 중: 4
익명 내부 클래스 실행 중: 5

💡 익명 내부 클래스를 사용한 이유:

• Runnable을 별도의 파일이나 클래스 없이 한 번만 사용하려고 할 때 유용
• 코드가 간결해지고 가독성이 좋아짐

---

📌 4단계 정리

✅ 내부 클래스는 실제 개발에서 자주 사용되며, 대표적인 활용 사례가 있다.

✅ GUI 프로그래밍에서는 이벤트 처리를 내부 클래스로 구현하여 코드 가독성을 높인다.

✅ 컬렉션 프레임워크에서는 Iterator를 내부 클래스로 구현하여 캡슐화를 강화한다.

✅ 멀티스레드 프로그래밍에서는 익명 내부 클래스를 사용하여 코드를 간결하게 만든다.

---

##

📌 5단계: 내부 클래스의 장점과 단점 & 실무에서의 올바른 사용법

내부 클래스는 코드의 캡슐화, 가독성 향상, 편리한 이벤트 처리 등의 장점이 있지만,

잘못 사용하면 코드 복잡도 증가, 메모리 누수 등의 문제가 발생할 수도 있습니다.

이번 단계에서는 내부 클래스의 장점과 단점을 명확히 이해하고,

실무에서 올바르게 사용하는 방법을 학습합니다. 🚀

---

✅ 1. 내부 클래스의 장점

내부 클래스를 사용하면 어떤 장점이 있을까요?

장점	설명
캡슐화(Encapsulation) 강화	특정 클래스 내부에서만 사용되는 클래스를 숨길 수 있음
코드 가독성 향상	관련된 코드를 하나의 논리적인 단위로 그룹화 가능
외부 클래스와의 강한 결합	내부 클래스는 외부 클래스의 멤버(변수, 메서드)에 자유롭게 접근 가능
이벤트 리스너 구현이 용이	GUI 프로그래밍에서 내부 클래스를 사용하면 이벤트 처리가 간결해짐
클래스 네임스페이스 관리	불필요한 클래스를 외부에 노출하지 않아 코드 정리가 쉬워짐

📌 예제: 캡슐화가 강화된 내부 클래스 사용

class BankAccount {
    private double balance = 1000.0;

    // 내부 클래스: 계좌 트랜잭션 처리
    private class Transaction {
        void withdraw(double amount) {
            if (amount <= balance) {
                balance -= amount;
                System.out.println(amount + "원이 출금되었습니다. 잔액: " + balance);
            } else {
                System.out.println("잔액이 부족합니다.");
            }
        }
    }

    public void withdrawMoney(double amount) {
        Transaction transaction = new Transaction();
        transaction.withdraw(amount);
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.withdrawMoney(500); // 500원 출금
        account.withdrawMoney(600); // 잔액 부족
    }
}

💡 내부 클래스를 사용한 이유:

• Transaction 클래스는 BankAccount에서만 사용되므로 캡슐화를 위해 내부 클래스로 선언
• 외부에서 Transaction 객체를 직접 조작하지 못하도록 숨김

---

✅ 2. 내부 클래스의 단점

하지만, 내부 클래스를 잘못 사용하면 다음과 같은 단점이 발생할 수 있습니다.

단점	설명
코드 복잡도 증가	내부 클래스가 많아지면 코드 가독성이 떨어질 수 있음
메모리 누수 위험	내부 클래스가 외부 클래스를 참조할 경우, 참조 해제가 안 되면 메모리 누수 발생 가능
테스트 및 유지보수 어려움	내부 클래스는 외부 클래스와 강하게 결합되어 있어 단위 테스트가 어렵다
클래스 크기 증가	내부 클래스가 많으면 바이트코드가 증가하여 최적화에 영향을 미칠 수 있음

📌 예제: 메모리 누수가 발생할 가능성이 있는 코드

class Outer {
    private String data = "중요한 데이터";

    class Inner {
        void showData() {
            System.out.println(data); // Outer 클래스를 참조 (메모리 누수 위험)
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.showData();
    }
}

💡 문제점:

• 내부 클래스 Inner는 외부 클래스 Outer를 암묵적으로 참조함 (Outer.this)
• 외부 클래스가 해제되지 않는 한, 내부 클래스도 GC(가비지 컬렉션)가 불가능하여 메모리 누수 가능성이 있음

✅ 해결 방법: static 내부 클래스 사용

class Outer {
    private static String data = "중요한 데이터";

    static class Inner {
        void showData() {
            System.out.println(data); // static 변수만 참조 (메모리 누수 방지)
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner(); // 외부 클래스 객체 생성 없이 사용 가능
        inner.showData();
    }
}

---

✅ 3. 실무에서 내부 클래스를 올바르게 사용하는 방법

그렇다면 내부 클래스를 언제, 어떻게 사용해야 할까요?

📌 올바른 사용 기준

✅ 내부 클래스가 외부 클래스와 강하게 결합된 경우 사용

✅ 불필요한 코드 노출을 막기 위해 내부 클래스를 활용 (캡슐화 강화)

✅ 내부 클래스가 너무 많아지면 코드 복잡도가 증가할 수 있으므로 주의

✅ 메모리 누수를 방지하기 위해 static 내부 클래스를 고려

✅ 단순한 이벤트 처리는 익명 내부 클래스를 활용하여 코드 간결화

---

📌 5단계 정리

✅ 내부 클래스는 캡슐화를 강화하고, 코드 가독성을 높이는 역할을 한다.

✅ 이벤트 처리, 컬렉션의 반복자, 멀티스레드 환경 등에서 유용하게 활용된다.

✅ 하지만 잘못 사용하면 코드 복잡도 증가 & 메모리 누수 등의 문제가 발생할 수 있다.

✅ 외부 클래스와 강하게 결합된 경우에만 내부 클래스를 사용해야 하며, 필요하지 않으면 static 내부 클래스를 고려해야 한다.

---

##

📌 6단계: 내부 클래스와 람다식(람다 표현식)의 관계

내부 클래스와 람다식(Lambda Expression) 은 매우 밀접한 관계가 있습니다.

특히 익명 내부 클래스는 람다식으로 대체될 수 있으며,

람다식을 활용하면 코드를 훨씬 간결하게 만들 수 있습니다.

이 단계에서는 익명 내부 클래스와 람다식의 차이점, 변환 과정, 장단점을 학습합니다. 🚀

---

✅ 1. 익명 내부 클래스 vs 람다식

비교 항목	익명 내부 클래스	람다식 (Lambda Expression)
코드 길이	길고 복잡함	짧고 간결함
this 키워드	익명 내부 클래스 자체를 가리킴	람다식이 포함된 외부 클래스를 가리킴
가독성	코드가 길어지면 읽기 어려움	직관적이고 간결
성능	클래스 파일이 생성됨 (클래스 로딩 필요)	바이트코드 수준에서 최적화
사용 가능 대상	인터페이스 & 추상 클래스 모두 구현 가능	인터페이스(추상 메서드가 1개)만 가능

💡 결론:

• 람다식은 오직 “함수형 인터페이스(메서드가 1개만 있는 인터페이스)”에서만 사용 가능
• 익명 내부 클래스는 여러 개의 메서드를 가진 클래스나 인터페이스를 구현할 때 필요

---

✅ 2. 익명 내부 클래스 → 람다식 변환 과정

📌 예제: 익명 내부 클래스로 Runnable 구현

public class AnonymousClassExample {
    public static void main(String[] args) {
        // 익명 내부 클래스 사용
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("익명 내부 클래스 실행!");
            }
        };
        runnable.run();
    }
}

📌 람다식으로 변환

public class LambdaExample {
    public static void main(String[] args) {
        // 람다식 사용 (더 간결해짐!)
        Runnable runnable = () -> System.out.println("람다식 실행!");
        runnable.run();
    }
}

📌 실행 결과

익명 내부 클래스 실행!
람다식 실행!

💡 변환 과정

• new 인터페이스() { ... } → () -> { ... } 로 변경
• 자동으로 @Override 처리되므로 메서드 이름을 따로 지정할 필요 없음

---

✅ 3. this 키워드 차이점

익명 내부 클래스와 람다식에서 this 키워드는 서로 다르게 동작합니다.

📌 익명 내부 클래스에서의 this

class Outer {
    String message = "Outer Class";

    void test() {
        Runnable r = new Runnable() {
            String message = "Anonymous Class";

            @Override
            public void run() {
                System.out.println(this.message); // 익명 내부 클래스의 message 출력
            }
        };
        r.run();
    }
}

public class Main {
    public static void main(String[] args) {
        new Outer().test();
    }
}

📌 실행 결과

Anonymous Class

💡 익명 내부 클래스에서는 this가 익명 클래스 자체를 가리킴

---

📌 람다식에서의 this

class Outer {
    String message = "Outer Class";

    void test() {
        Runnable r = () -> {
            System.out.println(this.message); // Outer 클래스의 message 출력
        };
        r.run();
    }
}

public class Main {
    public static void main(String[] args) {
        new Outer().test();
    }
}

📌 실행 결과

Outer Class

💡 람다식에서는 this가 외부 클래스(Outer)를 가리킴

---

✅ 4. 람다식을 사용할 수 없는 경우

람다식은 “함수형 인터페이스(추상 메서드가 1개만 있는 인터페이스)”에서만 사용할 수 있습니다.

즉, 인터페이스에 2개 이상의 메서드가 있다면 람다식을 사용할 수 없습니다.

📌 예제: 람다식을 사용할 수 없는 경우

interface MultiMethodInterface {
    void method1();
    void method2();
}

// ❌ 컴파일 오류! (람다식은 오직 하나의 메서드만 지원)
MultiMethodInterface obj = () -> System.out.println("Hello");

💡 해결 방법:

• 익명 내부 클래스를 사용해야 함
• 또는 함수형 인터페이스로 변경하여 단일 메서드만 남김

---

📌 6단계 정리

✅ 익명 내부 클래스와 람다식은 유사하지만, 람다식이 더 간결하고 최적화됨

✅ 람다식은 “함수형 인터페이스”에서만 사용 가능

✅ 익명 내부 클래스에서는 this가 익명 클래스 자신을 가리키지만, 람다식에서는 외부 클래스를 가리킴

✅ 메서드가 2개 이상인 인터페이스는 람다식으로 변환할 수 없음

---

##

📌 7단계: 내부 클래스 관련 기술 면접 질문 & 실무 최적화 방법

마지막 단계에서는 내부 클래스와 관련된 기술 면접 질문과 실무 최적화 방법을 학습합니다.

내부 클래스를 언제, 어떻게 활용하면 좋은지와 자주 묻는 면접 질문을 정리했습니다.

---

✅ 1. 내부 클래스 관련 기술 면접 질문

내부 클래스는 자바의 객체지향 개념과 캡슐화와 관련이 깊기 때문에

기술 면접에서 자주 등장하는 주제입니다.

📌 면접 질문 & 답변 예시

Q1. 내부 클래스(Inner Class)란 무엇이며, 왜 사용하나요?

✅ 답변:

내부 클래스는 클래스 내부에 정의된 또 다른 클래스입니다.

특정 클래스 내부에서만 사용되는 클래스를 만들 수 있어 캡슐화를 강화하고,

코드 가독성을 높이는 장점이 있습니다.

특히 GUI 이벤트 처리, 컬렉션 반복자(Iterator), 멀티스레드 등에서 자주 활용됩니다.

---

Q2. 내부 클래스의 종류를 설명하고 차이점을 말해주세요.

✅ 답변:

내부 클래스에는 4가지 종류가 있습니다.

1. 인스턴스 내부 클래스: 외부 클래스의 인스턴스를 통해 접근 가능
2. 정적(static) 내부 클래스: 외부 클래스의 인스턴스 없이 사용 가능 (static 멤버만 접근 가능)
3. 지역(Local) 내부 클래스: 특정 메서드 내부에서만 사용됨
4. 익명(Anonymous) 내부 클래스: 한 번만 사용되는 무명 클래스 (주로 이벤트 처리에 사용)

✅ 추가 질문:

Q: 정적 내부 클래스와 일반 내부 클래스의 차이는?

• 정적 내부 클래스는 외부 클래스의 인스턴스 없이 사용 가능
• 일반 내부 클래스는 외부 클래스의 객체가 있어야 사용 가능

---

Q3. 내부 클래스 사용 시 주의할 점은?

✅ 답변:

메모리 누수 가능성: 내부 클래스는 외부 클래스의 참조를 유지하므로,외부 클래스가 해제되지 않으면 GC(가비지 컬렉션)가 불가능하여 메모리 누수가 발생할 수 있습니다.코드 복잡도 증가: 내부 클래스를 많이 사용하면 가독성이 낮아질 수 있음.클래스 크기 증가: 내부 클래스는 바이트코드를 증가시켜 클래스 로딩 성능에 영향을 줄 수 있음.

✅ 추가 질문:

Q: 메모리 누수를 방지하는 방법은?

• static 내부 클래스를 사용하여 불필요한 외부 클래스 참조를 제거
• WeakReference를 활용하여 내부 클래스의 참조를 약하게 유지

---

Q4. 익명 내부 클래스와 람다식의 차이는?

✅ 답변:

익명 내부 클래스는 인터페이스 또는 추상 클래스를 구현할 수 있지만,람다식은 오직 “함수형 인터페이스” (메서드 1개짜리 인터페이스)에서만 사용 가능익명 내부 클래스에서 this는 자기 자신(익명 클래스)을 참조,람다식에서 this는 외부 클래스를 참조

✅ 추가 질문:

Q: 람다식으로 변환할 수 없는 익명 내부 클래스의 예시는?

• 인터페이스에 2개 이상의 추상 메서드가 있는 경우 (람다식은 사용 불가)
• 기존 클래스(추상 클래스 X)를 상속해야 하는 경우 (람다식은 인터페이스만 가능)

---

✅ 2. 실무에서 내부 클래스를 최적화하는 방법

내부 클래스를 사용할 때 성능과 유지보수를 고려한 최적화 방법을 정리했습니다.

📌 1. 메모리 누수를 방지하기 위해 static 내부 클래스 사용

일반 내부 클래스는 외부 클래스를 암묵적으로 참조하기 때문에

static 내부 클래스를 사용하면 불필요한 참조를 제거할 수 있습니다.

✅ 잘못된 예시 (메모리 누수 발생 가능)

class Outer {
    private String data = "중요한 데이터";

    class Inner {
        void show() {
            System.out.println(data); // Outer.this를 암묵적으로 참조 (GC 불가능)
        }
    }
}

✅ 올바른 예시 (static 내부 클래스 사용)

class Outer {
    private static String data = "중요한 데이터";

    static class Inner {
        void show() {
            System.out.println(data); // static 변수만 접근 (메모리 누수 방지)
        }
    }
}

💡 static 내부 클래스를 사용하면 외부 클래스의 인스턴스와 독립적으로 존재하므로 메모리 누수가 사라짐.

---

📌 2. 너무 깊은 중첩 클래스 사용 금지 (가독성 문제)

내부 클래스를 너무 많이 사용하면 코드 가독성이 떨어지고 유지보수가 어려워질 수 있음

3단계 이상의 내부 클래스는 사용하지 않는 것이 좋다.

✅ 잘못된 예시 (너무 많은 중첩 클래스)

class A {
    class B {
        class C {
            void method() {
                System.out.println("너무 깊은 중첩 클래스!");
            }
        }
    }
}

✅ 올바른 예시 (클래스를 분리하여 사용)

class C {
    void method() {
        System.out.println("클래스를 분리하여 가독성 향상!");
    }
}

💡 클래스가 너무 깊어지면 유지보수가 어려워지므로, 독립된 클래스로 분리하는 것이 좋음.

---

📌 3. 익명 내부 클래스 대신 람다식을 활용하여 코드 최적화

익명 내부 클래스는 가능하면 람다식으로 변환하여 코드를 간결하게 유지

✅ 잘못된 예시 (익명 내부 클래스 사용)

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("익명 내부 클래스 실행!");
    }
};

✅ 올바른 예시 (람다식 변환)

Runnable r = () -> System.out.println("람다식 실행!");

💡 람다식을 사용하면 코드가 훨씬 간결해지고, 유지보수가 쉬워짐.

---

📌 7단계 정리

✅ 내부 클래스는 기술 면접에서 자주 등장하는 주제이므로, 각 종류와 차이점을 명확히 이해해야 한다.

✅ 메모리 누수를 방지하기 위해 static 내부 클래스를 적절히 사용해야 한다.

✅ 너무 깊은 중첩 클래스는 피하고, 유지보수를 고려한 구조를 설계해야 한다.

✅ 람다식을 활용하면 익명 내부 클래스를 더 간결하게 최적화할 수 있다.

🎯 최종 결론: 내부 클래스는 언제 사용할까?

✅ 내부 클래스가 외부 클래스와 강하게 연결된 경우

✅ 클래스가 불필요하게 노출되지 않도록 캡슐화가 필요한 경우

✅ GUI 이벤트 처리, 컬렉션 반복자, 멀티스레드 등에서 코드 가독성을 높이기 위해

✅ 람다식이 가능하다면 익명 내부 클래스 대신 람다식을 사용하여 최적화

이제 내부 클래스의 개념부터 활용법까지 완벽하게 이해했습니다! 🚀

더 궁금한 점이 있으면 언제든지 질문하세요! 😊