Java学习笔记10（面向对象三：接口）

接口：

暂时可以理解为是一种特殊的抽象类

接口是功能的集合，可以看作是一种数据类型，是比抽象类更抽象的“类”

接口只描述所应该具备的方法，并没有具体实现，具体实现由接口的实现类（相当于接口的子类）来完成

这样将功能的实现与定义分离，优化了程序设计

接口的成员方法全抽象，不能存在带有方法体的方法

接口中无法定义普通的成员变量，必须定义为常量

接口定义抽象方法有固定格式

一切事物皆有功能，即一切事物都有接口

接口的定义规则：

public interface MyInterface {
    public static final int a = 1;
    public abstract void function();
}

接口的实现类（类和类之间叫继承，类和接口之间叫实现）：

public class MyInterfaceImpl implements MyInterface{
    public void function(){
        System.out.println("实现类，重写接口方法");
    }
}

测试：

public class Test {

    public static void main(String[] args) {
        MyInterfaceImpl my = new MyInterfaceImpl();
        my.function();
    }

}

接口中成员变量的特点：

注意这里的public static final三个修饰词可以省略任意个数，但是效果不变，总是public static final，建议写全

public interface MyInter {
    //静态的可以用.方式访问
    //final表示不能被修改
    public static final int x = 3;
    
}

测试：

public class Test {

    public static void main(String[] args) {
        //静态的可以用.方式访问，具体关于static在后边讲
        System.out.println(MyInter.x);
    }
}

接口中成员方法的特点：

注意这里的public abstract也是选择性书写的，无论怎样效果都是public abstract，建议写全

public interface MyInter {
    public abstract void function();
}

实现类，实现接口，重写接口全部抽象方法，创建实现类对象

接口不可以创建对象

子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化，否则子类是一个抽象类

接口的多实现：

接口最重要的体现：解决多继承的弊端，将多继承这种机制在java中通过多实现完成了

解决安全隐患原理：接口中的方法全都是抽象的，没有主体，方法依赖实现类的重写才可以实现，因此没有安全问题

因此接口的多实现解决了单继承的局限性

举例：

接口A：

public interface A {
    public abstract void a();

    public abstract void c();
}

接口B：

public interface B {
    public abstract void a();

    public abstract void b();
}

多实现：

/*
 * 类C，同时实现两个接口，接口A，B
 * 作为实现类，C必须重写两个接口的所有抽象方法，才可以建立C类对象
 * */
public class C implements A, B {
    public void a() {
    }

    public void b() {
    }

    public void c() {
    }
}

类继承类的同时，还可以实现接口：

类D：

public abstract class D {
    public abstract void d();
}

C：

//在继承一个类(只能是一个)的同时，实现多个接口
public class C extends D implements A, B {
    public void a() {
    }

    public void b() {
    }

    public void c() {
    }

    public void d() {

    }
}

接口存在多继承：

由于接口的方法都是抽象的，所以不存在安全隐患

public interface A {
    public abstract void a();
}

public interface B {
    public abstract void b();
}

public interface C extends A,B{
    public abstract void c();
}

public class D implements C{
    public void a(){}
    public void b(){}
    public void c(){}
}

这里有一个有关java的问题：

java中到底存在多继承吗？

答：类没有多继承，接口之间存在多继承

接口的思想：

举例：电脑上有多个插口，这些插口可以插入相应的设备，因为这些设备生产的时候符合了这个插口的使用规则，否则无法插入使用

接口在开发中的好处：

1.接口的出现扩展了功能

2.接口其实就是暴漏出来的规则

3.接口的出现降低了耦合性，设备与设备之间实现了解耦（笔记本电脑USB插口是否被使用电脑都可以运行）

接口和抽象类的共同点：

1.都位于继承的顶端，用于被其他类实现或继承

2.都不能直接实例化对象

3.都包含抽象方法，其子类都必须覆写这些抽象方法

区别：

1.抽象类为部分方法提供实现，避免子类重复实现这些方法，提高代码的重用性；而接口只能包含抽象方法

2.一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口，接口弥补了java的单继承

思想方面的区别：

抽象类是这个事物中应该具备的内容，继承体系是一种is..a的关系

接口是这个事物中的额外内容，继承体系是一种like...a的关系

伪代码举例：class 贼 extends 人 implements 偷盗

贼本身是一个人，他可以偷盗，不是所有的人都偷盗

选用：

1.优先使用接口，尽量少用抽象类

2.需要定义子类的行为，又要为子类提供共性功能时，选用抽象类

综合案例（电脑）：

public interface USB {
    public abstract void open();
    public abstract void close();
}

public class Mouse implements USB{
    public void open(){
        System.out.println("开启鼠标");
    }
    
    public void close(){
        System.out.println("关闭鼠标");
    }
}

public class Keyboard implements USB{
    public void open(){
        System.out.println("开启键盘");
    }
    public void close(){
        System.out.println("关闭键盘");
    }
}

public class Computer {
    public void openComputer(){
        System.out.println("笔记本开机");
    }
    
    public void closeComputer(){
        System.out.println("笔记本关机");
    }
    public void useUSB(USB usb){
        usb.open();
        usb.close();
    }
    
}

public class Test {
    public static void main(String[] args) {
        //创建笔记本对象,调用笔记本的功能
        Computer com = new Computer();
        com.openComputer();
        
        //调用笔记本使用USB设备的方法
        //参数,是USB接口类型,接口不能建立对象
        //调用方法,传递USB接口的实现类的对象
        //Mouse m = new Mouse();
        com.useUSB(new Mouse());
        //使用USB设备,使用键盘
        com.useUSB(new Keyboard());
        
        com.closeComputer();
    }
}