介绍

Java内部类是一种特殊的类，它定义在另一个类的内部。内部类提供了许多有用的特性，包括访问外部类的私有成员、隐藏实现细节以及实现回调接口等。以下是Java内部类的一些常用场景及其举例说明：

回调接口

当某个类需要一个对象来执行其方法时，通常可以使用回调接口。这时，内部类可以作为一个匿名实现类，简化代码。
在这个例子中，ActionListener是一个回调接口，Button类通过ActionListener来执行某个动作。在Main类中，我们使用了一个匿名内部类来实现ActionListener接口。

interface ActionListener {  
    void actionPerformed();  
}  
  
class Button {  
    private ActionListener listener;  
  
    public void setActionListener(ActionListener listener) {  
        this.listener = listener;  
    }  
  
    public void click() {  
        if (listener != null) {  
            listener.actionPerformed();  
        }  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        Button button = new Button();  
        button.setActionListener(new ActionListener() {  
            @Override  
            public void actionPerformed() {  
                System.out.println("Button clicked!");  
            }  
        });  
        button.click();  
    }  
}

访问外部类的私有成员

内部类可以访问外部类的私有成员，这使得内部类成为了一种封装和隐藏实现细节的有效手段。在这个例子中，Inner类可以访问Outer类的私有成员secret。

class Outer {  
    private int secret = 42;  
  
    class Inner {  
        void revealSecret() {  
            System.out.println("The secret is: " + secret);  
        }  
    }  
  
    public Inner getInner() {  
        return new Inner();  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        Outer outer = new Outer();  
        Outer.Inner inner = outer.getInner();  
        inner.revealSecret();  // 输出 "The secret is: 42"  
    }  
}

实现多继承

Java不支持多继承，但内部类可以帮助我们实现类似的效果。

interface A {  
    void methodA();  
}  
  
interface B {  
    void methodB();  
}  
  
class MyClass implements A {  
    private class InnerB implements B {  
        @Override  
        public void methodB() {  
            System.out.println("Method B from InnerB");  
        }  
    }  
  
    private InnerB innerB = new InnerB();  
  
    @Override  
    public void methodA() {  
        System.out.println("Method A from MyClass");  
    }  
  
    public void methodB() {  
        innerB.methodB();  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        MyClass myClass = new MyClass();  
        myClass.methodA();  // 输出 "Method A from MyClass"  
        myClass.methodB();  // 输出 "Method B from InnerB"  
    }  
}

在这个例子中，MyClass实现了接口A，并通过内部类InnerB实现了接口B。这样，MyClass就具有了A和B两个接口的行为。

数据隐藏

内部类可以将实现细节隐藏在外部类内部，从而提供一个更简洁、更易于使用的API。

class DataHolder {  
    private int data;  
  
    public DataHolder(int data) {  
        this.data = data;  
    }  
  
    class DataProcessor {  
        void processData() {  
            // 在这里可以对data进行复杂的处理  
            System.out.println("Processed data: " + data);  
        }  
    }  
  
    public DataProcessor getProcessor() {  
        return new DataProcessor();  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        DataHolder holder = new DataHolder(42);  
        DataHolder.DataProcessor processor = holder.getProcessor();  
        processor.processData();  // 输出 "Processed data: 42"  
    }  
}

在这个例子中，DataProcessor内部类隐藏了对data的处理细节，外部类只需要调用getProcessor()方法即可。

总之，Java内部类在回调接口、访问外部类私有成员、实现多继承和数据隐藏等场景中非常有用。