Java接口

接口是指一种允许不同系统、设备或组件之间进行通信和交互的方法或系统。

在编写程序时，类似于定义一组方法来执行指定操作的类。可以通过使用接口来定义在该类中使用的方法。在接口中，方法的具体内容可以为空，通常在使用接口的类内部实现方法内容。

//インターフェース
interface インターフェース名{
    //メソッド定義
    void method A(){}
    void method B(){}
}

//インターフェースをクラスに実装
class A implements インターフェース名 {
    public void methodA {
        //実装する
    }
}

场合应用

当定义类之间的关系时: 接口是用于多个类共享相同方法和行为的情况。例如，通过不同类实现相同的接口，这些类可以提供共同的操作。这样一来，就可以明确定义类之间的关系，并提高灵活性和可扩展性。

如果要实现多态性：接口可以用于实现多态性。通过不同的类实现同一个接口，可以统一地处理这些类的实例。通过在程序中使用接口类型，可以在运行时调用适当的类方法，从而实现对对象的灵活操作。

要提高代码的可重用性时，通过定义一个接口来在多个类中共享相同的方法可以增加代码的可重用性。通过实现接口，可以在多个类中重新使用相同的接口方法。此外，在添加新类时，只需实现现有接口即可保持与现有代码的兼容性。

接口的作用 de

实现多态

实现面向对象编程中的多态性。
多态性是指多个对象可以对相同的命令产生不同的行为。
例如，当有猫、狗、鸟的对象时，它们都有一个共同的命令”叫”，但是它们的行为分别是”喵喵”、”汪汪”、”叽叽”。
定义这个共同行为的入口就是接口的作用。

interface Animal {
    void cry();
}

//同じcryメソッドを使用しているが、出力される結果はそれぞれ違う
class Cat implements Animal {
    public void cry() {
        System.out.println("にゃー");
    }
}

class Dog implements Animal {
    public void cry() {
        System.out.println("わん");
    }
}

class Bird implements Animal {
    public void cry() {
        System.out.println("ピヨ");
    }
}

2. 避免实施遗漏

在接口中定义的方法必须在实现类中进行重写。
如果没有进行重写，将会出现编译错误，从而可以防止漏掉实现。

提高柔軟性和擴展性

public interface Calculation  {
    int sum(int num);
}

public class A implements Calculation {
    @Override
    public int sum(int num) {
        int price = num + 100;
        return price;
    }
}

public class B implements Calculation {
    @Override
    public int sum(int num) {
        int price = num + 200;
        return price;
    }
}

接受Calculation接口作为参数。通过使用接口作为方法的参数和返回值，实现了只要是实现了Calculation接口的类就能够灵活地被接受。

public class Main {
 
    public static void main(String[] args) {
 
        A a = new A();
        B b = new B();
        //同じ記述で呼び出せる
        settlement(a);
        settlement(b);
    }
 
    public static void settlement(Calculation calculation) {
        int num = calculation.sum(100);
        System.out.println("計算結果：" + num);
    }
}

默认方法

在接口中可以实现一个已经定义好处理逻辑的方法。
在方法类型的声明前写上”default”关键字。

interface Animal {
    default void sleep() {
        Sysyem.out.println("寝てます");
    }
}

class Cat implements Animal {
    @Ovierride
    public void sleep() {
        Animal.super.sleep(); //継承元のデフォルトメソッドの呼び出し
    }
}

嵌套接口

在接口中声明类也是可能的。
接口内的类总是public或static。习惯上省略public和static。

interface Animal {
    class Cat {
        private String name;
        public Cat(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
    }
    Cat getCat();
}

class MyImpl implements Animal {
    @Ovierride
    public Cat getCat() {
        return new Animal.Cat("猫");
    }
}

Animal animal = new animal();
Animal.Cat cat = animal.getCat();
System.out.println(cat.getCat());

多重继承可以被视为一个类从多个父类继承属性和方法的机制。

如果一个类继承了两个具有相同签名方法的接口，那么它只需实现该方法一次即可。

interface A {
    void method();
}

interface B {
    void method();
}

class C implements A,B {
    //methodメソッドは1つで良い
    @Ovierride
    public void method() {
        System.out.println("メソッド");
    }
}

如果一个类同时实现了两个具有不同方法签名的接口，那么需要分别实现每个接口的方法。

interface A {
    void methodA();
}

interface B {
    void methodB();
}

class C implements A,B {
    @Ovierride
    public void methodA() {
        System.out.println("メソッドA");
    }

    @Ovierride
    public void methodB() {
        System.out.println("メソッドB");
    }
}

如果两个继承关系中有多重继承的接口，且具有相同名称的方法，那么只需实现位于继承关系下层的类型的方法即可。

interface A {
    Object methodA();
}

interface B {
    String methodA();
}

class C implements A,B {
    //Object→StringなのでStringの方を実装する
    @Ovierride
    public String methodA() {
        System.out.println("メソッドA");
    }
}