【JAVA学习笔记】41

项目代码

https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter10/src/com/yinhai/interface_

一、快速入门

usb插槽就是现实中的接口。你可以把手机，相机，u盘都插在usb插槽上，而不用担心那个插槽是专门插哪个的，原因是做usb的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸，排线等等。

这样的设计需求在java编程/ php/.net/go中也是会大量存在的，程序就是一个世界，在现实世界存在的情况，在程序中也会出现。使用代码模拟。 interface01

public interface UsbInterface {//创建一个规范，相当于个法则，要想用接口就得有这两个方法
    public void start();

    public void stop();
}
//Phone 类实现UsbInterface
//解读1.即Phone类需要实现UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface{
    //实现接口，本质就是把接口的方法实现，相当于在规范内实现我自己类的方法
    public void start(){
        System.out.println("手机开始工作...");
    }
    public void stop(){
        System.out.println("手机停止工作...");
    }
}
public class Camera implements UsbInterface{//
    @Override
    public void start() {
        System.out.println("相机开始工作...");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作...");
    }
}
public class Computer {
    //编写一个方法
    public void work(UsbInterface usbInterface){//创建了个接口，用来接入对象的方法
        usbInterface.start();
        usbInterface.stop();
    }
}
public class Interface01 {
    public static void main(String[] args) {
        //创建手机相机对象
        Camera camera = new Camera();
        Phone phone = new Phone();
        Computer computer = new Computer();
        computer.work(phone);//把手机接入到电脑
        System.out.println("===============");
        computer.work(camera);
    }
}

二、基本介绍

接口就是给出一些没有实现的方法，封装到一起到某个类要使用的时候,在根据具体情况把那

些方法写出来。语法:

interface 接口名{

//属性

//方法（1.抽象方法 2默认实现方法 3静态方法）

}

class 类名 implements 接口{

自己属性；

自己方法；

必须实现的接口的抽象方法

}

1.在Jdk7.0前接口里的所有方法都没有方法体，即都是抽象方法。

2.Jdk8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

public interface AInterface {
    //写属性
    public int n1 = 10;
    //写方法
    public void hi();//在接口中可以省略abstract关键字
    //jdk 8 后可以有默认实现方法，但是需要使用default关键字修饰
    default public void ok() {
        System.out.println("OK");
    }
    //在jdk8后可以有静态方法
}
//1.如果一个类implements实现接口
//2.需要该接口的所有抽象方法都实现
class A implements AInterface{
    public void hi(){
        System.out.println("hi().....");
    }
}

三、深入讨论

对初学者讲，理解接的概念不算太难，难的是不知道什么时候使用接口，下面我例举几个应用场景:

1.说现在要制造战斗机.武装直升机专家只需把飞机需要的功能/规格定下来即可，然后让别的人具体实现就可。

2.说现在有一个项目经理，管理三个程序员,功能开发一个软件为了控制和管理软件项目经理可以定义一些接口，然后由程序员具体实现。

实际要求: 3个程序员，编写三个类，分别完成对Mysql,Oracle,DB2数据库的连接

public interface DBInterface { //项目经理

    public void connect();//连接方法
    public void close();//关闭连接
}
public class MysqlDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接mysql");
    }

    @Override
    public void close() {
        System.out.println("关闭mysql");
    }
}
//B程序员连接Oracle
public class OracleDB implements DBInterface{

    @Override
    public void connect() {
        System.out.println("连接oracle");
    }

    @Override
    public void close() {
        System.out.println("关闭oracle");
    }
}
public class Interface03 {
    public static void main(String[] args) {

        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }

    public static void t(DBInterface db) {
        db.connect();
        db.close();
    }
}

四、注意事项和细节

1.接口不能被实例化（接口实际上是特殊抽象类）

2.接口中所有的方法是public方法，接口中抽象方法，可以不用abstract 修饰:

实际上是abstract void aa();

3.一个普通类实现接口,就必须将该接口的所有方法都实现。

将光标放到红线使用alt+enter可以快速实现接口方法

4.抽象类实现接口，可以不用实现接口的方法。

5.一个类可以同时实现多个接口

6.接口中的属性只能是final的，而且是public static final修饰符。

比如:int a=1;实际上是public static finai int a=1; (必须初始化)

7.接口中属性的访向形式:接口名.属性名

8.一个接口不能继承其它的类但是可以继承多个别的接口

9.接口的修饰符只能是public和默认，这点和类的修饰符是一样的。

五、课堂练习

都正确，因为B实现了A接口，当然拥有接口的成员

六、接口和继承类之间的关系

可以看做继承类的补充

一个对象创建开始就应该继承有父类的内容，但是要有其他功能需要实现接口的方式拓展，可以理解为对java单继承机制的一种补充

public class ExtendsvsInterface {
    public static void main(String[] args) {
        LittleMonkey houzi = new LittleMonkey("houzi");
        houzi.climbing();
        houzi.swimming();
    }
}
interface Fishable{
    void swimming();
}
class Monkey{
    private String name;

    public Monkey(String name) {
        this.name = name;
    }
    public void climbing(){
        System.out.println(name + "会爬树");
    }

    public String getName() {
        return name;
    }
}
class LittleMonkey extends Monkey implements Fishable{

    public LittleMonkey(String name) {
        super(name);
    }
    public void swimming(){
        System.out.println(getName() + "通过学习，可以像鱼一样游泳");
    }
}

1.接口和继承解决的问题不同

继承的价值主要在于:解决代码的复用性和可维护性。

接口的价值主要在于:设计设计好各种规范(方法)，让其它类去实现这些方法。

2.接口比继承更加灵活

接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足like - a的关系。

3.接口在一定程度上实现代码解耦【即接口规范性和动态绑定】

七、多态特性

1.多态参数

在前面的Usb接口案例，Usb usb，既可以接收手机对象，又可以接收相机对象，就体现了接口多态(接口引用可以指向实现了接口的类的对象)

传入的对象可以是不同类型，只要是完成了实现接口的对象都可以传入

接口类型的变量If01 可以指向实现了IF接口的类的对象实例

2.多态数组

案例:给Usb数组中，存放Phone和相机对象，Phone类还有一个特有的方法call
() ,请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用
Phone特有方法call.

public class InterfacePolyArr {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定
            if(usbs[i] instanceof Phone_){//判断运行类型是phone
                ((Phone_) usbs[i]).call();//向下转型
            }
        }
    }
}

interface Usb {
    void work();
}

class Phone_ implements Usb {

    @Override
    public void work() {
        System.out.println("手机工作中");
    }
    public void call(){
        System.out.println("手机打电话中");
    }
}

class Camera_ implements Usb {
    @Override
    public void work() {
        System.out.println("相机工作中");
    }
}

3.接口存在多态传递现象

/*
 *  演示多态传递现象
 */
public class InterfacePolyPass {
    public static void main(String[] args) {
        IG ig = new Teacher();
        IH ih = new Teacher();
    }
}
interface IH{
    void hi();
}
interface IG extends IH{}
class Teacher implements IG{//也就是说想要实现IG接口，需要把IG的父类的方法也实现才能调用

    @Override
    public void hi() {
        
    }
}

八、课堂练习

interface A { // 1min看看
    int x = 0; //想到等价于 public static final int x = 0;
}

class B {
    int x = 1;
}

class C extends B implements A {
    public void pX() {
        System.out.println(x);//调用的x不知道是哪一个 考虑改为
        //System.out.println(super.x);
        //System.out.println(A.x);//A是静态的
    }

    public static void main(String[] args) {
        new C().pX();
    }
}

输出1