1.接口

一.理解接口

1. 硬件接口：指的是两个硬件设备之间的连接方式。硬件接口既包括物理上的接口，还包括逻辑上的数据
   数据传输协议。
2. 软件接口：程序代码，特殊的类。表示一种规范，是具有N个方法的特征集合。
   在封装时，显示器封装了很多电子元件等，最终向外暴露数据交换的孔–>接口。
3. 目的：设备和设备之间通信桥梁。
4. 在Java中，接口表示一种规范/约束/要求实现者必须遵循该规范。
   接口只是定义了类应当遵循的规范，却不关心这些类的内部数据和其功能的实现细节。站在程序
   角度上说接口只是规定了类里面必须提供的方法，从而分离了规范和实现，增强了系统的可拓展性
   和可维护性。
5. 面向接口编程：
   接口和实现类体现了真正的多态。

二.接口的定义和使用

1. Java中的接口：
   多个抽象类的抽象就是接口。
   在Java中，最小的程序单元就是类，接口其实是一个特殊的类。

2. Java中的接口表示规范，用于定义一组抽象方法，表示某一类事物必须具备的功能，要求实现类必
   须来实现该接口并提供方法实现。

3. 定义类语法： [public] class 类名{}

4. 定义接口语法： [public] interface 类名{}

5. 接口的起名问题：表示具有某些能力的，有人习惯以able/handler结尾。Walkable，表示可以行
   走的能力。

6. 有的公司或者个人习惯习惯以I开头表示接口：IWalkable.java
   成功编译之后，和类一样，有一份字节码文件。

7. 接口存在的成员：

   1. 接口中没有构造器：推论：接口不能创建对象（不能new），不能定义普通方法。
   2. 接口中定义的成员变量，实质是全局静态常量，默认使用public static final来修饰。

   public static final String NAME = "234";
   

   3. 接口中定义的方法都是公共的抽象方法，默认使用public abstract来修饰。
      public abstract void walk();一般的，在接口中定义方法不使用修饰符。
   4. 接口中定义的内部类都是公共的静态内部类。默认使用public static 修饰
      public static interface ABC{}
   5. 标志接口：接口中没有任何成员，就仅仅是一个接口的定义，就是一个标志，其他的类实现该接口，
      就是属于该家族，可以通过第三方代码赋予该接口实现类特殊的功能。
   6. 常量接口：有人喜欢使用接口封装有多个常量信息，我们称之为常量接口，其目的和常量类一样。

三.接口的特点

1. 没有构造方法，一不能显示定义构造器，不能实例化。
2. 接口只能继承接口，不能继承类，且接口支持多继承（类是单继承）
3. 接口里的方法全是抽象的，默认修饰符public abstract
4. 接口里的字段全是全局静态常量，模式修饰符public static final
5. 接口里的内部类全是静态的，默认修饰符public static
6. 类和类之间存在继承关系：使用extends来表示
7. 接口和接口之间只能是继承关系：使用extends来表示
8. 接口和实现类之间只能是实现关系：使用implements来表示。

四.接口的实现类

1. 接口仅仅只是定义了某一类事物应该具有某些功能，但是没有提供任何实现。
   此时，我们的提供类，再让该类去实现接口，并覆盖接口中的方法，从而实现类接口中定义的功能。
2. 接口和实现类之间的关系，严格上称之为“实现关系”，使用implements来表示
   但是在开发，有很好为了方便也把实现关系称之为特殊继承关系。
3. 所以可以这样理解：接口是实现类的父类，实现类就是接口的子类
4. 接口 变量 = 创建实现类对象；//体现了多态思想
5. 接口和实现类的多态关系才是我们见的最多的
6. 类实现接口的语法：一个类可以实现多个接口，从而也弥补不了类的单继承问题。
7. [修饰符] class 实现类名 extends 父类 implements 接口1，接口2{}
8. 注意：接口中的方法是公共的抽象的，所以实现类必须覆盖接口中的方法，并且方法必须使用public
   修饰。

新建InterfaceDemo.java

//接口Demo
//动物接口
interface Animalable
{
}
//爬行动物接口
interface IWalkable extends Animalable
{
    void walk();
}
class Animal
{
}
//猫
class Cat extends Animal implements IWalkable
{
    public void walk(){
    System.out.println("走猫步");
    }
}
class InterfaceDemo
{
public static void main(String[] args)
{
    //不推荐
    Cat c = new Cat();
    c.walk();
    IWalkable w = new Cat();//面向接口编程，存在多态
    w.walk();//体现多态特征:执行Cat类中的walk方法
    }
}

五.类和接口的关系图

修改InterfaceDemo.java

//接口Demo
//动物接口
interface Animalable
{
}
//爬行动物接口
interface IWalkable extends Animalable
{
    void walk();
}
//水类接口
interface ISwimable extends Animalable
{
    void swim();
}
//动物类
class Animal
{
}
class Fish extends Animal implements ISwimable
{ 
    public void swim(){
        System.out.println("游啊游...");
        }
}
...
//青蛙
class Frog extends Animal implements ISwimable,IWalkable
{ 
    public void swim(){
        System.out.println("蛙泳...");
    }
    public void walk(){
     System.out.println("蛙跳");
    }
} 
class InterfaceDemo
{
    public static void main(String[] args)
    {
        ...
        ISwimable s = new Fish();
        s.swim();
        Frog f = new Frog();
        f.walk();
        f.swim();
    }
}

六.接口和抽象类的区别

1. 相同：
   1. 都位于继承的顶端，用于被其他实现或继承
   2. 都不能实例化
   3. 都可以定义抽象方法，其子类都必须覆盖写这些抽象方法
2. 区别：
   1. 接口没有构造方法，抽象类有构造方法
   2. 抽象类可以包含普通方法和抽象方法，接口只能包含抽象方法；（Java8之前）
   3. 一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口（接口弥补了Java的单继承）
   4. 成员变量：接口里默认是public static final，抽象类是默认包权限
   5. 方法：接口默认是public abstract，抽象类默认是包访问权限
   6. 内部类：接口里默认是public static ，抽象类默认是包访问权限。
3. 如果接口和抽象类可以完成相同的功能，尽量使用接口，面向接口编程。
   设计模式：接口和抽象类集合使用的（适配器模式）

七.面向接口编程

1. 多态的好处：把实现类对象赋值给接口类型变量，屏蔽了不同实现类之间差异，从而可以实现通用编程

新建USBDemo.java

//面向接口编程思想
//USB接口
interface IUSB
{
    void doWork();
}
//打印机
class Printer implements IUSB
{
    public void doWork(){
        System.out.println("正在为主人打印中.....");
    }
}
//鼠标
class Mouse implements IUSB
{
    public void doWork(){
        System.out.println("正在为主人移动中......");
    }
}
//主板
class Mainboard
{
    private static IUSB[] usbs = new IUSB[6];
    private static int index;
    public static void plugin(IUSB usb){
        if (index > 5)
        {
            System.out.println("插槽已满");
            return;
        }
    usbs[index] = usb;
    index ++;
}
public static void doWork(){
    for (IUSB usb:usbs )
    {
        if (usb == null)
        {
            return;
        }
    usb.doWork();
    }
}
}
class USBDemo
{
    public static void main(String[] args)
    {
        IUSB m = new Mouse();
        IUSB p = new Printer();
        Mainboard.plugin(m);
        Mainboard.plugin(p);
        Mainboard.plugin(m);
        Mainboard.plugin(m);
        Mainboard.plugin(m);
        Mainboard.plugin(m);
        Mainboard.plugin(m);
        Mainboard.doWork();
    }
}