java基础 ---- 接口

java基础 ---- 接口

接口的理解概述：

接口（interface）用作多个类的公共规范，使得多个类能同过这一接口实现协调适配。"实现接口"可类比继承体系，虽然两者的使用大部分相同，但是接口强调功能的实现，继承强调所属关系。粗易例如电脑类，U盘类，迷你电风扇类等都通过执行（implement）一个标准的USB接口完成数据传输等功能的协调适配；前者又都可以继承电子产品父类表明父子类间的所属关系

接口的使用概述：

interfance申明接口，implement声明执行接口。接口中封装常量和方法，依据不同版本的JDK可封装的方法类型不同，其中JDK1.8后，更新接口直接用默认（default）方法或者静态(static)方法：更新用抽象方法的话，所有实现类也必须调整实现该新增方法，否则就得声明为抽象类；JDK9之后，更新接口过程中，多个默认方法（静态方法）中重复代码可提取出来放入一个不让实现类访问的私有方法(私有静态方法)。一个类能继承唯一父类的同时实现多个接口。一个接口能通过关键字extends继承另一个或者多个接口。

---

 

接口最终测试代码：

interface MyInterface {
    //
    //接口没有成员变量，只有常量
    public static final String SIGN_FU = "MyInterface";//final 关键词说明SIGN_FU是常量不可改变

    //public static final String SIGN_FU;错于没有赋初始值
    //String SIGN_FU = "MyInterface " 不写关键词也是规定默认public static final
    //String signFu = "MyInterface " 推荐使用完全大写的字母，下划线进行分隔的命名规则
    //
    //所有版本JDK都包含抽象方法，常量
    public abstract void methodAbs();

    //abstract void methodAbs();
    // public void methodAbs();
    // void methodAbs();
    //
    //JDK9之后，可以封装私有方法和私有静态方法，供静态方法和静默方法调用使用
    private void methodPrivate(){
        System.out.println("这是一个私有方法：包含默认方法的重复代码");
    }
   private static void methodPrivateStatic(){
        System.out.println("这是一个私有静态方法：包含静态方法的重复代码");
   }
    //
    //多个默认方法调用私有方法中的重复代码（JDK9之后）
    public default void methodDefault() {
        //default void methodDefault()
        //
        methodPrivate()
        System.out.println("这是新添加的默认方法");
    }

    public default void methodDefault02() {
        //default void methodDefault()
        //
        methodPrivate()
        System.out.println("这是新添加的默认方法02");
    }

    //
    //同理，静态方法调用私有静态方法的重复代码（JDK9之后）
    public static void methodStatic() {
        methodPrivateStatic()
        System.out.println("这是一个静态方法");
    }
}
//
//测试一个与MyInterface有同名三类方法的MyInterface02
interface MyInterface02 {
    public abstract void methodAbs();

    //
    public default void methodDefault() {
        //default void methodDefault()
        System.out.println("这是新添加的默认方法");
    }

    //
    public static void methodStatic() {
        System.out.println("这是一个静态方法");
    }
}
//
class MyInterfaceImpl implements MyInterface, MyInterface02 {//不同于继承，实现类可以同时实现多个接口
    //
    //多接口重名的抽象方法只要实现一次
    @Override
    public void methodAbs() {
        System.out.println("这是一个接口抽象方法的实现");
    }

    //
    //多接口重名的默认方法必须重写一次，不重名的可直接调用
    @Override
    public void methodDefault() {
        System.out.println("这是一个接口默认方法的重写");
    }
}
//
public class InterfaceCode {
    public static void main(String[] args) {
        MyInterfaceImpl myInterfaceImpl = new MyInterfaceImpl();
        MyInterface.methodStatic();  //"这是一个静态方法"
        MyInterface02.methodStatic();//"这是一个静态方法"
        //静态方法通过接口调用，重名没事
        //myInterfaceImpl.methodStatic();错于静态方法只与接口有关，与对象无关
        //methodStatic();错于一个类可以实现多个接口，所以调用静态方法必须要用接口名调用
        //
        //多接口重名默认方法，实现类重写一次后覆盖执行
        myInterfaceImpl.methodDefault();//"这是一个接口默认方法的重写"
        //
        //多接口重名抽象方法，实现类只重写一次后统一执行
        myInterfaceImpl.methodAbs();//"这是一个接口抽象方法的实现"
    }
}

//构造具有同名抽象方法，静态方法，成员方法对应默认方法的父类和接口
abstract  class Fu {
    public void method() {
        System.out.println("AAA");
    }

    abstract void methodAbs();
    //void methodAbs();错于父类中的抽象方法必须用abstract声明，接口可以省略
    //
    static void methodStatic() {
        System.out.println("aaa");
    }
}
    interface MyInterface {
        public default void method() {
            System.out.println("BBB");
        }

        void methodAbs();

        //
        static void methodStatic() {
            System.out.println("bbb");
        }
    }
    class Zi extends Fu implements MyInterface{//子类可以继承唯一父类的同时实现多个接口
    //
    //父类，接口抽象方法同名，只需要重写一次抽象方法    
    public void methodAbs(){
            System.out.println("CCC");
        }
     //
     //构造一个子类静态方法于父类，接口静态方法同名   
        public static void methodStatic(){
            System.out.println("DDD");
        }
    }
    //
    public class InterfaceCode {
        public static void main(String[] args) {
            Zi zi = new Zi();
            //
            // 父类和接口的抽象方法同名，子类重写一次后统一执行
            zi.methodAbs(); //CCC
            //
            //接口静态方法只有接口有关，父类的静态方法只有父类有关，子类静态方法只与子类有关
            zi.methodStatic(); //aaa
            Zi.methodStatic(); //DDD
            Fu.methodStatic(); //DDD
            MyInterface.methodStatic(); //bbb
            //父类的成员方法和接口的默认方法同名，优先执行父类的成员方法
            zi.method();    //AAA
        }
    }

interface MyInterfaceFu {
    public default void method() {
        System.out.println("AAA");
    }

    void methodAbs();
}

interface MyInterfaceFu02 {
    public default void method() {
        System.out.println("BBB");
    }

    void methodAbs();
}

interface MyInterfaceZi extends MyInterfaceFu, MyInterfaceFu02 {//子接口可继承多个父接口

    //父接口中默认方法重名，子接口需要重写一次
    @Override
    public default void method() {
        System.out.println("CCC");
    }

    void methodAbs02();
}

class MyInterfaceImpl implements MyInterfaceZi {//子类可以继承唯一父类的同时实现多个接口

    //父子接口中抽象方法同名，只需要重写一次抽象方法
    public void methodAbs() {
        System.out.println("DDD");
    }

    //父子接口中抽象方法不同名，需要另外重写一次抽象方法
    public void methodAbs02() {
        System.out.println("EEE");
    }
}

public class InterfaceCode {
    public static void main(String[] args) {
        MyInterfaceImpl myInterfaceImpl = new MyInterfaceImpl ();
        //
        // 父子接口的抽象方法同名，实现类重写一次后统一执行
        myInterfaceImpl.methodAbs(); //DDD
        //
        myInterfaceImpl.methodAbs02(); //EEE
        //
        //父接口和子接口的默认方法同名，子接口重写一次后，实现类调用覆盖执行
        myInterfaceImpl.method();    //CCC
    }
}