Java面向对象之内部类的几类使用场景

介绍

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内部类在回调接口、访问外部类私有成员、实现多继承和数据隐藏等场景中非常有用。