接口的定义与实现

在Java中，接口（Interface）是一种抽象类型，它定义了一组方法的规范，但没有具体的实现。接口可以被类实现（implement），从而使类能够遵循接口定义的方法。

接口具有以下特点：

1. 定义方法规范：接口中只包含方法的声明，没有方法体。它描述了一个类应该具有的方法，并定义了方法的名称、参数列表和返回类型，但不指定具体的实现。
2. 不能被实例化：接口本身不能被实例化，也就是不能创建接口的对象。但可以通过类实现接口，并创建实现了接口的类的对象。
3. 多实现：一个类可以实现一个或多个接口，实现接口的类必须提供接口中定义的所有方法的具体实现。
4. 方法默认为公共的抽象方法：在接口中声明的方法默认为 public 的抽象方法，因此在实现接口时，需要将接口中的方法声明为 public。
5. 可以包含常量和默认方法：接口可以包含常量（使用 final 和 static 修饰）和默认方法（使用 default 关键字修饰的方法，提供默认的实现）。

以下是一个简单的接口示例：

interface Drawable {
    int MAX_WIDTH = 100;
    int MAX_HEIGHT = 100;
    
    void draw();
    void resize(int width, int height);
}

class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
    
    @Override
    public void resize(int width, int height) {
        System.out.println("Resizing circle to width: " + width + ", height: " + height);
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw();            // 输出：Drawing a circle
        circle.resize(50, 50);    // 输出：Resizing circle to width: 50, height: 50
        
        System.out.println(Drawable.MAX_WIDTH);    // 输出：100
        System.out.println(Drawable.MAX_HEIGHT);   // 输出：100
    }
}

在上面的示例中，我们定义了一个名为 Drawable 的接口，它声明了 draw() 和 resize(int width, int height) 两个方法。接口中还定义了两个常量 MAX_WIDTH 和 MAX_HEIGHT。

然后，我们创建了一个名为 Circle 的类，并实现了 Drawable 接口。在 Circle 类中，我们提供了对接口中方法的具体实现。

在 main 方法中，我们创建了一个 Circle 对象，并调用了接口中定义的方法 draw() 和 resize(int width, int height)。同时，我们还通过接口名直接访问了接口中定义的常量。

接口的使用可以帮助我们实现程序的模块化和解耦，提供了一种灵活的方式来定义和组织代码。通过实现接口，类可以满足接口定义的规范，并且可以多重实现接口以达到多态的效果。接口在面向对象设计中起到了重要的角色，用于定义共享行为和实现类之间的契约。

实现多个接口

在Java中，一个类可以实现多个接口，通过使用逗号将多个接口名称连接起来。这样，实现类就可以同时具备多个接口定义的方法。

以下是一个示例，展示了如何实现多个接口：

interface Interface1 {
    void method1();
}

interface Interface2 {
    void method2();
}

class MyClass implements Interface1, Interface2 {
    @Override
    public void method1() {
        System.out.println("Implementation of method1");
    }
    
    @Override
    public void method2() {
        System.out.println("Implementation of method2");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.method1();    // 输出：Implementation of method1
        obj.method2();    // 输出：Implementation of method2
    }
}

在上面的示例中，我们定义了两个接口 Interface1 和 Interface2，它们分别声明了方法 method1() 和 method2()。

然后，我们创建了一个名为 MyClass 的类，并实现了 Interface1 和 Interface2 接口。在 MyClass 类中，我们提供了对接口中方法的具体实现。

在 main 方法中，我们创建了一个 MyClass 对象，并调用了实现的方法 method1() 和 method2()。

通过实现多个接口，类可以获得多个接口定义的方法，实现类需要提供对这些方法的具体实现。这样的设计允许类具备不同接口所定义的行为，提供了更大的灵活性和代码复用性。同时，通过多个接口的实现，还可以利用多态性来处理不同接口的对象，提高代码的可扩展性和适应性。