接口概述与生活举例

image.png

接口的定义基本格式

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

接口的抽象方法定义

  1. package Demo02;
  3. /*
  4. 在任何版本的java中接口都能定义抽象方法
  5. 格式：
  6. public abstract 返回值类型 方法名称(参数列表);
  8. 注意事项：
  9. 1.接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
  10. 2.这两个关键字修饰符，可以选择性省略（刚学 不建议）
  11. 3.方法的三要素可以随意定义
  12.  */
  13. public interface MyInterfaceAbstract {
  14.     //这是一个抽象方法
  15.     public abstract void methodAbs1();
  17.     //这也是抽象方法
  18.     abstract void methodBabs1();
  20.     //这也是抽象方法
  21.     public void methodCabs1();
  23.     //这也是抽象方法
  24.     void methodabs1();
  25. }

接口的抽象方法使用

  1. package Demo02;
  3. /*
  4. 接口使用步骤
  5. 1.接口不能直接使用，必须有一个”实现类“来”实现“接口
  6. 格式：
  7. public class 实现类名称 implements 接口名称{
  8.     ...
  9. }
  10. 2.接口的实现类必须覆盖重写（实现）接口中的所有抽象方法
  11. 实现：去掉abstract关键字，加上方法体大括号
  12. 3.创建实现类的对象进行使用
  14. 注意事项：
  15. 如果实现类并没有覆盖重写（实现）接口中的所有抽象方法，那么这个实现类自己就必须是抽象类
  16.  */
  17. public class Demo01Interface {
  18.     public static void main(String[] args) {
  19.         //错误写法！不能直接new 接口对象将进行使用
  20. //        MyInterfaceAbstract inter = new MyInterfaceAbstract();
  21.         //创建实现类的对象进行使用
  22.         MyInterfaceAbstractImpl inter = new MyInterfaceAbstractImpl();
  23.         inter.methodAbs1();
  24.     }
  25. }
  27. =========================================================================================
  28. package Demo02;
  30. public interface MyInterfaceAbstract {
  31.     //这是一个抽象方法
  32.     public abstract void methodAbs1();
  34.     //这也是抽象方法
  35.     abstract void methodBabs1();
  37.     //这也是抽象方法
  38.     public void methodCabs1();
  40.     //这也是抽象方法
  41.     void methodDabs1();
  42. }
  44. ================================================================================
  45. package Demo02;
  47. public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
  49.     @Override
  50.     public void methodAbs1() {
  51.         System.out.println("接口抽像方法A实现");
  52.     }
  54.     @Override
  55.     public void methodBabs1() {
  57.     }
  59.     @Override
  60.     public void methodCabs1() {
  62.     }
  64.     @Override
  65.     public void methodDabs1() {
  67.     }
  68. }

接口的默认方法定义

  1. package Demo02;
  3. /*
  4. 从java8开始，接口允许定义默认方法
  5. 格式：
  6. public default 返回值类型 方法名称(参数列表){
  7.     方法体
  8. }
  10. 备注：接口当中的默认方法可以解决接口升级的问题
  11.  */
  12. public interface MyInterfaceDefault {
  13.     //抽象方法
  14.     public abstract void methodAbs();
  16.     //新添加一个抽象方法
  17.     public abstract void methodAbs2();
  19.     public default void methodDefault(){
  20.         System.out.println("这是接口默认方法");
  21.     }
  22. }
  24. ===================================================================================
  25. package Demo02;
  27. public class MyInterfaceDefaultA implements MyInterfaceDefault{
  28.     @Override
  29.     public void methodAbs() {
  31.     }
  33.     @Override
  34.     public void methodAbs2() {
  36.     }
  37. }
  39. =============================================================================================
  40. package Demo02;
  42. public class MyInterfaceDefaultB implements MyInterfaceDefault {
  43.     @Override
  44.     public void methodAbs() {
  46.     }
  48.     @Override
  49.     public void methodAbs2() {
  51.     }
  53.     @Override
  54.     public void methodDefault() {
  55.         System.out.println("我是B实现类覆盖重写的默认方法");
  56.     }
  57. }
  59. ========================================================================================================
  60. package Demo02;
  62. /*
  63. 1.接口的默认方法，可以通过接口实现对象，直接调用
  64. 2.接口的默认方法，也可以被接口实现类覆盖重写
  65.  */
  66. public interface DemoInterface {
  67.     public static void main(String[] args) {
  68.         //创建实现类对象
  69.         MyInterfaceDefaultA a= new MyInterfaceDefaultA();
  70.         a.methodAbs();    //调用抽象方法，实际运行的是右侧实现类
  72.         //调用默认方法，如果实现类当中没有，会向上找接口
  73.         a.methodDefault();   //这是新添加的默认方法
  74.         System.out.println("=====================");
  76.         MyInterfaceDefaultB b=new MyInterfaceDefaultB();
  77.         b.methodAbs2();
  78.         b.methodDefault();     //实现类B覆盖重写了接口的默认方法
  79.     }
  80. }

