接口01-Java

一、引入(快速入门案例)

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

【实现】
设备通过接口， 接入电脑开始工作。

（1） 一个接口 UsbInterface：人为规定了一系列的方法，类似现实生活中的USB规范、参数 大小
（2） 两个设备 Phone, Camera：相机实现接口，本质就是把接口的方法完成
（3） 一台电脑 Computer：通过接口调用方法

1、接口

	public interface UsbInterface { //接口
	    //规定接口的相关方法
	    public void start();//开始工作
	    public void stop();//停止工作
	}

2、两个设备

//解读1。即 Phone类需要实现 UsbInterface接口规定/声明的方法
class Phone implements UsbInterface {
    @Override
    public void start() {
        System.out.println("手机开始工作···");
    }

    @Override
    public void stop() {
        System.out.println("手机结束工作···");
    }
}

//如果想使用接口，就去实现它。
class Camera implements UsbInterface {
    @Override
    public void start() {
        System.out.println("Camera开始工作···");
    }

    @Override
    public void stop() {
        System.out.println("Camera结束工作···");
    }
}

3、一台电脑

class Computer {
    public void work(UsbInterface usbinterface) {
        usbinterface.start();
        usbinterface.stop();
    }
}

4、

    public static void main(String[] args) {
        //创建手机，相机对象
        Camera camera = new Camera();
        Phone phone = new Phone();
        //创建计算机
        Computer computer = new Computer();

        computer.work(camera);//把相机接入到计算机
        System.out.println("========");
        computer.work(phone);//把手机接入到计算机
    }

二、接口介绍

1、概念

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

2、语法

	interface 接口名 { 
		//属性
		//方法
	}

interface 中的方法只有三种
① 抽象方法，可以不写abstract
② 默认实现方法，需要使用default关键字修饰
③ 静态方法

	class 类名 implements 接口 { 
		自己的属性;
		自己的方法;
		必须实现的接口的抽象方法
	}
	
	implement ：实现的意思

小结:

1. 在Jdk7.0前接口里的所有方法都没有方法体，即都是抽象方法。
2. Jdk8.0后接口类可以有①静态方法，②默认方法（需要使用default关键字修饰），也就是说接口中可以有方法的具体实现。

public interface AInterface {
    //-------------------------jdk 7--------------------------
    //属性
    public int n1 = 10;
    //方法
    public void hi();
    //在接口中，抽象方法，可以省略abstract关键字
    
    //--------------------------------------------------------
    //在jdk8后，可以有默认实现方法，需要使用default关键字修饰
    default public void ok() {
        System.out.println("ok!");
    }
    //在jdk8后，可以有静态方法
    static public void cry(){
        System.out.println("cry!");
    }
}

三、应用场景

1. 说现在要制造战斗机，武装直升机。专家只需把飞机需要的功能/规格定下来即可，然后让别的人具体实现就可。
2. 说现在有一个项目经理，管理三个程序员，功能开发一个软件，为了控制和管理软件，项目经理可以定义一些接口，然后由程序员具体实现。

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

• 接口

//项目经理写的
public interface DBInterface {
    public void connect();//连接方法
    public void close();//断开方法
}

• 不同程序员实现不同数据库的连接、断开

//A程序员
class MySqlDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接MySQL···");
    }

    @Override
    public void close() {
        System.out.println("断开MySQL···");
    }
}

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

    @Override
    public void close() {
        System.out.println("断开Oracle···");
    }
}

• main

public class Interface03 {
    public static void main(String[] args) {
        MySqlDB mySqlDB = new MySqlDB();
        test1(mySqlDB);
        System.out.println("=========");
        OracleDB oracleDB = new OracleDB();
        test1(oracleDB);
    }
    
    public static void test1(DBInterface db) {
        db.connect();
        db.close();
    }
}

四、接口使用注意事项

1. 接口不能被实例化。
2. 接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰。

	void aaa();
	实际上是 abstract public void aaa();

3. 一个普通类实现接口，就必须将该接口的所有方法都实现。
   IDEA中的快捷键-快速查看有哪些需要实现。
   鼠标光标移动到红色波浪线处，然后 ALT+ENTER。

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

//接口
public interface DBInterface {
    public void connect();//连接方法
    public void close();//断开方法
}

//抽象类
abstract class Sqldb implements DBInterface{
    这样不会报错。
}

5. 一个类同时可以实现多个接口。[举例a.见后文]
   和继承区分：继承是单一继承。
6. 接口中的属性，只能是final的，而且是public static final修饰符。[举例b.见后文]
   比如：

	int a=1;
	实际上是 public static final int a=1; (必须初始化)

7. 接口中属性的访问形式：接口名.属性名。
8. 接口不能继承其它的类，但是可以继承多个别的接口。[举例c.]

	interface A extends B,C {}

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

---

• 举例
• a.一个类同时可以实现多个接口

interface IB {
    void hi(); //实际上是 abstract public void hi();
}
interface IC {
    void hello();
}

class Pig implements IB,IC {

    @Override
    public void hi() {

    }

    @Override
    public void hello() {

    }
}

• b.接口中的属性，只能是final的

	interface IB {
    	int n1 = 1;
    }
	实际上是 public static final int a=1; (必须初始化)

（1）证明 static：
可以通过一个【”类名“/”接口名“ .属性访问】，就是静态的含义。

	 public static void main(String[] args) {
	        System.out.println(IB.n1);//说明n1是static
	 }

（2）证明 final：

（3）证明 public：【反证法】

证明不是protected、private：
证明不是默认：用包外的类调用，如果可以调用，就证明不是默认的。

因为 import 路径不会写，所以暂时没有验证。。。

• c.接口继承其他接口

interface IB {
    void hi(); 
}
interface IC {
    void hello();
}
// 接口继承其他接口
interface ID extends IB,IC {
    
}

五、练习

题1

语法是否正确,如果正确,输出什么?

	interface A{
		int a=23;
	}
	class B implements A{
	}
	
	【main】中:
	B b=new B();
	System.out.println(b.a);
	System.out.println(A.a);
	System.out.println(B.a);

我的答案：
b.a 错
A.a 对
B.a 错

分析:
① int a=23; 等价于 public static final int a=23;
② class B implements A正确，因为目前的接口A中没有抽象方法。
③ b.a 正确 =>23
④ A.a 静态，23
⑤ B.a 正确 B实现了A，当然可以使用其中的属性。

本笔记是对韩顺平老师的Java课程做出的梳理。方便本人和观看者进行复习。
课程请见： https://www.bilibili.com/video/BV1fh411y7R8/?spm_id_from=333.999.0.0&vd_source=ceab44fb5c1365a19cb488ab650bab03