Java面向对象与接口¶

约 1008 个字 113 行代码预计阅读时间 5 分钟

接口介绍¶

在Java中，除了有抽象类，还有与抽象类类似的特殊类型，称为接口，接口有以下几种特点：

实现了接口，必须有对应的实现类，因为接口本身不可以实例化对象
接口中的成员方法在JDK7及之前只有抽象方法，即public abstract，如果不显式写public abstract，默认成员方法也会有该修饰；在JDK8时，新增了默认方法和静态方法，即public default和public static，在接口中可以显式写default，但是在实现类中不可以显示写default；在JDK9及之后，新增了私有成员方法，但是不常用
接口中的成员变量在JDK7及之前只有public static final，被final修饰的成员变量相当于是常量，不可以修改和二次赋值，所以必须在初始化时给定初始值。被final修饰的成员变量的变量名建议全大写，因为一般被当做常量
接口可以被多个实现类实现，一个实现类可以实现多个接口，即public class InterfaceImpl implements InterfaceA，InterfaceB{}
接口可以实现继承多个接口，此时实现类必须重写所有的抽象方法，即public interface InterfaceA extends InterfaceB，InterfaceC{}
一个子类可以在继承一个父类的同时实现一个或者多个接口，即public class Derived extends Base implements InterfaceA，InterfaceB{}

定义接口和实现类¶

在Java中，接口和类一样，只是将class替换成interface，基本格式如下：

Java
public interface 接口名{
    接口体
}

创建了接口之后，就需要有对应的实现类，否则该接口就没有存在的意义

实现接口的类需要使用implements关键字，基本格式如下：

Java
public class 类名 interface 接口名{
    重写接口方法
}

例如下面的代码实例：

Java
// 定义接口
public interface test_interface {
    public abstract void method();
}

// 实现接口 
public class test_interfaceImpl implements test_interface{
    @Override
    public void method() {

    }
}

接口中的方法¶

抽象方法¶

JDK7开始默认情况下，接口中的所有方法都是抽象方法，即默认带有public abstract修饰，在定义时可以显式写public abstract，也可以不显式写

当接口创建了抽象方法，则实现类必须要重写接口的抽象方法，否则编译报错。实现类重写了接口中的方法后，可以通过创建对象调用重写接口的方法

Java
// 定义接口
public interface test_interface {
    public abstract void method();
}

// 实现接口 
public class test_interfaceImpl implements test_interface{
    @Override
    public void method() {
        System.out.println("实现类重写的方法");
    }
}

// 测试
public class test {
    public static void main(String[] args) {
        // 实现类创建对象
        test_interfaceImpl testInterface = new test_interfaceImpl();
        // 调用重写的方法
        testInterface.method();
    }
}

默认方法¶

在JDK8及之后出现的方法，该方法存在方法体，实现类可以选择不重写，也可以选择重写

Java
// 接口
public interface test_interface {
    public default void method01(){
        System.out.println("接口中的默认方法");
    }
}

// 测试
public class test {
    public static void main(String[] args) {
        test_interfaceImpl testInterface = new test_interfaceImpl();
        // 调用接口类的默认方法
        testInterface.method01();
    }
}

但是如果一个实现类实现了多个接口，并且多个接口中均有一个完全相同（函数名、形参、返回值类型）的默认方法，此时实现类必须要重写默认方法，但是只需要重写一个，并且实现类重写的默认方法不可以显式写default

Java
// 接口1
public interface test_interface {
    public abstract void method();
    public default void method01(){
        System.out.println("接口中的默认方法");
    }
}

// 接口2
public interface test_interface_1 {
    public default void method01(){
        System.out.println("接口1中的默认方法");
    }
}

// 实现类
public class test_interfaceImpl implements test_interface， test_interface_1{
    // 子类必须重写一个default方法，并且重写方法不能带default
    @Override
    public void method01() {
        System.out.println("实现类重写的默认方法");
    }
}

// 测试
public class test {
    public static void main(String[] args) {
        test_interfaceImpl testInterface = new test_interfaceImpl();
        // 调用重写后的默认方法
        testInterface.method01();
    }
}

静态方法¶

静态方法因为不需要创建对象，直接使用类名调用，所以只需要使用接口直接调用即可，并且因为静态方法不能重写，所以实现类实现了多个接口也不需要重写，例如：

Java
// 接口
public interface test_interface {
    public static void method02(){
        System.out.println("接口中的静态方法");
    }
}

// 测试
public class test {
    public static void main(String[] args) {
        // 接口直接调用静态方法
        test_interface.method02();
    }
}

成员变量¶

默认被修饰为public static final，可以显式写public static final，也可以不显式写

Java
// 接口
public interface test_interface {
    public static final int NUM1 = 100;
}

// 测试
public class test {
    public static void main(String[] args) {
        // 接口调用静态变量
        System.out.println(test_interface.NUM1);
    }
}

接口和抽象类的区别¶

相同点:

都位于继承体系的顶端，用于被其他类实现或者继承
都不能new
都包含抽象方法，其子类或者实现类都必须重写这些抽象方法

不同点:

抽象类:一般作为父类使用，可以有成员变量，构造，成员方法，抽象方法等
接口:成员单一，一般抽取接口，抽取的都是方法，视为功能的大集合
类不能多继承，但是接口可以

实际应用：一般接口用于定义常用的方法，被实现类实现，从而实现对应满足需要使用的方法，而继承抽象类一般是继承共有的属性，可以使子类拥有成员变量等属性