java基础[接口]

         接口作用：将两个不同的东西连接起来，让他们共同去工作！

        具体类：定义某一具体的事物；

        抽象类：定义某一类不同种的事物；

        接口：定义不同类型的不同种事物，但是却有共同的行为，注重事物的行为，而不是事物的种类。接口不是类，是一个特殊的存在。接口和类是并列的关系。在接口中的方法，需要定义为抽象公共方法，属性需要定义为全局常量（public static final）【基本不用】，接口是抽象的极致。在抽象类中可以直接定义方法：返回值 + 方法名即可。接口没有构造方法。

package com.hike.javase.interfacetest;

public interface Flayer {

    //抽象类中的方法都为全局常量 public static finall
    int num = 10;

    //public abstract void takeOff();
    void takeOff();

    public void fly();

    void land();
}

package com.hike.javase.interfacetest;

/**
 * Plane相当于子类，Flayer相当于父类
 */
public class Plane implements Flayer {
    public void takeOff(){
        System.out.println("飞机起飞了");
    }

    public void fly(){
        System.out.println("飞机在天空中飞");
    }

    public void land(){
        System.out.println("飞机着陆了");
    }

    public void addOil(){
        System.out.println("飞机要加油");
    }
}

package com.hike.javase.interfacetest;

/**
 * 接口不能实例化对象，但是可以子类可以实现接口,只能实现，不能继承
 */
public class FlayerTest {
    public static void main(String[] args) {

        Plane plane = new Plane();  //本态调用

        plane.takeOff();
        plane.fly();
        plane.land();
        plane.addOil();//类中私有方法，不实用多态可以调用

        Flayer flayer = new Plane(); //多态调用：子类对象可以看做是父类使用
        flayer.takeOff();
        flayer.fly();
        flayer.land();
       // flayer.addOil(); 多态不可以调用类的私有方法
    }
}

        练习：定义一个USB接口，定义三个方法，连接，工作，断开，在子类中实现它们，并完成测试。

package com.hike.javase.interfacetest;

public interface USB {

    void connect();

    void work();

    void disconnect();
}

package com.hike.javase.interfacetest;

public class Udisk implements USB{
    @Override
    public void connect() {
        System.out.println("USB正在连接");
    }

    @Override
    public void work() {
        System.out.println("USB正在工作");
    }

    @Override
    public void disconnect() {
        System.out.println("USB正在断开");
    }
}

package com.hike.javase.interfacetest;

public class USBTest {
    public static void main(String[] args) {
        Udisk udisk = new Udisk();
        udisk.connect();
        udisk.work();
        udisk.disconnect();

        USB usb = new Udisk();
        usb.connect();
        usb.work();
        usb.disconnect();
    }
}

        抽象类可以包含抽象方法，所以实现接口时可以对其抽象方法不予实现。

        子类可以同时继承父类并实现接口。public class Bird extends Pet implements Flayer{}。无形中子类同时间接有两个父类，间接实现了多继承。

        java中不能多继承的原因：如果多个父类中有相同的test（）方法，那么会同时继承这三个test（）方法，当调用test（）时，会出现混乱，所以java使用了接口来弥补这个缺点，在接口中的方法是没有方法体的，不会造成同名方法的混乱，所以接口可以实现多继承。子类可以同时实现多个接口，只有在子类中重写接口中的抽象方法，子类才能够使用。

        练习：编写抽象类Decive，mouse类，测试类，实现USB接口，在测试类中完成本态，多态的调用。

package com.hike.javase.interfacetest;

public abstract class Decive {

    private static int no = 1;

    private final int ID;
    private String name;

    {
        ID = no++;
    }

    public Decive(){

    }

    public Decive(String name){
        super();
        this.name = name;
    }

    public int getID() {
        return ID;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Decive{" +
                "ID=" + ID +
                ", name='" + name + '\'' +
                '}';
    }

    public abstract void startup();

    public abstract void shutdown();


}


package com.hike.javase.interfacetest;

public class Mouse extends Decive implements USB {

    public Mouse() {
    }

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

    @Override
    public void startup() {
        System.out.println("鼠标启动了");
    }

    @Override
    public void shutdown() {
        System.out.println("鼠标关闭了");
    }

    @Override
    public void connect() {
        System.out.println("鼠标连接了");
    }

    @Override
    public void work() {
        System.out.println("鼠标工作了");
    }

    @Override
    public void disconnect() {
        System.out.println("鼠标断开了");
    }
}


package com.hike.javase.interfacetest;

import java.lang.management.MemoryUsage;

public class MouseTest {
    public static void main(String[] args) {
        Mouse mouse = new Mouse("华为"); //本态调用
        mouse.connect();
        mouse.startup();
        mouse.work();
        mouse.shutdown();
        mouse.disconnect();
        mouse.toString();

        USB usb = new Mouse("华为");
        usb.connect();
        usb.work();
        usb.disconnect();

        //Decive device = (Decive)usb;
        Decive decive = new Mouse("华为");
        decive.startup();
        decive.shutdown();
    }
}

        接口表现的是一种能力，表明事物可以做到什么。可以飞行的，可以奔跑的等等，在词性上看，是一个形容词。

        接口也可以继承另一个接口，使用extends关键字。接口只能继承接口，不能继承类，并且支持多继承。在子类中实现多个父类中的同名抽象方法，意思就是将所有接口中的同名方法全部重写，并不会引起混乱。

package com.hike.javase.interfacetest;

interface A{
    void test();
}

interface B{
    void test();
}

interface C{
    void test();
}

interface D extends A,B,C{
    void test();
}

class E implements D{
    public void test(){
        System.out.println("E test()");
    }
}

public class ExtendsTest {
    public static void main(String[] args) {
        B b = new E();
        b.test();
    }
}

  问题：接口中的属性是全局常量，当接口和父类中同时有一个同名属性，当子类继承父类并实现接口，当调用这个同名属性时会引起歧义。

接口规范的目的是越多的子类实现越好。