Java基础 8.18

1.接口注意事项和细节

1. 接口不能被实例化
2. 接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
3. 一个普通类实现接口，就必须将该接口的所有方法都实现（快捷键alt+enter）
4. 抽象类实现接口，可以不用实现接口的方法
5. 一个类同时可以实现多个接口
6. 接口中的属性，只能是final的，而且是 public static final 修饰符 比如：int a=1; 实际上是 public static final int a=1;(必须初始化)
7. 接口中属性的访问形式：接口名.属性名
8. 接口不能继承其它的类，但是可以继承多个别的接口

2.接口和类继承之间的比较

package com.logic.interface_;

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

interface Fish {
    void swimming();
}

interface Bird {
    void flying();
}

class Monkey {
    private String name;

    public Monkey(String name) {
        this.name = name;
    }

    public void climbing() {
        System.out.println("猴子会爬树...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class LittleMonkey extends Monkey implements Fish, Bird {
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + "通过学习在游泳...");
    }

    @Override
    public void flying() {
        System.out.println(getName() + "通过学习在飞翔...");
    }
}

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

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

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

接口比继承更加灵活

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

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

3.接口的多态

多态参数(前面案例体现)

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

多态数组

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

package com.logic.interface_;

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

        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给Usb数组中，存放 Phone  和  相机对象，Phone类还有一个特有的方法call（），
        请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，
        还需要调用Phone 特有方法 call
         */
        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("手机可以打电话...");
    }

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

class Camera_ implements Usb {

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

接口存在多态传递现象

package com.logic.interface_;

/**
 * 演示多态传递现象
 */
public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG 继承了 IH 接口，而Teacher 类实现了 IG接口
        //那么，实际上就相当于 Teacher 类也实现了 IH接口.
        //这就是所谓的 接口多态传递现象.
        IH ih = new Teacher();
    }
}

interface IH {
    void hi();
}

interface IG extends IH {
}

class Teacher implements IG {
    @Override
    public void hi() {
    }
}