编辑“︁Java内部类应用场景”︁（章节）

== 应用场景详解 ==  

=== 1. 封装逻辑与隐藏实现 ===  
成员内部类可访问外部类的私有成员，适合将紧密相关的逻辑封装在一起。  

<syntaxhighlight lang="java">  
public class DataProcessor {  
    private int[] data = {1, 2, 3};  

    // 成员内部类  
    class Processor {  
        void process() {  
            for (int num : data) {  
                System.out.println(num * 2);  
            }  
        }  
    }  

    public void startProcessing() {  
        Processor processor = new Processor();  
        processor.process();  
    }  

    public static void main(String[] args) {  
        DataProcessor dp = new DataProcessor();  
        dp.startProcessing();  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
2  
4  
6  
</pre>  

'''分析：'''  
* <code>Processor</code> 直接访问外部类的私有字段 <code>data</code>，无需通过Getter方法。  
* 外部类通过 <code>startProcessing()</code> 隐藏内部类的实例化细节。  

=== 2. 静态内部类实现工具类 ===  
静态内部类不依赖外部类实例，适合独立工具逻辑。  

<syntaxhighlight lang="java">  
public class MathUtils {  
    // 静态内部类  
    public static class Calculator {  
        public static int add(int a, int b) {  
            return a + b;  
        }  
    }  

    public static void main(String[] args) {  
        System.out.println(Calculator.add(5, 3)); // 直接调用  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
8  
</pre>  

'''分析：'''  
* <code>Calculator</code> 与 <code>MathUtils</code> 逻辑关联但无需实例化外部类。  

=== 3. 局部内部类处理临时任务 ===  
局部内部类在方法内定义，适合一次性任务。  

<syntaxhighlight lang="java">  
public class EventManager {  
    public void scheduleEvent(String eventName) {  
        // 局部内部类  
        class Event {  
            void log() {  
                System.out.println("Event scheduled: " + eventName);  
            }  
        }  
        new Event().log();  
    }  

    public static void main(String[] args) {  
        new EventManager().scheduleEvent("Meeting");  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
Event scheduled: Meeting  
</pre>  

'''分析：'''  
* <code>Event</code> 仅在 <code>scheduleEvent</code> 方法内有效，避免污染类作用域。  

=== 4. 匿名内部类简化接口实现 ===  
匿名内部类常用于事件监听或线程实现。  

<syntaxhighlight lang="java">  
public class ButtonDemo {  
    interface OnClickListener {  
        void onClick();  
    }  

    public void setOnClickListener(OnClickListener listener) {  
        listener.onClick();  
    }  

    public static void main(String[] args) {  
        ButtonDemo button = new ButtonDemo();  
        // 匿名内部类  
        button.setOnClickListener(new OnClickListener() {  
            @Override  
            public void onClick() {  
                System.out.println("Button clicked!");  
            }  
        });  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
Button clicked!  
</pre>  

'''分析：'''  
* 快速实现接口，无需单独定义类。  

=== 5. 回调机制与事件驱动 ===  
内部类天然支持回调，常见于GUI开发（如Swing/AWT）。  

<syntaxhighlight lang="java">  
import javax.swing.*;  
import java.awt.event.*;  

public class GUIExample {  
    public static void main(String[] args) {  
        JFrame frame = new JFrame();  
        JButton button = new JButton("Click Me");  

        // 匿名内部类实现事件监听  
        button.addActionListener(new ActionListener() {  
            @Override  
            public void actionPerformed(ActionEvent e) {  
                JOptionPane.showMessageDialog(frame, "Hello from inner class!");  
            }  
        });  

        frame.add(button);  
        frame.pack();  
        frame.setVisible(true);  
    }  
}  
</syntaxhighlight>  

'''效果：'''  
点击按钮后弹出对话框显示消息。