（java总结）接口

拼搏现实的明天。 2023-06-12 08:34 11阅读 0赞

package Demo15;
    /*
    接口就是多个类的公共规范
    接口是一种引用数据类型，最重要的内容就是其中的抽象方法。
    
    定义一个接口格式：
    Public interface 接口名称｛
        //接口内容
    ｝
    java7，接口中的内容有：
    1、常量
    2、抽象方法
    java8，有
    1、默认方法图
    2、静态方法
    java9，有
    1、私有方法
    
    接口使用步骤：
    1、接口不能直接使用，必须有一个实现类来实现接口
    格式：
    public class 实现类名称 implements 接口名称｛
            //...
     }
    2、接口的实现类必须覆盖重写（实现）接口中的所有方法。
    3、创建实现类的对象，进行使用
    
    
     */
    public class DemoInterface {
        
        public static void main(String[] args) {
        
    
            //
            MyInterfaceAbstractImplinl impl = new MyInterfaceAbstractImplinl();
            impl.methodAbs();
            impl.methodAbs2();
        }
    }

package Demo15;
    
    public class MyInterfaceAbstractImplinl implements MyInterfaceAbstract {
        
        @Override
        public void methodAbs() {
        
            System.out.println("这是第一个方法");
        }
    
        @Override
        public void methodAbs2() {
        
            System.out.println("这是二个方法");
    
        }
    
        @Override
        public void methodAbs3() {
        
            System.out.println("这是三个方法");
    
        }
    
        @Override
        public void methodAbs4() {
        
            System.out.println("这是四个方法");
    
        }
    }

package Demo15;
    /*
    在任何版本的java中，接口都能定义抽象方法
    格式：
    Public abstract 返回值类型 方法名称（参数列表）;
    
    注意事项：
    1、接口中的抽象方法，修饰符必须是两个固定的关键字： public abstract
    2、 这俩个关键字可以选择性省略
     */
    public interface MyInterfaceAbstract {
        
    
        //这是一个抽象方法
        public abstract void methodAbs();
        //这也是抽象方法
        abstract void methodAbs2();
        //这也是抽象方法
        public void methodAbs3();
        //这也是抽象方法
        void methodAbs4();
    
    
    }

package Demo15;
    /*
    从java 8 开始，接口 里允许定义默认方法
    格式：
    public default 返回值类型 方法名称(参数列表)｛
    方法体
    ｝
    备注： 接口当中的默认方法，可以解决接口升级的问题
     */
    public interface MyInterfaceDefault {
        
    
        //抽象方法
        public abstract void methodAbs();
    
        //新添加了一个抽象方法,会使另外两个实现类也报错，如果已投入使用，不建议修改实现类
      //  public abstract void methodAbs1();
    
        //新添加的方法，改成默认方法 关键字是灰色的 可以省略
        public default void methodDefault(){
        
            System.out.println("这是新添加的默认方法");
        }
    }

package Demo15;
    
    public class MyInterfaceDefaultA implements MyInterfaceDefault {
        
        @Override
        public void methodAbs() {
        
            System.out.println("实现了抽象方法， AAA");
        }
    }

package Demo15;
    /*
    1、接口的默认的方法，可以通过接口实现类对象，直接调用
    2、接口的默认方法，也可以被接口实现类进行覆盖重写
     */
    public class DemoInterface01 {
        
        public static void main(String[] args) {
        
            MyInterfaceDefaultA a = new MyInterfaceDefaultA();
            a.methodAbs();//调用抽象方法，实际调用的是实现类      实现了抽象方法， AAA
    
            //调用默认的方法，如果实现类中没有，会向上找
            a.methodDefault();//这是新添加的默认方法
    
            System.out.println("===================");
    
            MyInterfaceDefaultB b = new MyInterfaceDefaultB();
            b.methodAbs();//实现了抽象方法， BBB
            b.methodDefault();//实行按类B类覆盖重写了接口的默认方法
        }
    
    
    
    
    }

package Demo15;
    
    public class MyInterfaceDefaultB implements MyInterfaceDefault {
        
        @Override
        public void methodAbs() {
        
            System.out.println("实现了抽象方法， BBB");
        }
        @Override
        public void methodDefault(){
        
            System.out.println("实行按类B类覆盖重写了接口的默认方法");
        }
    }

package Demo15;
    /*
    从java 8开始，接口中允许定义静态方法。
    格式：
    public static 返回值类型 方法名称(参数列表)｛
        方法体
    ｝
    提示：就是将abstract或者default换成static即可，带上方法体
     */
    public interface MyInterfaceStaic {
        
        public static void methodStatic(){
        
            System.out.println("这是接口的静态方法！");
        }
    
    }

package Demo15;
    
    public class DemoInterface02 {
        
        public static void main(String[] args) {
        
    
        }
    }

package Demo15;
    /*
    注意：不能通过接口实现类的对象来调用接口当中的静态方法
    正确名称：
    接口名称.静态方法名()
    思想：静态方法是在类中
     */
    public class MyInterfaceStaticImpl implements MyInterfaceStaic{
        
        public static void main(String[] args) {
        
            MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
    
            //错误写法
            // impl.methodStatic();
    
            //正确写法
            MyInterfaceStaic.methodStatic();
        }
    }

