接口

 

子类继承父类，自动拥有父类的功能，

需要扩展功能的话，需要用到接口

package com.Study.ByStd.InterFace_;

public class InterFace03 {
    public static void main(String[] args) {
        LittleMonkey littleMonkey = new LittleMonkey("大圣");
        littleMonkey.work();//这项功能来自父类
        littleMonkey.fly();//这个fly的功能来自接口（扩展功能）
    }
}
class monkey{
    private String name;

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

    public String getName() {
        return name;
    }

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

    public String tree(){
        return "在爬树";
    }
}
class LittleMonkey extends monkey implements bird{

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

    public void work(){
        System.out.println(getName()+super.tree());
        System.out.println(getName()+fly());
    }

    @Override
    public String fly() {
        return "能飞";
    }
}
interface bird{
    public String fly();
}

 

  

package com.Study.ByStd.InterFace_;

public class Computer {

    //相当于主设备生成一个接口插槽，别的设备可以通过这个插槽插入这个主设备
    //括号里面就是实现了USb...这个接口的类的对象实例
    public void work(USBinterface u1) {
        u1.start();
        u1.stop();
    }
}

package com.Study.ByStd.InterFace_;

public class InterFaceo1 {
    public static void main(String[] args) {
        //创建两个设备的对象
        Camera camera = new Camera();
        Phone phone = new Phone();

        //创建一个计算机
        Computer computer = new Computer();
        computer.work(phone);//相当于把手机接入计算机
        computer.work(camera);//相当于把相机接入计算机
    }
}

  （多态参数：Computer类里面的方法的参数用的是接口类的实例，等到main里面调用这个方法的时候，传入的参数可以是实现这个接口的类的对象）

package com.Study.ByStd.InterFace_;

public class InterFacePolymorphic {
    public static void main(String[] args) {
        //多态！
        //接口的对象实例是实现接口的类
        //相当于向上转型（父类的引用指向了子类的对象）
        FF f1 = new AA();
        f1 = new BB();
    }
}
interface FF{}
class AA implements FF{}
class BB implements FF{}

（所谓的多态就是接口的实例指向实现接口的类的对象） 

package com.Study.ByStd.InterFace_;

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

        //多态数组——>数组的类型是接口类，数组的具体数值是实现接口的类的具体实例
        Usbb[] u1 = new Usbb[2];
        u1[0] = new Myphone();
        u1[1] = new Camera_();

        //遍历接口数组
        for (int i = 0; i < u1.length; i++) {
            u1[i].work();

            //如何调用Myphone 类里面的特有方法？
            //用到类型判断instansof
            if (u1[i] instanceof Myphone){
                ((Myphone) u1[i]).call();//向下转型
            }
        }
    }
}
interface Usbb{
    void work();
}
class Myphone implements Usbb{
    @Override//实现接口的方法
    public void work() {
        System.out.println("手机工作");
    }

    public void call(){
        System.out.println("打电话");
    }
}
class Camera_ implements Usbb{
    @Override
    public void work() {
        System.out.println("相机工作");
    }


}

数组多态就是数组的类型是接口的类型，但是数组的具体的值是实现接口的类的实例

接口的多态就相当于接口可以相互继承

package com.Study.ByStd.InterFace_;

//接口的多态传递(接口与接口之间也可以相互继承)
public class InterfacePolyPass {
    public static void main(String[] args) {
        F1 f1 = new ff();
        // 当F2没有继承F1接口的时候，
        // F2和ff类没有任何关系，所以F2接口的对象不能指向ff类的对象实例
        F2 f2 = new ff();

        //本来ff类实现的是F2这个接口，但是F2继承了F1这个接口，
        // 所以相当于ff类把两个接口都实现了(ff类要把这两个接口的里面的标准都实现)


    }
}
interface F1{
    void play();

}
interface F2 extends F1{
    void hhh();
}
class ff implements F2{
    @Override
    public void play() {

    }

    @Override
    public void hhh() {

    }
}

如果一个类继承了一个父类，有实现了一个接口，那么像访问父类的属性用 super. 

想访问接口的属性(接口里面的属性是public static final 的)可以 接口类名.