java之接口

package level2.myInterface;
/*
 1、介绍: 接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，
         再根据具体情况把这些方法写出来
 2、语法：
        interface 接口名{
            // 属性
            // 方法(1.抽象方法 2.默认实现方法 3.静态方法)
        }

        class 类名 implement 接口{
            自己属性;
            自己方法;
            必须实现的接口的抽象方法
        }
 3、PS：
    1) 在Jdk7.0前，接口里的所有方法都没有方法体
    2) Jdk8.0 后，接口类可以有静态方法、默认方法、即：接口中可以有方法的具体实现
 4、说明
    1) 接口不能被实例化
    2) 接口中的所有方法是public方法，接口中抽象方法，可以不用abstract修饰
    3) 一个普通类实现接口，就必须将该接口的所有方法都实现
    4) 抽象类实现接口，可以不用实现接口的方法
    5) 一个类可以同时实现多个接口,需要实现所有接口中的抽象方法
    6) 接口中的属性，只能是final的，而且是public static final修饰符
       例如: int a=1;  实际上是 public static final int a=1;(必须初始化)
    7) 接口中属性的访问形式：接口名.属性名
    8) 一个接口不能继承其他的类，但是可以继承多个别的接口
       interface A extends B,C{}
    9) 接口的修饰符只能是public和默认，与类的修饰符是一样的
 4、接口VS继承
    1) 当子类继承了父类，就自动拥有了父类的功能，如果子类需要扩展功能，可以通过实现接口的方式进行扩展
    2) 继承的价值主要在于：解决代码的复用性和可维护性
    3) 接口的价值主要在于：设计、规范方法，让其他类去实现
    4) 接口比继承更加灵活，继承满足 is-a 的关系，接口只需满足 like-a 的关系
    5) 接口在一定程度上实现解耦(即：接口的规范性+动态绑定机制)
 4、接口的多态
    1) 多态参数：当参数为接口类型时，则参数可以接收 实现了该接口 类型的实例
                接口引用可以指向实现该接口的类的实例
    2) 多态数组：
    3) 接口存在 多态传递 现象
 */
public class MyInterface {
    public static void main(String[] args) {
        // 接口引用可以指向实现该接口的类的实例对象
        IA ia1 = new Var();
        ia1 = new Vbr();

        // 数组多态
        IA[] ia2 = new IA[2];
        ia2[0] = new Var();
        ia2[1] = new Vbr();
        for (int i = 0; i < ia2.length; i++) {
            ia2[i].work();
            if(ia2[i] instanceof Var){  // 向下转型
                ((Var) ia2[i]).call();
            }
        }

        // 多态传递
        IE ie= new Vcr();
        IA ia = new Vcr();  // 由于IE继承了IA，那么IA类型也可指向实现了IE的类的对象实例；若没有继承，则不能指向
    }
}

interface IA{

    void work();
}

class Var implements IA{

    // 类的特有属性
    public void call(){
        System.out.println("能打电话...");
    }

    @Override
    public void work() {
        System.out.println("工作中...");
    }
}
class Vbr implements IA{
    @Override
    public void work() {
        System.out.println("工作中...");
    }
}


// 若IE继承了IA
interface IE extends IA{ }
// Vcr 也需要实现IA中的方法
class Vcr implements IE{

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

1、接口VS继承

package level2.myInterface;

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey littleMonkey = new LittleMonkey("小猴子");
        littleMonkey.climbing();
        littleMonkey.fly();
        littleMonkey.swimming();
    }
}

class Monkey{

    private String name;

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

    public String getName() {
        return name;
    }

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

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

interface Fish{
    void swimming();
}

interface Bird{
    void fly();
}
// 当子类继承了父类，就自动拥有了父类的功能，如果子类需要扩展功能，可以通过实现接口的方式进行扩展
// 实现接口是对java单继承机制的补充
class LittleMonkey extends Monkey implements Fish,Bird{

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

    @Override
    public void climbing() {
        super.climbing();
    }

    @Override
    public void swimming() {
        System.out.println("猴子 " + getName()+" 经过学习，学会了游泳...");
    }

    @Override
    public void fly() {
        System.out.println("猴子 " + getName()+" 经过学习，学会了飞...");
    }
}

2、

package level2.myInterface;

public class InterfaceDetail02 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        // 都可以访问
        System.out.println(cat.a);
        System.out.println(Cat.a);
        System.out.println(IB.a);
    }
}

interface IB{
    int a = 10;
    void hi();
}
interface IC{
    void say();
}

// 一个类可以实现多个接口
class Cat implements IB,IC{
    @Override
    public void hi() {

    }

    @Override
    public void say() {

    }
}

// 接口可以继承多个接口
interface ID extends IB,IC{

}