03.Java接口类详解

接口类是一种完全抽象的业务模型，它不能直接new实例化对象。
接口类仅仅用来定义一组对象的行为规范和常量集合，所以接口中的方法都是抽象方法，没有方法体{}。
- 抽象方法只能通过子类继承实现具体方法（这一点类似父子类继承关系）。
- 注：在Java1.8+的版本，允许接口存在default修饰的默认方法体，static静态方法体
- 注：在Java1.9+的版本，允许接口存在private修饰的私有方法，仅提供接口类内部使用
接口类使用interface关键字修饰声明。
普通类使用implements关键字实现接口类，并强制重写接口类中的所有抽象方法。
- 普通类只能继承一个类，但可以实现多个接口，多个接口使用逗号分隔

语法格式

[访问修饰符] interface 接口名称 {
    // 常量定义（默认是 public static final）
    // 抽象方法（默认是 public abstract）
    // 默认方法（Java 8+，用 default 修饰）
    // 静态方法（Java 8+，用 static 修饰）
    // 私有方法（Java 9+，用于辅助默认方法或静态方法）
}

代码案例

public interface Animal {
    // 静态类中不能存在成员属性,所有属性都隐式使用public static final
    // 常量（隐式使用 public static final修饰）
    // public static final int LEGS = 4; 这句与下面其实完全一致
    int LEGS = 4;

    // 抽象方法（隐式使用 public abstract 修饰）
    // public abstract void makeSound();
    // public void makeSound();
    // 以上两种写法下面这种结果一致，更建议使用下面这种写法
    void makeSound();
    

    // 默认方法（Java 8+）
    default void sleep() {
        System.out.println("This animal is sleeping.");
    }

    // 静态方法（Java 8+）
    // Animal.info();
    static void info() {
        System.out.println("Animal interface provides animal behaviors.");
    }
    
    // 接口中不能存在构造方法
}

// 普通实体类通过implements声明实现Animal接口类,多个接口使用逗号分隔（这里假设创建了Animal2.java接口类）
class Cat implements Animal,Animal2 {
    // 这里不是必须重写Animal接口类的sleep的方法
    @Override
    public void sleep() {}
}

二、Java接口的特性（代码实例）

2.1、接口中只能声明抽象方法

接口中的所有函数方法会隐式使用public abstract修饰
普通类实现接口时，除非该类是接口或抽象类，否则必须实现接口中所有的抽象方法！

/* 文件名 : Animal.java */
interface Animal {
    // 接口中只能定义抽象方法
    // 下面三种写法结果一致，一般更建议void info()书写格式;
    void info();
    public void eat();
    public abstract void travel();// Java会隐式使用 public abstract 修饰,不必显式声明
}

/** Cat.java */
class Cat implements Animal {
    // 必须实现Animal接口类中的全部抽象方法,否则报代码编译错误
    @Override
    public void info() {}
    @Override
    public void eat() {}
    @Override
    public void travel() {}
}

2.2、接口中不能声明成员属性

接口中只能存在静态常量，所有成员属性会隐式使用public static final修饰
- final修饰的常量必须赋初始值，且不可更改。

/* 文件名 : Animal.java */
interface Animal {
    // 设置身高属性默认为0
    // 因为接口中的所有属性隐式使用final修饰,所以这种常量都必须设置初始值
    int height = 0;
    // public static final
    public static final int weight = 0;
}

2.3、default默认方法（JDK1.8+）

JDK1.8，也就是Java1.8+版本后，接口中开始可以声明具体方法，使用default关键词修饰
子类可以选择性重写父类的default默认方法
- 这样就解决了不是所有的实现类都必须重写接口中抽象方法的痛点

/* 文件名 : Animal.java */
interface Animal {
    default void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

// 普通实体类通过implements声明实现Animal接口类
class Cat implements Animal {
    // 这里不是必须重写Animal接口类的sleep的方法
    @Override
    public void sleep() {}
}

2.4、static静态方法（JDK1.8+）

/* 文件名 : Animal.java */
interface Animal {
    // 接口中的静态方法直接通过类名调用
    // Animal.info();
    static void info() {
        System.out.println("This animal is sleeping.");
    }
}

2.5、多接口实现

普通类可以实现多个接口，多个接口之间用逗号分隔。

// 定义接口A
interface InterfaceA {
    void methodA();
}
 
// 定义接口B
interface InterfaceB {
    void methodB();
}
 
// 定义一个类实现这两个接口
public class MyClass implements InterfaceA, InterfaceB {
    @Override
    public void methodA() {
        System.out.println("实现接口A的抽象方法");
    }
 