接口的静态方法定义

  1. package Demo02;
  3. /*
  4. 从java 8开始 接口中允许定义静态方法
  5. 格式：
  6. public static 返回值类型 方法名称(参数列表){
  7.     //方法体
  8. }
  9. 提示：就是把abstract或default换成static即可，带上方法体
  10.  */
  11. public interface MyInterfaceStatic {
  12.     public static void methodStatic(){
  13.         System.out.println("这是一个接口里的静态方法");
  14.     }
  15. }
  17. =====================================================================================================
  18. package Demo02;
  20. public class MyInterfaceImpl implements MyInterfaceStatic{
  22. }
  24. ==================================================================================================
  25. package Demo02;
  27. /*
  28. 注意事项：不能通过接口实现类的对象来调用接口中的静态方法
  29. 正确用法：通过接口名称，直接调用其中的静态方法
  30. 格式：
  31. 接口名称.静态方法名(参数);
  32.  */
  33. public interface DemoInterfaceStatic {
  34.     public static void main(String[] args) {
  35.         //创建了实现类对象
  36.         MyInterfaceAbstractImpl obj=new MyInterfaceAbstractImpl();
  37.         //错误写法
  38. //        obj.methodStatic();
  39.         //直接通过接口命名成调用静态方法
  40.         MyInterfaceStatic.methodStatic();
  41.     }
  42. }

接口的私有方法/静态私有方法定义

  1. package Demo02;
  3. /*
  4. 问题描述：
  5. 我们需要抽取一个共有的方法，用来解决两个默认方法之间重复代码的我呢提
  6. 但是这个共有方法不应该让实现类使用，应该是私有化的
  8. 解决方案：
  9. 从java9开始，接口当中允许定义私有方法
  10. 1.普通私有方法，解决默认方法之前重复代码的问题
  11. 格式：
  12. private 返回值类型 方法名称(参数列表){
  13.     方法体
  14. }
  15. 2.静态私有方法，解决多个静态方法之间重复代码问题
  16. 格式：
  17. private static 返回值类型 方法名称(参数列表){
  18.     方法体
  19. }
  20.  */
  22. public interface MyInterfacePrivateA {
  23.     public default void methodDefault1(){
  24.         System.out.println("默认方法1");
  25.         methodCommon();
  26.     }
  27.     public default void methodDefault2(){
  28.         System.out.println("默认方法2");
  29.         methodCommon();
  30.     }
  31.     private void methodCommon(){
  32.         System.out.println("AAA");
  33.         System.out.println("BBB");
  34.         System.out.println("CCC");
  35.     }
  36. }
  38. =================================================================================================
  39. package Demo02;
  41. public interface MyInterfacePrivateB {
  42.     public static void methodDefault1(){
  43.         System.out.println("静态方法1");
  44.         methodCommon();
  45.     }
  46.     public static void methodDefault2(){
  47.         System.out.println("静态方法2");
  48.         methodCommon();
  49.     }
  50.     private static void methodCommon(){
  51.         System.out.println("AAA");
  52.         System.out.println("BBB");
  53.         System.out.println("CCC");
  54.     }
  55. }

接口的常量定义和使用

  1. package Demo02;
  3. /*
  4. 接口当中也可以定义”成员便令“，但是必须使用publict static final三个关键字进行修饰
  5. 从效果上看，这其实就是接口的【常量】
  6. 格式：
  7. public static final 数据类型 常量名称 = 数据值;
  8. 备注：
  9. 一旦使用final关键字进行修饰，说明不可改变
  11. 注意事项：
  12. 1.接口当中的常量，可以省略public static final，注意：不写也照样是这样
  13. 2.接口当中的常量，必须进行赋值，不能不赋值
  14. 3.接口中常量的名称，必须使用完全大写的字母，用下划线进行分割。（推荐命名规则）
  15.  */
  16. public interface MyInterfaceConst {
  17.     public static final int NUM_OF_MY_CLASS=12;
  18. }

接口内容小结

image.png

继承父类并实现多个接口

  1. package Demo03;
  3. /*
  4. 使用接口的时候，需要注意：
  6. 1.接口是没有静态代码块或者构造方法的
  7. 2.一个 类的直接父类是唯一的，但是一个类可以同时实现多个接口
  8. 格式：
  9. public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB(){
  10.     //覆盖重写所有抽象方法
  11. }
  12. 3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可
  13. 4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
  14. 5.如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
  15. 6.一个类如果直接父类当中的方法，和接口当中的默认方法发生了冲突，优先用父类当中的方法
  16.  */
  17. public class Demo01Interface {
  18. }
  1. package com.Demo10;
  3. public interface MyInterfaceA {
  4.     //错误写法！接口不能用静态代码块
  5. //    static{}
  6.     //错误写法！接口不能有构造方法
  7. //    public MyInterfaceA(){}
  9.     public abstract void methodA();
  11.     public abstract void methodAbs();
  13.     public default void methodDefault(){
  14.         System.out.println("默认方法AAA");
  15.     }
  16. }
  18. =======================================================================================================================================
  19. package com.Demo10;
  21. public interface MyInterfaceB {
  22.     public abstract void methodB();
  24.     public abstract void methodAbs();
  26.     public default void methodDefault(){
  27.         System.out.println("默认方法BBB");
  28.     }
  29. }
  31. ========================================================================================================================================
  32. package com.Demo10;
  34. public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
  35.     @Override
  36.     public void methodA() {
  37.         System.out.println("覆盖重写了A方法");
  38.     }
  40.     @Override
  41.     public void methodB() {
  42.         System.out.println("覆盖重写了B方法");
  43.     }
  45.     @Override
  46.     public void methodAbs() {
  47.         System.out.println("覆盖重写了AB接口都有的抽象方法");
  48.     }
  50.     @Override
  51.     public void methodDefault() {
  52.         System.out.println("覆盖重写了接口当中冲突的默认方法 进行了覆盖重写");
  53.     }
  54. }