package Demo15;
    
    java9的特性
    /*
    问题描述：
    需要抽象抽取一个共有方法，用来解决俩个默认方法之间重复代码的问题
    但是这个方法不应该让实现类使用，应该是私有的。
    解决方案:
    从java 9 开始，接口中允许定义私有方法
    1、普通私有方法，解决多个默认方法之间 重复代码的问题
    private 返回值类型 方法名称(参数列表)｛
            方法体
      ｝
    2、静态私有方法，解决多个静态方法之间重复代码问题
    private static 返回值类型 方法名称(参数列表){
            方法体
       }
     */
    public interface MyInterfacePrivateA {
        
    
        public default void methodDefault1() {
        
            System.out.println("默认方法1");
            methodCommon();
        }
    
        public default void methodDefault2(){
        
            System.out.println("默认方法2");
            methodCommon();
        }
            public default void methodCommon(){
        
            System.out.println("AAA");
            System.out.println("BBB");
            System.out.println("CCC");
        }
    }

package Demo15;
    /*
    1、接口是没有静态代码块或者构造方法的
    2、一个类的直接父类是唯一的，但是一个类的可以同时实现多个接口。
    格式：
    public class MyInterface implements MyInterfaceA, MyInterfaceB
            //覆盖重写所有的抽象方法
    3、如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
    4、如果实现类没有重写覆盖接口中所有的抽象方法，那么实现类就必须是抽象类。
    5、如果实现类实现的多个接口中，存在重复默认方法，那么实现类一ID那个要对冲突的默认方法进行重写
    6、一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先使用父类当中的方法
     */
    public class DemoInterface05 {
        
    }

package Demo15;
    
    public interface MyInterfaceA {
        
    
        //错误写法,接口不能有静态代码块
    //    static{
        
    //
    //    }
        //错误写法,接口不能有构造方法
    //    public MyInterface(){
        
    //
    //    }
    
        public abstract void methodA();
    
        public abstract void methodAB();
    
        public default void methodDefault(){
        
            System.out.println("默认方法AAA");
        }
    }

package Demo15;
    
    public interface MyInterfaceB {
        
    
        //错误写法,接口不能有静态代码块
    //    static{
        
    //
    //    }
        //错误写法,接口不能有构造方法
    //    public MyInterface(){
        
    //
    //    }
        public abstract void methodB();
        public abstract void methodAB();
    
        public default void methodDefault(){
        
            System.out.println("默认方法BBB");
        }
    
    }

package Demo15;
    
    public class MyInterfaceeImpl implements MyInterfaceA,MyInterfaceB {
        
        @Override
        public void methodA() {
        
            System.out.println("覆盖重写了A方法！");
        }
    
        @Override
        public void methodAB() {
        
            System.out.println("覆盖重写了AB接口都有的抽象方法");
    
        }
    
    
    
        @Override
        public void methodB() {
        
            System.out.println("覆盖重写了B方法！");
    
        }
        @Override
        public void methodDefault() {
        
            System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
        }
    }

package Demo15;
    
    public class Fu {
        
        public void method(){
        
            System.out.println("父类方法");
        }
    }

package Demo15;
    //这里父类和接口中有同样的方法，优先父类，所以不用重写
    public class Zi extends Fu implements MyInterface {
        
    }

package Demo15;
    
    public interface MyInterface {
        
        public default void method(){
        
            System.out.println("接口的默认方法");
        }
    }

package Demo15;
    /*
    1、类与类之间是单继承的，直接父类只有一个。
    2、类与接口之间是多实现的，一个类可以实现多个接口。
    3、接口与接口之间是多继承的。
    
    注意事项：
    1、多个父接口当中的抽象方法如果重复，没关系
    2、多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的重写，而且必须带着default关键字
    
     */
    public class DemoRelations {
        
    }

package Demo15;
    
    public interface MyInterfaceA01 {
        
    
        public abstract void methodA();
    
        public abstract void methodCommon();
    
        public default void method(){
        
            System.out.println("默认AAA");
        }
    }

package Demo15;
    
    public interface MyInterfaceB01 {
        
        public abstract void methodB();
    
        public abstract void methodCommon();
    
        public default void method(){
        
            System.out.println("默认AAA");
        }
    }

package Demo15;
    //接口与接口之间是多继承的。
    public interface MyyInterfaceAB extends MyInterfaceA01,MyInterfaceB01 {
        
            public abstract void method();
    }

package Demo15;
    
    public interface MyInterfaceImplement extends MyInterfaceA01, MyInterfaceB01 {
        
    
    
        @Override
        default void methodA() {
        
    
        }
    
        @Override
        default void methodB() {
        
    
        }
    //两个接口中的default有同样的默认方法，所以这里必须带着default
        @Override
        default void methodCommon() {
        
    
        }
    
        @Override
        default void method() {
        
    
        }
    }