接口（interface)的实现

接口（interface)的实现

usb插槽就相当于现实中的接口。其实现实生活和编程相对应的，即程序就是事件。

1.java中的接口是怎么实现的呢？

接口就是给出一些没有实现的方法，到了某个类要使用的时候就去实现他

语法：

interface 接口名{

//属性

//方法 1.抽象方法  jdk8:之后 2.默认实现方法 3.静态方法

}
class 类名 implements 接口{

//自己属性

//自己方法

必须实现接口的抽象方法但抽象方法的abstract可以省略

}

小结：

jdk7.0:方法都是抽象方法

jdk8.0:有静态方法和默认方法

1. 定义了一个接口，类似于规范
2. 相机和手机分别实现这个接口，本质就是把接口的方法实现
3. 通过接口来调用方法

代码演示：

1.先写一个统一实现的接口interface usbinterface

说明：接口也是一个特殊的类

public interface usbinterface { //接口
    //规定的接口的相关方法 且在jdk7中方法都是抽象方法
     public abstract void start();
    public abstract void stop();
}

2.再写两个类，Phone(手机)类和Camera(相机)类分别实现这个接口的抽象方法

Phone(手机)类：用implements关键词对应这个接口

public class Phone implements usbinterface {  //phon 这个类实现usb这个接口
    //phone这个类需要去实现这个接口的 规定和声明的方法

    @Override
    public void start() {
        System.out.println("手机开始工作！");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作！");
    }
}

Camera(相机)类：

public class Camera implements usbinterface {
    @Override
    public void start() {
        System.out.println("相机开始工作！");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作！");
    }
}

3.写一个Computer电脑类，参数为接口定义的方法，来调用接口中实现的了抽象方法、

public class Computer {
    //编写一个方法
    public void work(usbinterface usbinterface){ //定义接口
        usbinterface.start();
        usbinterface.stop();
    }
}

4.测试类

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);//把相机接入到计算机
    }

}

5.结果：

2.接口编程

测试案例2：

项目经理需要实现mysql和oracle的连接和关闭工作，定义了如下接口

public interface DBinterface { //项目经理

    public void connect();
    public void close();
}

需要两个程序员去实现它，然后自己就跑出喝奶茶了

实现mysql的程序员：

public class mysql implements DBinterface {
    @Override
    public void connect() {
        System.out.println("链接mysql!");
    }

    @Override
    public void close() {
        System.out.println("关闭mysql!");
    }
}

实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) {
        mysql mysql = new mysql();
        t(mysql);
        System.out.println("============");
        oracledb oracledb = new oracledb();
        t(oracledb);
    }
    public static void t(DBinterface db){
        db.connect();
        db.close();
    }
}

结果：

问题：

如果项目经理不去定义接口类的话，两个程序员就会自由发挥，分别写出不同的方法，这样测试的时候，就会存在代码的复杂和冗余，相反定义了接口类，程序员就必须遵从接口中的抽象方法，进行实现即可，测试的时候分别进行写对象调用就完事了。

3.接口的注意事项

事项一：

• 接口是一种抽象的概念不能被实例化。
• 接口中的方法都是public的，可以不用abstract修饰，可以省略abstract
• 一个普通类实现接口，就必须将该接口的所有方法都实现
• 抽象类实现接口，可以不使用接口方法

public class interface04 {
    public static void main(String[] args) {

    }
}
interface IA{
    void say(); //可以省略abstract
    void hi(); //修饰符 public protected 默认 private 这里的方法是public的
}
class cat implements IA{ //快捷键 ait+enter 实现所有抽象方法 不然会报错

    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
}
//抽象类
abstract class tiger implements IA{
    //可以不实现接口的方法
}

事项二

1. 一个类可以实现多个接口
2. 接口中的属性都是Final的，而且是public static final修饰符
3. 接口中的属性的访问形式：接口名.属性名
4. 接口不能继承其他的类，但是可以继承多个别的接口
5. 接口的修饰符只能是Public和默认的，跟类的修饰符是一样的

public class interface05 {
    public static void main(String[] args) {
        System.out.println(IB.n1); //n1 为static
//        IB.n1 =1;
    }
}
interface IB{
    int n1 = 100;//public static final int n1  = 100;
    void h1();
}
interface IC{
    void say();
}
interface ID extends IB,IC{
    
}
class pig implements IB,IC{

    @Override
    public void h1() {

    }

    @Override
    public void say() {

    }
}

接口中的属性都是Final的，而且是public static final修饰符处理结果：

原码拉取地址：https://github.com/Ronronner859/Java/tree/master