Java之路---Day11(接口)

2019-10-25-23:22:23

目录

　　1.接口的概念

　　2.接口的定义格式

　　3.接口包含的内容

　　4.接口的使用步骤

　　5.继承父类并实现多个接口

　　6.接口之间的多继承

---

接口的概念

　　接口是指对协定进行定义的引用类型。其他类型实现接口，以保证它们支持某些操作。接口指定必须由类提供的成员或实现它的其他接口。与类相似，接口可以包含方法、属性、索引器和事件作为成员,其中最终哟啊的内容就是其家中的抽象方法

接口的定义格式

　　public interface 接口名称{

　　　　接口内容

　　}

接口包含的内容

　　1.常量

 package demopra.Interface;
 //定义一个接口
 public interface InterfaceContent01 {
     //接口包含的内容(常量)
     double PI = 3.141592654;
 }

　　2.抽象方法

 package demopra.Interface;
 //定义一个接口
 public interface InterfaceContent02 {
     //接口包含的内容(抽象方法)
     public abstract void method();//(public abstract两个关键字可以省略)
 }

　　3.默认方法

　　　　1.备注:接口当中的默认方法可以解决接口升级的问题

　　　　2.接口的默认方法可以通过接口实现类对象进行直接调用

　　　　3.接口的默认方法可以被接口的实现类进行覆盖重写

 package demopra.Interface;
 /*
     格式:
         public default 返回值类型 方法名称(参数列表){
             方法体
         }
  */
 //定义一个接口
 public interface InterfaceContent03 {
     //接口包含的内容(默认方法)
     public default void method03(){
         System.out.println("这是一个默认方法");
     }
 }

 package demopra.Interface;

 public class InterfaceContentt03Test implements InterfaceContent03{
     public static void main(String[] args) {
         //创建实现类对象
         InterfaceContentt03Test ic = new InterfaceContentt03Test();
         //实现类对象直接调用接口的默认方法
         ic.method03();
     }
 //    //实现类覆盖重写接口的默认方法
 //    @Override
 //    public void method03() {
 //        System.out.println("实现类覆盖重写接口的默认方法");
 //    }
 }

　　4.静态方法

 package demopra.Interface;
 /*
     格式:
         public static 返回值类型 方法名称(){
             方法体
         }
     提示:就是将abstract或者default换成static 即可,记得带上方法体{}
     注意事项:不能通过接口实现类对象来调用接口当中的静态方法,只能通过接口名称来调用
         格式:
             接口名称.静态方法(参数);
  */
 //定义一个接口
 public interface InterfaceContent04 {
     //接口包含的内容(静态方法)
     public static void method04(){
         System.out.println("这是一个静态方法");
     }
 }

 package demopra.Interface;
 //创建一个接口的实现类
 public class InterfaceContentt04Test implements InterfaceContent04{
     public static void main(String[] args) {
         //创建一个实现类对象
         InterfaceContentt04Test ic = new InterfaceContentt04Test();
         //错误写法,会报错
 //        ic.method04();

         //正确调用方法
         InterfaceContent04.method04();//执行结果:这是一个静态方法
     }
 }

　　5.私有方法

 package demopra.Interface;
 /*
     为什么要用私有方法:
         我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
         但是这个共有方法不应该让实现类使用，应该是私有化的。
     私有方法的两种用法:
         普通私有方法:解决多个默认方法之间代码重复问题
             格式:
                 private 返回值类型 方法名称(参数列表){
                     方法体
                 }
         静态私有方法:解决多个静态方法之间代码重复问题
             格式:
                 private static 返回值类型 方法名称(){
                     方法体
                 }
  */
 //定义一个接口
 public interface InterfaceContent05 {
     //接口包含的内容(私有方法)
     public static void method0501(){
         System.out.println("这是一个普通私有方法1");
         method05();
     }

     public static void method0502(){
         System.out.println("这是一个普通私有方法2");
         method05();
     }
     //定义一个普通私有方法
     private static void method05(){
         System.out.println("AAAA");
         System.out.println("BBBB");
     }
     //静态私有方法同理
 }

 package demopra.Interface;

 public class InterfaceContentt05Test {
     public static void main(String[] args) {
         //直接通过接口名调用
         InterfaceContent05.method0501();
         InterfaceContent05.method0502();
         //错误的写法,private不能直接调用
 //        InterfaceContent05.method05();
     }
     //静态私有方法同理

     /*
         结果:
             这是一个普通私有方法1
             AAAA
             BBBB
             这是一个普通私有方法2
             AAAA
             BBBB
      */
 }

接口的使用步骤

　　1.接口不能直接使用,逆序有一个"实现类了"来"实现"该接口

　　　　格式:

　　　　　　public class 实现类名称 implements 接口名称{

　　　　　　　　实现类内容

　　　　　　}

　　2.接口的实现必须覆盖实现接口中所有的抽象方法

　　　　实现:去掉abstract关键字,加上方法体大括号

　　3.创建实现类对象,进行使用

　　备注:如果实现类并没有覆盖重写接口中所有的实现方法,那么这个实现类自己必须是抽象类

继承父类并实现多个接口

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

接口之间的多继承

　　1.类与类之间是单继承的.直接父类只有一个。
　　2.类与接口之间是多实现的。一个类可以实现多个按口。
　　3.接口与接口之间是多继承的。
　　　　注意事项
　　　　　　1多个父接口当中的抽象方法如果重复，没关系。
　　　　　　2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写， [而且带着default关键字]