Java接口

Class  interface  array（并列的概念）

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

2.1 接口

声明格式：

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  { 常量定义；                         方法定义； }

   定义接口的详细说明：

1. 访问修饰符：只能是public或默认。
2. 接口名：和类名采用相同命名机制。
3. extends：接口可以多继承。
4. 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
5. 方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract。

要点 子类通过implements来实现接口中的规范。 接口不能创建实例，但是可用于声明引用变量类型。 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。 JDK1.8（不含8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。 JDK1.8（含8）后，接口中包含普通的静态方法、默认方法。

需求：飞机、鸟、超人，导弹参加飞行表演。

思路1：定义一个父类Flyable，让飞机、鸟、超人，导弹都继承该类。不可以，因为继承表达的是is-a的关系，而飞机、鸟、超人不是一种事物，

思路2：使用接口，定义一个接口Flyable（具有飞的能力  ），让飞机、鸟、超人，导弹都实现该接口。接口表达是has-a的关系

public interface MyInterface {
}

public interface Flyable extends MyInterface{
    //public static final double PI = 3.14;
    final double PI=3.14
    //接口中所有变量都是全局静态的常量
    //接口不能new 也没有抽象方法 也不会自动的继承某个类

    //成员方法 接口中所有方法都是全局抽象方法  （<=JDK1.7）
    //public abstract void fly();

    void fly();
}

 

public abstract class Animal {
    public abstract void shout();
}

 

public class Bird extends Animal implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿在天上展翅高翔");
    }

    @Override
    public void shout() {
        System.out.println("----发出鸟儿的声音------");
    }
}

 

public class Machine {
}

public class Plane extends Machine implements Flyable {

    @Override
    public void fly() {
        System.out.println("飞机在平流层飞行");
    }
}

/**
 * implement 实现
 */
public class Superman implements Flyable {
    @Override
    public void fly() {
        System.out.println("超人会飞");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Flyable.PI);
        //Flyable.pi=3.15;
        Bird bird = new Bird();
        fly(bird);
        Plane plane = new Plane();
        fly(plane);
        Flyable superman = new Superman();
        fly(superman);



    }

    /**
     *形参是一个接口，实参可以是该接口的任意一个实现类的对象
     * （运用多态）
     * @param flyable
     */
    public static void fly(Flyable flyable) {
        flyable.fly();
        //这里鸟类只能使用fly的能力
    }
//    public void fly(Bird bird) {
//        bird.fly();
//    }
//
//    public void fly(Plane plane) {
//        plane.fly();
//    }
//
//    public void fly(Superman superman) {
//        superman.fly();
//    }
}

 

总结1：接口的组成

1. 接口和数组、类、抽象类是同一个层次的概念
2. 成员变量:接口中所有的变量都使用public static final修饰，都是全局静态常量
3. 成员方法： 接口中所有的方法都使用public abstract修饰，都是全局抽象方法
4. 构造方法：接口不能new，也没有构造方法
5.  接口做方法的形参，实参可以该接口的所有实现类

总结2：接口和多继承

1. C++  多继承

     好处 ：可以从多个父类继承更多的功能

     缺点：不安全 有两个父类Father1,Father2,都有一个方法giveMoney(),子类如果重写了，没有问题，如果子类没有重写，调用giveMoney()是谁的

1. Java 单继承

好处：安全   缺点：功能受限

    解决方案：既安全，功能又强大，采用接口。接口变相的使Java实现了C++的多继承，又没有C++多继承的不安全性

     public class Bird extends Animal implements Flyable,Sleepable

    必须先extends 再implements