Java初学8-7-接口

在 Java 中，接口（interface）是一种特殊的抽象类型，用于定义一组相关的方法签名，这些方法没有具体的实现。接口提供了一种规范或契约，规定了实现该接口的类必须提供的行为。接口中的方法默认是公共（public）和抽象（abstract）的，不允许有任何实现细节。

接口的关键特点

抽象方法：接口中的方法默认是抽象的，即没有方法体。实现接口的类必须提供这些方法的具体实现。

常量：接口可以包含常量字段，这些常量默认是 public, static 和 final 的。

多继承：在 Java 中，类只能继承一个超类，但可以实现多个接口。这为实现多继承的概念提供了一种方式。

默认方法：从 Java 8 开始，接口可以包含具有默认实现的方法，称为默认方法，这允许在不破坏现有实现的情况下添加新方法。

静态方法：从 Java 8 开始，接口还可以包含静态方法。

接口的定义格式

接口使用 interface 关键字定义，并且可以包含抽象方法、默认方法和静态方法：

public interface InterfaceName {

    // 抽象方法

    void Method();

//在接口中声明的方法默认是 public 和 abstract 的，因此不需要显式地使用 abstract 关键字。这意味着接口中的方法不需要方法体，实现接口的类必须提供这些方法的具体实现。

    // 默认方法

    default void Method() {

        // 方法体

}

//接口可以包含具有默认实现的方法，这些方法使用 default 关键字声明。默认方法允许在不修改现有类的基础上向接口添加新方法，从而避免破坏现有的实现。

    // 静态方法

    static void Method() {

        // 方法体

    }

}

实现接口

一个类可以通过 implements 关键字实现一个或多个接口，并且必须提供接口中所有抽象方法的具体实现。如果类本身是抽象类，那么它可以不完全实现接口中的方法。

public class ClassName implements InterfaceName {

    @Override

    public void Method() {

        // 实现细节

    }

}

示例：

接口定义

public interface Animal {

    // 抽象方法

    void makeSound();

}

实现接口的类

public class Dog implements Animal {

    @Override

    public void makeSound() {

        System.out.println("Woof!");

    }

}

使用实现接口的类

public class Main {

    public static void main(String[] args) {

        Dog myDog = new Dog();

        myDog.makeSound(); // 输出 "Woof!"

    }

}

在这个例子中，Animal 是一个接口，它定义了一个 makeSound 方法。Dog 类实现了 Animal 接口，并提供了 makeSound 方法的具体实现。

总结

接口在Java 中用于定义一组行为的规范。实现接口的类必须提供接口中定义的所有抽象方法的具体实现。默认方法和静态方法允许在接口中提供默认实现。多继承可以通过实现多个接口来实现。

示例：

package InterfaceTest;

public class InterfaceTest01 {
    public static void main(String[] args) {

System.out.println(DSG.MAX_SIZE);//可以直接使用接口名.属性名进行调用

        InterfaceTest01001 IT01 = new InterfaceTest01001();
        IT01.InterfaceTest0101();
        IT01.InterfaceTest0102();
        IT01.InterfaceTest0103();
        //IT01.InterfaceTest0104();静态方法仍然是： **名.方法名进行调用！！！
        DSG.InterfaceTest0104();
    }
}



interface DSG {

//接口中的属性
    //接口中的属性默认是 public, static, 和 final 的，因此不需要显式地使用这些关键字。属性通常是常量，因此必须初始化。
//接口中的属性必须在声明时初始化
    //接口中的属性默认是 public 的，这意味着它们可以被任何类访问。不能使用 private 或 protected 关键字来修饰接口中的属性
    int MAX_SIZE = 50000;
 

    void InterfaceTest0101();//抽象方法
//接口中的方法默认是 public 和 abstract 的，因此不需要显式地使用 public 或 abstract 关键字。
//抽象方法的返回类型可以是任何合法的类型，包括基本类型、引用类型或泛型。
//不能使用 private、protected 或 final 关键字来修饰接口中的方法




    default void InterfaceTest0102(){
        System.out.println("接口的默认方法InterfaceTest0102()。");
    }

    default void InterfaceTest0103(){
        System.out.println("接口的默认方法InterfaceTest0103()。");
    }
    //默认方法使用 default 关键字声明。默认方法必须包含方法体，即具体的实现逻辑。即必须要有{...},只有{}也行
//不能使用 private 或 protected 关键字来修饰默认方法。








    static void InterfaceTest0104(){//静态方法不能被重写
        //静态方法与多态性：静态方法不属于对象实例，而是属于类本身。因此，它们不能被重写或覆盖，也不会表现出多态性。
        //静态方法的调用：静态方法通常通过类名来调用，而不是通过类的实例。
        System.out.println("接口的静态方法InterfaceTest0104()。");
    }
    //void InterfaceTest0105();当一个类实现了某个接口，但没有实现接口中的所有抽象方法，并且该类本身不是抽象类时，将会导致编译错误。

}




