JAVA 接口专题（韩顺平）

我是康康康

已于 2022-04-16 19:17:02 修改

阅读量607

点赞数 2

文章标签： java 开发语言

于 2022-04-16 10:26:22 首次发布

本文链接：https://blog.csdn.net/wztmds/article/details/124204158

版权

3.接口在一定程度上实现代码解耦（即：接口规范性+动态绑定机制）

一.基本介绍

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

语法：

interface 接口名{

//属性

//抽象方法}

class 类名 implements 接口{

自己属性；

自己方法；（必须实现接口的抽象方法）}

小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，jdk8后接口类中可以有静态方法，默认方法。接口体现了程序设计的多态和高内聚低耦合的设计思想。

这里解释一下高内聚低耦合：1.一个功能模块内功能要联系密切；2.把联系不密切的功能放在不同的功能模块内；3.尽量减少模块间的联系——百度百科。

二.快速入门案例

public interface UsbInterface { //接口
    //规定接口的相关方法,老师规定的.即规范...
    public void start();
    public void stop();
}


public class Phone implements UsbInterface{
    @Override
    public void start() {
        System.out.println("手机开始工作。。。");
    }

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

public class Camera implements UsbInterface{
    @Override
    public void start() {

    }

    @Override
    public void stop() {

    }//实现接口,就是把接口方法实现

}

public class Computer {
    //编写一个方法, 计算机工作
    //解读:
    //1. UsbInterface usbInterface 形参是接口类型 UsbInterface
    //2. 看到 接收 实现了 UsbInterface接口的类的对象实例
    public void work(UsbInterface usbInterface) {//体现了多态的思想
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

public class interface01_ {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Camera camera = new Camera();

        phone.start();
        Computer computer = new Computer();

        computer.work(phone);
    }
}

三.使用接口的好处

1.当多人开发时，我负责A模块，需要调用一个T方法，这时我开始编写T方法，但是负责其它模块的人也需要调用T方法，他们也编写T方法，但是他们编写的方法名可能不是T，所以如果不用接口，当我调用调他们的方法时，还需要确定和我编写的T方法是不是一样的，开发效率不高

2.java不像c++可以进行多继承，接口可以来弥补这一不足

3.抽象类是实现抽象的，接口也是实现抽象的，二者的区别在于，抽象类内部可能包含非final的变量，接口中存在的变量一定是final，public,static的

四.使用细节

1）接口不能被实例化

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

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

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

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

//1.接口不能被实例化
//2.接口中所有的方法是 public方法,  接口中抽象方法，可以不用abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用alt+enter来解决
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();//修饰符 public protected 默认 private
    void hi();
}
class Cat implements IA{
    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
}
abstract class Tiger implements  IA {

}

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

interface IB {
//接口中的属性,只能是 final 的，而且是 public static final 修饰符
int n1 = 10; //等价 public static final int n1 = 10;
void hi();
}
interface IC {
void say();
}


class Pig implements IB,IC {
@Override
public void hi() {
}
@Override
public void say() {
}
}

6）接口中的属性，只能是final，而且是public static final修饰符，案例如上述5）的代码

7）接口中属性的访问形式：接口名.属性名

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

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

五.接口和继承的区别

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

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

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

2.接口比继承更加灵活

继承是满足is-a 的关系，而接口只需要满足like-a 的关系

3.接口在一定程度上实现代码解耦（即：接口规范性+动态绑定机制）

小结：当子类继承了父类，就自动的拥有父类的功能

如果子类需要扩展功能，可以通过实现接口的方式扩展

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

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("Monkey");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();
    }
}

class Monkey {
    private String name;

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

    public String getName() {
        return name;
    }
}

//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}


class LittleMonkey extends Monkey implements Fishable,Birdable {

    public LittleMonkey(String name) {
        super(name);
    }

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

    @Override
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

六.接口的多态性

1.多态参数

案例代码可以参考快速入门的代码案例

UsbInterface usb 既可以接受手机对象，也可以接受相机对象就体现了接口的多态性（接口引用可以指向实现接口的类的对象）

2.多态数组

案例：Usb数组中，存放phone和camera对象，phone类中还有一个特有的方法call（），遍历Usb数组，如果是phone对象，处理调用Usb接口定义的方法外，还需要调用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 {
    public void call() {
        System.out.println("手机可以打电话...");
    }//phone独特的方法

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

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

3. 多态的传递性

interface IH {
void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
@Override
public void hi() {
}
}


IG ig = new Teacher();
//如果 IG 继承了 IH 接口，而 Teacher 类实现了 IG 接口
//那么，实际上就相当于 Teacher 类也实现了 IH 接口