14 接口

配套视频教程

本文B站配套视频教程

实现防盗门的功能

第一种方案

• 门有“开”和“关”的功能，锁有“上锁”和“开锁”的功能
• 将门和锁分别定义为抽象类

防盗门可以继承门的同时又继承锁吗？

第二种方案

• 将门定义为抽象类，锁定义为接口
• 防盗门继承门，实现锁的接口

接口

public interface MyInterface {
    public void foo()；
    //其他方法
}

必须知道的接口特性

• 接口不可以被实例化
• 实现类必须实现接口的所有方法
• 实现类可以实现多个接口
• 接口中的变量都是静态常量

用程序描述USB接口

image.png

USB接口本身没有实现任何功能
USB接口规定了数据传输的要求
USB接口可以被多种USB设备实现

接口是一种标准，一种协议，一种规范，规定了2个方面。usb接口为例，
规定了usb插槽和usb插头2方面，插槽不按标准生产，插头插不进去;插头不按标准生产，插不进插槽。
接口interface，定义了一系列的方法，同样规定了2个方面，其实是一种约束
1.实现接口的类（比如DepenseDoor类），必须按方法声明（方法名，方法参数，方法返回值）实现这些方法;
2.使用实现了接口类的那些类（比如测试类TestInterface），
必须按接口中的方法声明（方法名，方法参数，方法返回值）去使用这些方法;

• 编写USB接口
  根据需求设计方法
• 实现USB接口
  实现所有方法
• 使用USB接口
  用多态的方式使用

1定义usb接口

public interface UsbInterface {
    /**
     * USB接口提供服务。
     */
    void service();
}

2 实现接口

public class UDisk implements UsbInterface {
    public void service() {
        System.out.println("连接USB口，开始传输数据。");
    }
}

使用接口

UsbInterface uDisk = new UDisk();
uDisk.service();

接口表示一种能力（体现在接口的方法上 ）

做这项工作需要一个程序员
编程是一种“能力”，不关心具体是谁（具体的实现类是谁）

面向接口编程

设计程序时
关心实现类有何能力，而不关心实现细节
面向接口的约定而不考虑接口的具体实现

实例

某软件公司，需要2个能编程的“人”开发一个刚接到的项目

//编程接口
public interface IProgram {
    public void program();
}

public class Person {

}

//程序员
public class Programmer extends Person implements IProgram {
    @Override
    public void program() {
        System.out.println("我编编编");
    }
}

//机器人类
public class Robot implements IProgram{
    @Override
    public void program() {
        System.out.println("我编编编，但是我不累");
    }
}

//软件公司类
public class SoftwareCommany {
    public static void main(String[] args) {
        //需要2个能编程的“人”开发一个刚接到的项目
        IProgram[] iPrograms = new IProgram[2];//数组里放得是2个能编程的“人”
        iPrograms[0] = new Robot();
        iPrograms[1] = new Programmer();//只要是实现了接口的类，都可以看成是接口类型

        for(int i = 0; i < iPrograms.length; i++)
        {
            iPrograms[i].program();//让他们编程序
        }

    }
}

一个更复杂的实例

对象自定义属性排序实现
比较接口

public interface MyCompareable {
    public int CompareTo(Object obj);
}

一个汽车类实现了MyCompareable 接口

public class Car  implements MyCompareable{
    int id;
    String name;

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public Car(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public int CompareTo(Object obj) {
        Car car = (Car)obj;
        return this.id - car.id;
    }
}

排序类

public class BubbleSort {

    public static void endSort(Car[] arr2) {

        System.out.println("原序列");
        System.out.println(Arrays.toString(arr2));
        //两次for循环解决
        for(int i = 0; i < arr2.length-1; i++){
            for(int j=0; j < arr2.length-1-i;j++){
                if(arr2[j].CompareTo(arr2[j+1])>0){
                    Car temp = arr2[j];
                    arr2[j] = arr2[j+1];
                    arr2[j+1] = temp;
                }
            }
        }
        System.out.println();
        System.out.println("两层循环排序");
        System.out.println(Arrays.toString(arr2));
    }

}

主方法

public class Main {

    public static void main(String[] args) throws ClassNotFoundException, SQLException {

        Car[] cars = new Car[3];
        cars[0] = new Car(11,"baima");
        cars[1] = new Car(15,"benci");
        cars[2] = new Car(13,"audi");
        BubbleSort.endSort(cars);

    }


}