JAVA 接口

2021-07-14 10:44:18

接口

接口

一、基本介绍

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

快速入门

UsbInterface 接口

package com.hspedu.interface_;


public interface UsbInterface {//接口
    //规定接口的相关方法
    //这些都是人为规定的规定的，即规范..
    public void start();
    public void stop();
}

Phone.class

package com.hspedu.interface_;

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

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

Camera.class

package com.hspedu.interface_;

public class Camera implements UsbInterface{//实现接口，本质就是把接口的方法实现

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

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

Computer.class

package com.hspedu.interface_;

public class Computer {
    //编写一个方法,计算机工作
    public void work(UsbInterface usbInterface){
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

Interface01.java

package com.hspedu.interface_;

public class Interface01 {
    public static void main(String[] args) {
        //创建相机对象
        Camera camera = new Camera();
        Phone phone = new Phone();
        Computer computer = new Computer();
        computer.work(phone);//把手机接入到计算机
        computer.work(camera);//把相机接入到计算机

    }
}
//输出结果
//手机开始工作..
//手机停止工作..
//相机开始工作~~
//相机停止了工作~~

语法：

interface 接口{
	//属性
    //方法：分为以下三种
    1.抽象方法
    2.默认实现方法
    3.静态方法    
}

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

小结：

在Jdk7.0前接口里的所有方法都是没有方法体的，即都是抽象方法
Jdk8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现
- 现在基本上都是用的jdk8.0等以后的版本

二、应用场景

把需要的功能/规格定下来，让别人来具体实现即可
说现在有一个项目经理(段玉)管理三个程序员,功能开发一个软件为了控制和管理软件,项目经理可以定义一些接口，然后由程序员具体实现。(1.项目质量2.项目进度3.项目奖)参加工作
- 为了实现接口的统一调用

三、使用细节和注意事项

第一部分

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

package com.hspedu.interface_;

public class InterfaceDetail01 {
    public static void main(String[] args) {
//        new IA();
    }
}

//1.接口不能被实例化
//2.接口中的所有的方法是public方法，抽象方法abstract关键字可以省略
//3.一个普通类实现接口，就必须把接口中的抽象方法全部实现，可以使用alt+enter来解决
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA{
    void say();
    void hi();
}

class Cat implements IA{

    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
    //可以使用alt+enter来解决
}

abstract class Tiger implements IA{
     
}

第二部分

一个类同时可以实现多个接口
接口中的属性，都是public static final 的
- int n1 = 1等价于public static final int n1 = 1
接口中属性的访问形式：接口名.属性名
一个接口不能继承其他的类，但是可以继承多个别的接口
- interface A extend B.c{``}

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

package com.hspedu.interface_;

public class InterfaceDetail02 {
    public static void main(String[] args) {
        System.out.println(IB.n1);//证明 n1是静态的
//        IB.n1 = 200; 证明n1是不可以修改的常量，final来修饰的
//        Cannot assign a value to final variable 'n1'
    }
}

//一个接口不能继承其他的类，但是可以继承多个别的接口
interface ID extends IB,IC{

}

interface IB{
    int n1 = 100; //=> public static final int n1 = 10;
    void hi();
}

interface IC{
    void cry();
}

//一个类可以同时实现多个接口
class Pig implements IB,IC{

    @Override
    public void hi() {

    }

    @Override
    public void cry() {

    }
}

四、接口和继承的区别

小结：当子类继承了父类，就拥有了父类的一些功能，如果子类需要扩张功能，就能实现接口的方式来扩展

可以理解实现接口是Java 单继承机制的一种补充

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

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

接口的价值主要在于：设计，设计好各种规范(方法)，让其他类去实现这些方法。即更加灵活

2.接口比继承更加灵活

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

3.接口在一定程度上实现代码耦合

即接口的规范性+动态的绑定机制

五、接口的多态性

多态参数，只要要传入的对象实现了该形参的接口类型，就能通过使用

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

package com.hspedu.interface_;

public class InterfacePolyArr {
    public static void main(String[] args) {
        //多态数组 -> 接口类型的数组
        MyUsb [] myUsb = new MyUsb[2];
        myUsb[0] = new Phone_();
        myUsb[1] = new Camera_();
        for (int i = 0; i < myUsb.length; i++) {
            myUsb[i].start();//动态绑定
            myUsb[i].end();//动态绑定
            if (myUsb[i] instanceof Phone_){//判断它的运行类型是什么
                ((Phone_)myUsb[i]).cal();
            }
            System.out.println();
        }

    }

}

interface MyUsb{
    int n1 = 100;
    void start();
    void end();
}

class Phone_ implements MyUsb{
    public int n2 = 200;
    @Override
    public void start() {
        System.out.println("手机连接上了..");
    }

    @Override
    public void end() {
        System.out.println("手机断开了..");
    }

    public void cal(){
        System.out.println("我是手机..");
    }
}

class Camera_ implements MyUsb{
    public int n1 = 200;
    @Override
    public void start() {
        System.out.println("相机连接上了..");
    }

    @Override
    public void end() {
        System.out.println("相机断开了..");
    }
}

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

六、接口的多态传递

即如果B接口继承了A接口，C类(普通类)又实现了B接口，那么A和B接口类型的变量都可以指向C类的对象实例

码农公寓

接口