接口知识点

    public class Demo1 {
    /*
    接口就是多个类的公共规范
    接口是一种引用数据类型，最重要的内容就是其中的抽象方法
    
    如何定义一个接口？
    public interface 接口名称{
        接口内容
    }
    
    备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java-->.class
    
    如果是java7：那么接口中可以包含的内容有：
    1.常量
    2.抽象方法
    如果是java8：可以额外包涵有:
    3.默认方法
    4.静态方法
    如果是java9，还可以额外包涵有：
    5.私有方法
     */
    }
    public interface 接口名称 { 
    // 抽象方法 
    // 默认方法
    // 静态方法 
    // 私有方法 
    }

    /*
    在任何版本的java中，接口都能定义抽象方法
    格式：
    public abstract 返回值类型 方法名称（参数列表）；
    
    注意事项：
    1. 接口当中的抽象方法，修饰符必须是两个固定的关键字， public abstract
    2. 这两个关键字修饰符，可以选择性的省略（初学，不推荐）
    3. 方法的三要素，可以随意定义
     */
    public interface MyInterfaceAbstract {
    //这是一个抽象方法
    public abstract void methodAbs1();
    //这也是抽象方法
    abstract void methodAbs2();
    //这也是抽象方法
    public void methodAbs3();
    //这也是抽象方法
    void methodAbs4();
    }

    //定义一个类
    public class Demo01Interface {
    public static void main(String[] args) {
        //错误写法，不能直接new接口对象
        //MyInterfaceAbstract inter=new MyInterfaceAbstract();
        //创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
        impl.methodAbs3();
        impl.methodAbs4();
    }
    }
    
    //定义一个接口类
    public interface MyInterfaceAbstract {
    void methodAbs1();
    
    void methodAbs2();
    
    void methodAbs3();
    
    void methodAbs4();
    }
    
    //定义接口
    public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
    @Override
    public void methodAbs1() {
        System.out.println("这是我的第一种方法");
    }
    
    @Override
    public void methodAbs2() {
        System.out.println("这是我的第二种方法");
    }
    @Override
    public void methodAbs3() {
        System.out.println("这是我的第三种方法");
    }
    @Override
    public void methodAbs4() {
        System.out.println("这是我的第四种方法");
    }
    }

    /*
    1.接口的默认方法，可以通过接口实现类对象，直接调用
    2.接口的默认方法，也可以被接口实现类进行覆盖重写
     */
    public class Demo02Interface {
    public static void main(String[] args) {
        //创建了实现类对象
        MyInterfaceDefaultA a=new MyInterfaceDefaultA();
        a.methodAbs();//调用抽象方法，实际运行的是右侧的实习类
        //调用默认方法，如果实现类当中没有，会向上找借口
        a.methodDefault();//这是新添加的默认方法
        System.out.println("-----------------------");
        MyInterfaceDefaultB b=new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault();//实现类B覆盖重写了接口的默认方法
    }
    }
    
    
    /*
    从java8开始，接口允许定义默认方法
    格式：
    public default 返回值类型 方法名称（参数列表）{
    方法体
    }
    备注：
    接口当中的默认方法，可以解决接口升级的问题
     */
    public interface MyInterfaceDefault {
    //抽象方法
    public abstract void methodAbs();
    //新添加了一个抽象方法
    //public abstract void methodAbs2();
    //新添加的方法，改成默认方法
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
    }
    
    
    
    public class MyInterfaceDefaultA implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，AAA");
    }
    }
    
    
    public class MyInterfaceDefaultB implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，BBB");
    }
    }

    /*
    注意：不能通过接口实现类的对象来调用接口当中的静态方法
    正确用法：通过接口名称，直接调用其中的静态方法
    格式：
    接口名称.静态方法名（参数）
     */
    public class Demo03Interface {
    public static void main(String[] args) {
    //创建了实现类对象
        MyInterfaceStaticImpl impl=new MyInterfaceStaticImpl();
        //错误写法
        //impl.methodStatic();
        //直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }
    }
    
    
    /*
    从java8开始，接口当中允许定义静态方法
    格式：
    public static 返回值类型 方法名称（参数列表）{
    方法体
    }
    提示：就是将abstract或者default换成static即可，带上方法方法体
     */
    public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口的静态方法！");
    }
    }
    
    public class MyInterfaceStaticImpl implements MyInterfaceStatic{
    }