第三章 面向对象之接口

01_接口概述及生活举例：

 

01_接口英语单词
interface：接口    （英特废死）

Lock:锁

Theftproof:  防盗  ['θeftpruːf]

Door:  门    

Aptitude: [ˈæptɪtjuːd]  天赋

Implement  实现、实施  [ˈɪmplɪment]

Static 静态的

Final 最终的

 

02_接口定义的基本格式

生活当中的接口就是一套规则规范，在代码当中也是如此。

创建类：ch03.com.obtk_01.Demo01Interface

/**
 * @author fly
 * @date 2019-11-06 09:53:00
 * 接口就是多个类的公共规范
 * 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法
 *
 * 如何定义一个接口的格式：
 * public interface 接口名称{
 *     //接口的内容
 * }
 * 备注：换成了关键字interface之后，编译生成的字节码文件仍然是   .java ---->.class
 *
 * 如果是java 7，那么接口可以包含的内容有：
 * 1、常量   final（最终）
 * 2、抽象方法
 *
 * 如果是java8，还可以额外包含：
 * 3、默认方法  default
 * 4、静态方法  static
 *
 * 如果是java9，还可以额外包含有：
 * 5、私有方法 private
 *
 * 接口的使用步骤
 * 1、接口不能直接使用，必须有一个“实现类”来“实现”该接口
 * 格式：
 * public class 实现类名称  implements 接口名称{
 *     //.......
 * }
 * 2、接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
 * 实现：去掉abstarct关键，加方法体的大括号。
 * 3、创建实现类的对象，进行使用
 *
 * 注意事项：
 * 如果实现类并没有覆盖重写接口中所有的抽象方法，
 * 那么这个实现类自己就必须是抽象类。
  */
public class Demo01Interface {
    public static void main(String[] arg){
        //错误的写法，不能直接new接口对象使用
      //  MyInterfaceAbstarct interfaceAbstarct = new MyInterfaceAbstarct();

        //创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
    }
}

03_接口的抽象方法定义

创建接口：ch03.com.obtk_01.MyInterfaceAbstract

/**

 * @author fly

 * @date 2019-11-06 10:33:02

 * 在任何版本的java中，接口都能定义抽象方法

 * 格式：

 * public abstarct 返回值类型 方法名称（参数列表）；

 *

 * 注意事项：

 * 1、接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract

 * 2、这二个关键字修饰符，可以选择性的省略 （今天刚学，所以不推荐)

 * 3、方法的三要素可以随意定义（public /abstract/void)

 */

  public interface  MyInterfaceAbstarct {

    //这是一个抽象方法

    public abstract  void methodAbs1();

  

    //这也是一个抽象方法

    abstract void  methodAbs2();

  

    //这也是抽象方法

    public void metodAbs3();

  

    //这也是抽象方法

    void methodAbs4();

}

04_接口的抽象方法使用

已经定义了接口方法，并且其中有些抽象方法，如何对他进行使用呢？

* 接口的使用步骤

* 1、接口不能直接使用，必须有一个“实现类”来“实现”该接口

* 格式：

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

*     //.......

* }

* 2、接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。

* 实现：去掉abstarct关键，加方法体的大括号。

* 3、创建实现类的对象，进行使用

*

* 注意事项：

* 如果实现类并没有覆盖重写接口中所有的抽象方法，

* 那么这个实现类自己就必须是抽象类。

 */

创建接口类：MyInterfaceAbstractimpl

public class MyInterfaceAbstractImpl  implements MyInterfaceAbstarct {

    @Override

    public void methodAbs1() {

        System.out.println("这是第一个方法");

    }

  

    @Override

    public void methodAbs2() {

        System.out.println("这是第二个方法");

    }

  

    @Override

    public void metodAbs3() {

        System.out.println("这是第三个方法");

    }

  

    @Override

    public void methodAbs4() {

        System.out.println("这是第四个方法");

  

    }

}

创建测试类：Demo01Interface

 

05_接口的默认方法定义

* 从java 8开始，接口是允许 定义默认方法
 * 格式：
 * public default 返回值类型  方法名称（参数列）{
 *     方法体
 * }
 * 备注：接口当中的默认方法，可以解决接口升级的问题
 */

第一步：ch03.com.obtk_01.MyInterfaceDefault

/**

 * @author fly

 * @date 2019-11-06 11:26:31

 * 从java 8开始，接口是允许 定义默认方法

 * 格式：

 * public default 返回值类型  方法名称（参数列）{

 *     方法体

 * }

 * 备注：接口当中的默认方法，可以解决接口升级的问题

 */

  public interface MyInterfaceDefault {

    //抽象方法

    public abstract  void methodAbs();

  

    //新添加一个默认方法

    public default   void methodAbs2(){

        System.out.println("这是新添加的默认方法");

    }

}

 

