接口(Interface)

接口是什么

接口是一种抽象的数据类型，可以包含方法的声明、常量的定义和默认方法（Java 8+）。

接口中的方法默认是公开(public)的和抽象(abstract)的，可以省略这些修饰符。

接口声明变量

在接口中声明常量时，这些常量默认是公共的(public)、静态的(static)和最终(final)。这意味着他们是常量，一旦被赋值，就不能再修改。

在接口中声明变量的语法如下：

interface MyInterface {
    // 声明变量
    int MAX_VALUE = 100;
    String DEFAULT_NAME = "John Doe"
}

在上面的示例中，MAX_VALUE和DEFAULT_NAME都是接口中声明的常量。他们可以在接口中直接使用，也可以同接口名称来访问。

public interface MyInterface {
    int MAX_VALUE = 100;
    String DEFAULT_NAME = "John Doe";
}

public class MyClass implements MyInterface {
    public void printMaxValue() {
        System.out.println("Max value: " + MAX_VALUE);
    }
    
    public void printDefaultName() {
        System.out.println("Default name: " + DEFAULT_NAME);
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.printMaxValue();
        obj.printDefaultName();
        
        // 也可以通过接口名称来访问常量
        System.out.println("Max value: " + MyInterface.MAX_VALUE);
        System.out.println("Default name: " + MyInterface.DEFAULT_NAME);
    }
}

在上面的示例中，MyClas实现了MyInterface接口，并使用接口中声明的常量MAX_VALUE和DEFAULT_NAME。这些常量可以直接在实现类中使用，也可以通过接口名称来访问。

接口中声明的变量默认是公开的、静态的和最终的。因此可以在接口的任何实现类中直接使用或通过接口名称访问。

接口声明方法

在接口中声明方法时，这些方法默认是公开的(public)和抽象的(abstract)。接口中的方法没有具体实现，只有方法的签名(方法名、参数和返回类型)。

在接口中声明方法的语法如下：

public interface MyInterface {
    // 声明方法
    void method1();
    int method2(String str);
}

在上面的示例中，methed1和methed2都是接口中声明的方法。实现类必须提供这些方法的具体实现。

public interface MyInterface {
    void method1();
    int method2(String str);
}

public class MyClass implements MyInterface {
    public void method1() {
        System.out.println("Implementing method1.");
    }
    
    public int method2(String str) {
        System.out.println("Implementing method2 with parameter: " + str);
        return str.length();
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.method1();
        int length = obj.method2("Hello");
        System.out.println("Length: " + length);
    }
}

在上面的示例中，MyClass实现了MyInterface接口，并提供了接口中声明的方法methed1和methed2的具体实现。这些方法可以在实现类中根据需要进行自定义实现。

默认方法

默认方法是Java 8 引入的新特性，允许在接口中提供具体的方法实现。默认方法在接口中有默认的实现，实现类可以直接继承这些默认方法，而不需要重新实现。

默认方法的特点：

• 默认方法使用default关键字进行声明。

• 默认方法提供了接口的默认实现，实现类可以直接继承这些方法。

• 默认方法可以在接口中直接调用。也可以在实现类中进行重写。

• 默认方法可以被实现类覆盖，以提供自定义的实现。

• 默认方法可以调用其他接口中的默认方法

public interface MyInterface {
    // 抽象方法
    void abstractMethod();

    // 默认方法
    default void defaultMethod() {
        // 默认方法的实现
    }
}

public interface MyInterface {
    void abstractMethod();
    
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
}

public class MyClass implements MyInterface {
    public void abstractMethod() {
        System.out.println("Implementing abstract method.");
    }
    
    // 可选：覆盖默认方法
    public void defaultMethod() {
        System.out.println("Overriding default method.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.abstractMethod();  // 输出：Implementing abstract method.
        obj.defaultMethod();   // 输出：Overriding default method.
    }
}

在上面的示例中，MyInterface接口中定义了一个抽象方法method1和一个默认方法method2。MyClass实现了MyInterface接口，并提供了对抽象方法和默认方法的具体实现。在Main类中，我们创建了MyClass的实例并调用了接口中的方法。

静态方法

静态方法（Static Methods）是在Java 8中引入的新特性，它允许在接口中定义具体的静态方法。静态方法属于接口本身，而不是接口的实现类。

静态方法的特点：

• 静态方法使用static关键字进行声明。

• 静态方法可以在接口中直接调用，无需通过实现类的对象。

• 静态方法不能被实现类覆盖或重写。

• 静态方法包含方法体，提供具体的实现。

• 静态方法可以访问接口中的静态变量，但不能访问示例变量。

public interface MyInterface {
    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
    