class InterfaceTest01001 implements DSG {

@Override
    public void InterfaceTest0101(){
        System.out.println("类InterfaceTest01001重写接口的抽象方法InterfaceTest0101()。");
    }
    @Override
    public void InterfaceTest0102(){
        System.out.println("类InterfaceTest01001重写接口的默认方法InterfaceTest0102()。");
    }

}

一个类可以继承多个接口。

package InterfaceTest;

public class InterfaceTest02 {
    public static void main(String[] args) {
        InterfaceTest02001 IT0201 = new InterfaceTest02001();
        IT0201.show();
        IT0201.cry();
        IT0201.say();

    }
}
interface Interface1 {
    void say();
    void show();


    default void play() {
        System.out.println("PLAY!!!");
    }
    default void laughing(){
        System.out.println("Laughing");
    }

}
interface Interface2 {
    void cry();
    void show();


    default void play() {
        System.out.println("play~~~");
    }
    default void playfighting() {
        System.out.println("playfighting");
    }
}
class InterfaceTest02001 implements Interface1, Interface2 {
    public void say() {
        System.out.println("Hello baby~");
    }
   public void show() {//可以将该类设置为抽象类以后，不在该类中实现接口中同名的抽象方法。
        System.out.println("display");
    }
    public void cry() {
        System.out.println("鸣鸣鸣~");
    }




   public void play(){
        System.out.println("玩耍ing");
    }//当继承的多个接口中还有同名的默认方法时，必须在继承的这个类中进行实现！！！无论该类是否是抽象类！！！都必须进行重写！！！
//public abstract void play();
// 另一个解决方案是将该类设置为抽象类后，在该类中将同名的默认方法设置为抽象方法，并在之后的子类中进行实现。
//注意，此时该类不能创建实例。 其中方法的调用可以在后续创建子类的实例进行调用。


    public void playfighting() {
        System.out.println("打闹ing");
    }
    public void laughing(){
        System.out.println("哈哈哈哈");
    }
}





//接口能继承接口，但是接口不能继承类
interface Interface3 extends Interface1, Interface2 {
    @Override
    default void play() {
        System.out.println("123");
    }

    @Override
    default void laughing() {
        System.out.println("123");
    }

    @Override
    default void playfighting() {
        System.out.println("123");
    }

    @Override
    void say();

    @Override
    void show();

    @Override
    void cry();
}
 

接口的多态性体现：

package InterfaceTest;

public class InterfaceTest03 {
    public static void main(String[] args) {
        /*InterfaceTest03001 A = new InterfaceTest03001("Seraphine");
        InterfaceTest03002 B = new InterfaceTest03002("Sona");

        InterfaceTest03003 obj = new InterfaceTest03003();
        obj.InterfaceTest0301(A);
        obj.InterfaceTest0301(B);*/


        QWE a = new InterfaceTest03001("Seraphine");
        a.show();
        a.print1();
        QWE b = new InterfaceTest03002("Sona");
        b.show();
        b.print1();


        //或者
        QWE x = new InterfaceTest03001("酸辣粉");
        x.show();
        x.print1();
        x = new InterfaceTest03002("QA女王");
        x.show();
        x.print1();

    }
}
interface QWE{
    void show();


    default void print1(){
        System.out.println("Hello 艾瑞巴蒂！");
    }

}

class InterfaceTest03001 implements QWE{
    private String name;
    public InterfaceTest03001(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println(name + "在台上演出~");
    }
    public void print1(){
        System.out.println("观众为止疯狂！！！");
    }
}
class InterfaceTest03002 implements QWE{
    private String name;
    public InterfaceTest03002(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println(name + "正在嫉妒她能唱歌");
    }
    public void print1(){
        System.out.println("因为自己是哑女");
    }
}
/*
class InterfaceTest03003{
    public void InterfaceTest0301(QWE qwe){//这里体现了接口的多态性
        qwe.show();
        qwe.print1();

    }
}*/

接口多态的传递性：

package InterfaceTest;

public class InterfaceTest04 {
    public static void main(String[] args) {
        interface2 a = new InterfaceTest04001();
        //要想使下面这行成立则要interface2 extends interface1
        interface1 b = new InterfaceTest04001();
    }
}
interface interface1 {
    //void A();一旦interface2 extends interface1，那么InterfaceTest04001就必须实现interface1中的方法。
}
interface interface2 extends interface1 {

}
class InterfaceTest04001 implements interface2 {

}