第二步：ch03.com.obtk_01.MyInterfaceDefaultA

public class MyInterfaceDefaultA  implements MyInterfaceDefault{

    @Override

    public void methodAbs() {

        System.out.println("实现了抽象类的方法 AAA");

    }

    //新添加一个默认方法

    public    void methodAbs2(){

        System.out.println("这是覆盖的默认方法");

    }

}

第三步：ch03.com.obtk_01.MyInterfaceDefaultB

public class MyInterfaceDefaultB  implements  MyInterfaceDefault{

    @Override

    public void methodAbs() {

        System.out.println("实现了抽象方法，BBB");

    }

}

第四步：在MyInterfaceDefault新加接口方法

 

新加的methodAbs2（）必须覆盖重写所有的实现类方法，MyInterfaceDefaultB和MyInterfaceDefaultA会报错，但是A和B已经投入使用，如果A和B类发生变化，那么多用到他俩的地方都要跟着变，都会受到影响、受到牵连，那么现在的问题是如何来保证AB类就是固定不动的，我就只管一个方法，但是我接口当中还想再加一个方法，而且这个添加动作让AB类不错，怎么解决这种矛盾呢？

我们就要让你新添加的methodAbs2方法拥有默认的方法体，而这种带有方法体的就叫默认default方法。

06_接口的默认方法使用

1、接口的默认方法，可以通过接口实现类对象直接调用。
2、接口的默认方法，也可以被 接口实现类进行覆盖重写。

 

ch03.com.obtk_01.Demo02Interface

/**
 * @author fly
 * @date 2019-11-06 11:47:19
 * 1、接口的默认方法，可以通过接口实现类对象直接调用。
 * 2、接口的默认方法，也可以被 接口实现类进行覆盖重写。
 */
public class Demo02Interface {
    public static void main(String[] args) {
        //创建实现类的对象
        MyInterfaceDefaultA a =  new MyInterfaceDefaultA();
        a.methodAbs();

        //调用默认方法，如果实现类中没有，会向上找接口
        a.methodAbs2();
        System.out.println("====================");
        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodAbs2();
    }
}

MyInterfaceDefaultA

public class MyInterfaceDefaultA  implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象类的方法 AAA");
    }
    //新添加一个默认方法
    public    void methodAbs2(){
        System.out.println("这是覆盖的默认方法");
    }
}

 

MyInterfaceDefaultB

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

 

 

07_接口的静态方法定义MyInterfaceStatic

静态的关键字叫static,

在Java语言中，static表示“静态”的意思，使用场景可以用来修饰成员变量和成员方法，当然也可以是静态代码块。static的主要作用在于创建独立于具体对象的域变量或者方法。

* 从java 8开始，接口当中允许 定义静态方法。
* 格式：
* public static 返回值类型 方法名称（参数列表）{
*     方法体
* }
* 提示：将abstract或者default换成static即可，带上方法体
*/

 

08_接口的静态方法使用

* 从java 8开始，接口当中允许 定义静态方法。
* 格式：
* public static 返回值类型 方法名称（参数列表）{
*     方法体
* }
* 提示：将abstract或者default换成static即可，带上方法体
*/

* 注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
* 正确用法：通过接口名称，直接调用其中的静态方法
* 格式：
* 接口名称.静态方法（参数）；
* 总结：静态方法与对象没有关系，与类有关系。
*/

 

 

第一步：在MyInterfaceStatic上继续

 

第二步：创建实现类：MyInterfaceStaticImpl

 

第三步：创建类Demo03Interface

演示完后补充：静态跟对象没有关系，跟类有关系，所以不用new对象，直接通过接口名称调用方法就是正确的方法。

 

09_接口的私有方法定义（选讲）

第一步：创建类：MyInterfacePrivateA

 

第二步：java9新特性

 

10_接口的私有方法使用(选讲)

第一步：错误演示：MyInterfacePrivateAImpl

(只有MyInterfacePrivateA类中methodDefaultA和methodDefaultB方法能调用methodCommon方法)

 

第二步：MyInterfacePrivateB

 

第三步：测试Demo04Interface

 

11_接口的常量定义和使用

*
* 接口当中也可以定义“成员变量”，但必须使用public static final三个关键字修饰
*从效果上看，这其实就是接口的【常量】
* 格式：
* public static final  数据类型 常量名称 = 数据值；
* 备注：
* 一旦使用final关键字进行修饰，说明不可改变
*
*注意事项：
* 1、接口当中的常量，可以省略 public static final  ，注意：不写也照 样可以
* 2、接口当中的常量，必须进行赋值，不能不赋值。
* 3、接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐的命名规则）
*/

 