    // 抽象方法
    void abstractMethod();
}

public class MyClass implements MyInterface {
    public void abstractMethod() {
        System.out.println("Implementing abstract method.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface.staticMethod();  // 输出：This is a static method.
        
        MyClass obj = new MyClass();
        obj.abstractMethod();        // 输出：Implementing abstract method.
    }
}

接口的多态性

接口的多态性是指通过接口类型的引用变量，可以实现该接口的不同类的对象，从而实现多态的特性。

具体来说，当一个类实现了一个接口时，可以将该类的对象赋值给接口类型的变量，然后通过接口类型的引用变量调用接口中定义的方法。这样做的好处是，可以在不改变代码的情况下，通过替换不同的实现类对象来实现不同的行为。

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Dog barks.");
    }
}

public class Cat implements Animal {
    public void makeSound() {
        System.out.println("Cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        dog.makeSound();  // 输出：Dog barks.
        cat.makeSound();  // 输出：Cat meows.
    }
}

在上面的示例中，Animal是一个接口，Dog和Cat是实现了Animal接口的类。在Main类中，我们创建了Dog和Cat的对象，并将它们分别赋值给Animal类型的变量。然后，通过接口类型的引用变量调用了makeSound方法。由于多态的特性，实际调用的是对应对象的方法。

接口的继承

在Java中，接口之间可以通过接口继承（Interface Inheritance）建立继承关系。接口继承允许一个接口继承另一个或多个接口的方法和常量，从而形成接口的继承链

接口继承的语法如下：

public interface ChildInterface extends ParentInterface {
    // 子接口的方法和常量声明
}

在上面的示例中，ChildInterface是一个子接口，通过extends关键字继承了ParentInterface接口。子接口可以继承父接口的方法和常量，并可以在子接口中声明自己的方法和常量

public interface Animal {
    void eat();
}

public interface Mammal extends Animal {
    void run();
}

public class Dog implements Mammal {
    public void eat() {
        System.out.println("Dog eats.");
    }
    
    public void run() {
        System.out.println("Dog runs.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 输出：Dog eats.
        dog.run();  // 输出：Dog runs.
    }
}

在上面的示例中，Animal是一个接口，Mammal是继承了Animal接口的子接口。Dog类实现了Mammal接口，并提供了对应方法的具体实现。在Main类中，我们创建了Dog的对象，并调用了接口中定义的方法。

匿名实现类

匿名实现类（Anonymous Inner Class）是一种在使用接口或抽象类时，直接创建一个实现类的对象并进行实现的方式，而无需显式地定义一个具名的实现类。

匿名实现类的语法如下：

InterfaceName obj = new InterfaceName() {
    // 实现接口中的方法
    // 可以在这里提供方法的具体实现
};

在上面的示例中，InterfaceName是一个接口，通过匿名实现类的方式创建了一个实现类的对象，并提供了对应方法的具体实现。

示例代码：

public interface MyInterface {
    void method();
}

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            public void method() {
                System.out.println("Anonymous implementation of method.");
            }
        };
        
        obj.method();  // 输出：Anonymous implementation of method.
    }
}

上面的示例中，MyInterface是一个接口，通过匿名实现类的方式创建了一个实现类的对象，并提供了对应方法的具体实现。在Main类中，我们创建了一个匿名实现类的对象，并调用了接口中定义的方法。

weizhi

interface CompareA {
    // 全局常量
    public static final int NUM = 10;
    public abstract void show();

    public default void show2() {
        System.out.println("CompareA show2");
    }
}

interface CompareB {
    public default void show2() {
        System.out.println("CompareB show2");
    }
}

class CompareC implements CompareA, CompareB {
    @Override
    public void show() {
        System.out.println("CompareC show");
    }

    @Override
    public void show2() {
        System.out.println("CompareC show2");
    }
}

私有方法

私有方法（Private Methods）是在Java 9中引入的新特性，它允许在接口或类中定义私有的方法。私有方法只能在定义它们的接口或类内部使用，无法被外部调用。

私有方法的特点：

• 私有方法使用private关键字进行声明。

• 私有方法只能在定义它们的接口或类内部使用。

• 私有方法可以被其他方法调用，用于提取和重用公共逻辑。

• 私有方法不能被接口的默认方法或静态方法调用。

public interface MyInterface {
    default void publicMethod() {
        // 调用私有方法
        privateMethod();
        System.out.println("This is a public method.");
    }
    
    private void privateMethod() {
        System.out.println("This is a private method.");
    }
}

public class MyClass implements MyInterface {
    // 实现接口的抽象方法
    public void abstractMethod() {
        // 调用私有方法
        privateMethod();
        System.out.println("Implementing abstract method.");
    }
    
    private void privateMethod() {
        System.out.println("This is a private method in MyClass.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.publicMethod();   // 输出：This is a private method. This is a public method.
        obj.abstractMethod(); // 输出：This is a private method in MyClass. Implementing abstract method.
    }
}