    @Override
    public void methodB() {
        System.out.println("实现接口B的抽象方法");
    }
}
 
// Test.java测试类
public class Test {
    public static void main(String[] args) {
        MyClass myObject = new MyClass();
        myObject.methodA(); // 输出: 实现接口A的抽象方法
        myObject.methodB(); // 输出: 实现接口B的抽象方法
    }
}

三、Java接口类的应用场景

3.1、工具类方法封装

因为Java接口类的特性，工作中可以用它来做一些工具类，在下面例子中创建了一个MathUtils数字操作工具类

3.2、接口间的继承

接口之间，可以多层级继承

interface InterfaceA{
    void run();
}
interface InterfaceB extends InterfaceA {
    void swim();
}
interface  InterfaceC extends InterfaceB{}

/** 创建测试类继承InterfaceC */
class Test implements InterfaceC {
    // 必须实现run(),swim()方法
    @Override
    public void run() {}
    @Override
    public void swim() {}
}

3.3、接口的向上转型，向下转型

interface InterfaceA {
    String testStr = "测试字段";
    void testMethod();
}
 
class ImplementingClass implements InterfaceA {
    @Override
    public void testMethod() {
        System.out.println("重写的抽象方法,父子类共有");
    }
    public void customMethod() {
        System.out.println("类自定义函数~");
    }
}
/** Test.java测试类*/
public class Test {
    public static void main(String[] args) {
        InterfaceA i = new ImplementingClass();
        System.out.println(i.testStr);// 接口特有字段，接口中有的成员，所以能访问
        i.testMethod();// 共有成员，接口中也有，所以能调用
        
        // i.customMethod(); // 这里就会报错，因为接口中没有这个成员（类似父类引用无法直接使用子类特有成员方法）
        // 这是实现类的特有成员，如果要访问，则需要向下转型
        ((ImplementingClass)i).customMethod();// 向下转型后访问实现类的特有成员
    }
}

3.4、接口多态

多态数组

/** InterfaceCry.java */
interface InterfaceCry {
    void cry();
}

/** Dog.java */
class Dog implements InterfaceCry {
    @Override
    public void cry() {
        System.out.println("Woof~");
    }
}
 
/** Cat.java */
class Cat implements InterfaceCry {
    @Override
    public void cry() {
        System.out.println("Meow~");
    }
}

/** Test.java*/
public class Test {
    public static void main(String[] args) {
        List<InterfaceCry> list = ‌Arrays.asList(new Cat(),new Dog());
        for(InterfaceCry i : list) {
            i.cry();
        }
    }
}

多态传参

/** InterfaceCry.java */
/** Dog.java */
/** Cat.java */
/** ...省略代码参考上面的多态数组... */

/** Test.java*/
public class Test {
    public static void main(String[] args) {
        useMethod(new Cat());
        useMethod(new Dog());
    }
    public static void useMethod(InterfaceCry item){
        item.cry();
    }
}

四、接口类的特点总结

在Java中，接口（Interface）是一种引用数据类型，类似于类，但它只能包含常量、方法签名和嵌套类型。接口不能包含实例变量或方法的实现
- 在Java 8及之后的版本，可以在接口中定义默认方法和静态方法
接口主要用于定义类的外部行为，并允许类实现这些行为。
接口类不能final类修饰，final修饰的类不可继承，这违背了接口定义的初衷

接口类不能private类修饰

接口类中不能含有构造函数，静态代码块
接口类和抽象类的区别
- 1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
- 2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
- 3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
- 4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
一个类只能继承一个类，但可以实现多个接口
接口之间也可以继承，例如接口A继承接口B，实现接口A的类必须实现全部抽象接口，包括在B接口中定义的抽象方法体

参考资料链接

接口排序案例

【Java】接口（超详细代码演示，速进）_java接口怎么写-优快云博客