编辑“︁Java内部类与接口”︁（章节）

= Java内部类与接口 =

== 介绍 ==
'''Java内部类'''（Inner Class）是定义在另一个类内部的类，而'''接口'''（Interface）则是一种完全抽象的类，用于定义一组方法规范。将两者结合使用时，内部类可以实现接口，或在接口中定义内部类，这种组合为Java程序提供了更灵活的代码组织方式。本节将详细介绍内部类与接口的关系、使用场景及实际应用。

== 内部类实现接口 ==
内部类可以直接实现接口，这种方式常用于需要隐藏实现细节或为外部类提供特定功能的情况。

=== 示例代码 ===
<syntaxhighlight lang="java">
// 定义一个接口
interface Greeting {
    void greet();
}

// 外部类
public class OuterClass {
    // 内部类实现接口
    class InnerClass implements Greeting {
        @Override
        public void greet() {
            System.out.println("Hello from InnerClass!");
        }
    }

    // 方法返回接口类型
    public Greeting getGreeting() {
        return new InnerClass();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        Greeting greeting = outer.getGreeting();
        greeting.greet(); // 输出: Hello from InnerClass!
    }
}
</syntaxhighlight>

'''输出:'''
<pre>
Hello from InnerClass!
</pre>

'''解释:'''
* <code>InnerClass</code> 实现了 <code>Greeting</code> 接口，并重写了 <code>greet()</code> 方法。
* <code>getGreeting()</code> 方法返回一个 <code>Greeting</code> 类型的对象，实际上是 <code>InnerClass</code> 的实例。
* 通过接口调用方法，实现了多态性。

== 接口中的内部类 ==
接口中也可以定义内部类，但此类默认是 <code>public static</code> 的，因为接口本身不能有实例字段或非静态方法。

=== 示例代码 ===
<syntaxhighlight lang="java">
interface Vehicle {
    // 接口中的内部类
    class Engine {
        void start() {
            System.out.println("Engine started.");
        }
    }

    void move();
}

public class Car implements Vehicle {
    @Override
    public void move() {
        Vehicle.Engine engine = new Vehicle.Engine();
        engine.start();
        System.out.println("Car is moving.");
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.move();
    }
}
</syntaxhighlight>

'''输出:'''
<pre>
Engine started.
Car is moving.
</pre>

'''解释:'''
* <code>Engine</code> 是定义在 <code>Vehicle</code> 接口中的静态内部类。
* <code>Car</code> 类实现 <code>Vehicle</code> 接口，并在 <code>move()</code> 方法中使用 <code>Engine</code> 类。

== 实际应用场景 ==
内部类与接口的结合在以下场景中非常有用：

1. '''事件监听器'''：在GUI编程中，匿名内部类常用于实现事件监听接口。
   <syntaxhighlight lang="java">
   button.addActionListener(new ActionListener() {
       @Override
       public void actionPerformed(ActionEvent e) {
           System.out.println("Button clicked!");
       }
   });
   </syntaxhighlight>

2. '''工厂模式'''：通过内部类实现接口，隐藏具体实现。
   <syntaxhighlight lang="java">
   interface Service {
       void execute();
   }

   class Services {
       private static class DefaultService implements Service {
           public void execute() {
               System.out.println("Default service.");
           }
       }

       static Service getDefaultService() {
           return new DefaultService();
       }
   }
   </syntaxhighlight>

== 类图示例 ==
以下是一个展示内部类与接口关系的类图：
<mermaid>
classDiagram
    class OuterClass {
        +getGreeting() Greeting
    }
    class InnerClass {
        +greet()
    }
    interface Greeting {
        <<interface>>
        +greet()
    }
    OuterClass --> InnerClass : contains
    InnerClass ..|> Greeting : implements
</mermaid>

== 总结 ==
* 内部类可以实现接口，提供更灵活的代码组织方式。
* 接口中的内部类默认是静态的，常用于工具类或共享逻辑。
* 实际应用中，内部类与接口的结合广泛用于事件处理、工厂模式等场景。

通过合理使用内部类与接口，可以增强代码的封装性、可读性和可维护性。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java内部类]]