第一步：MyInterFaceConst   Const：常量

 

第二步：MyInterFaceConst  

 

 

第三步：使用时直接接口.常量

 

12_接口的内容小结

在java9+版本中，接口的内容可以有：

1、 成员变量其实就是常量，格式

【public】【static】【final】数据类型 常量名称 = 数据值；

注意：

     常量必须进行赋值，而且一量赋值不能改变。

     常量名称完全大写，用下划线进行分隔。

2、 接口中最重要的就是抽象方法，格式：

【public 】【abstract】 返回值类型   方法名称（参数列表）；

注意：实现类必须 覆盖重写接口所有的抽象方法，除非实现类是抽象类。

 

3、 从java 8开始，接口是允许 定义默认方法，格式：

【public】default 返回值类型 方法名称（参数列）{方法体}

 注意：默认方法可以被 覆盖重写。

 

4、 从java 8开始，接口是允许 定义静态方法，格式：

【public】 static 返回值类型 方法名称（参数列表）{方法体}

注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。

 

5、 从java 9开始，接口里允许 定义私有方法，格式：

普通私有方法：private  返回值类型 方法名称（参数列表） {方法体}

静态私有方法：private  static 返回值类型 方法名称（参数列表） {方法体}

注意：private的方法只有接口自己才能调用，不能被 实现类或别人使用。

13_继承父类并实现多个接口（难点）

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

 

第一二点讲解：(ch03.com.obtk_02.Demo01Interface)

 

第二步：ch03.com.obtk_02.MyInterface(错误写法示范)

 

第三步:

 

第四步：将MyInterface改为MyInterfaceA,增加抽象方法methodA

 

第五步：增加接口类MyInterfaceB，增加抽象方法MethodB

 

第六步：创建实现类：MyInterfaceImpl.java

 

第三点讲解：Demo01Interface （一二点讲完暂停）

 

第二步：第三点举例：

在MyInterfaceA和MyInterfaceB中增加相同方法：

 

第三步：第三点举例：MyInterfaceImpl中添加方法

 

第四点讲解Demo01Interface

 

第四点举例：创建类：MyInterfaceAbstract

 

第五点讲解：

如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。Demo01Interface

 

第五点举例：在MyInterfaceA和MyInterfaceB中增加相同方法：methodDefault()

输出内容分别是：默认方法AAA，默认方法BBB

 

 

 

 

问题描述：MyInterfaceImpl

 

解决办法：直接在MyInterfaceImpl中增加方法

 

 

继续解决：MyInterfaceAbstract

 

讲完暂停

第六点讲解：

 

第六点举例：创建父类Fu

 

创建子类Zi

 

还可以让你实现一个接口

 

 

讲解：Zi已经继承了Fu，同时也实现了MyInterface，那这样不是有问题了吗？刚才说了接口与接口之间默认方法的冲突一定要进行覆盖重写，但是我没有覆盖重写，他也是对的，

因为在这种情况之下，你觉得是优先Fu类还是优先MyInterface呢？肯定要优先Fu类。

在java中继承要优先接口实现。

 

14_接口之间的多继承

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

第一步：创建类：ch03.com.obtk_02. Demo01Relations

 

第二步：创建接口类：MyInterfaceA

 

第三步：创建接口类：MyInterfaceB

 

第四步：创建接口类MyInterface

 

问题：你觉得MyInterface有几个抽象方法？

第五步：增加抽象方法

 

 

第六步：在MyInterface中增加提问注释？

 

第七步：我如何证明有四个方法？创建实现类MyInterfaceImpl

 

讲解：MyInterface是一个子接口，其实他父接口的内容也有，这就是我们想说的接口与接口之间的多继承。但是如果要是有冲突怎么办？

我的A和B类中都有methodCommon方法，抽象方法能冲突得了吗？不能（因为他没有方法体）

第八步：Demo01Relations写注意事项

 

第九步：根据注意事项继承演示：MyInterfaceA,MyInterfaceB中增加默认方法

 

 

第十步：发现接口类MyInterface再次报错

 

讲解报错原因：这个时候吃饭了，父亲让你吃面条，母亲让你吃饭，那你会吃哪个？这个时候就会发生冲突。这个时候你总是要做出抉择。

第十一步：我的选择是重写方法：methodDefault()

 

第十二步：注意事项说明

 

 

 

 

posted @ 2021-04-29 22:10  丰斤豆  阅读(140)  评论(0)    收藏  举报