• 【Java快速入门】Java语言的抽象类和接口（十）

    本文目录

    一、本文目标

    二、抽象类

    2.1 抽象类概念

    2.2 抽象方法

    2.3 抽象类

    2.4 抽象方法和抽象类的使用

    2.5 注意事项

    三、接口

    3.1 接口的概念

    3.2 接口的定义

    3.2.1 含有抽象方法

    3.2.2 含有默认方法

    3.2.3 含有静态方法

    3.2.4 含有私有方法和私有静态方法

    3.3 基本的实现

    3.3.1 实现的概述

    3.3.2 抽象方法的使用

    3.3.3 默认方法的使用

    3.3.4 静态方法的使用

    3.3.5 私有方法的使用

    3.4 接口的多实现

    3.4.1 抽象方法

    3.4.2 默认方法

    3.4.3 静态方法

    3.4.4 优先级的问题

    一、本文目标

    第一：描述抽象方法的概念、写出抽象类的格式和抽象方法的格式、能够说出父类抽象方法的存在意义；

    第二：写出定义接口的格式并实现接口的格式，掌握接口中成员的特点；

    二、抽象类

    2.1 抽象类概念

    Java语法规定，包含抽象方法的类就是抽象类。

    父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法，而包含抽象方法的类就是抽象类。

    所以我们定义：

    抽象方法 ： 没有方法体的方法。

    抽象类：包含抽象方法的类。

    2.2 抽象方法

    使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

    定义的格式：

    修饰符 abstract 返回值类型 方法名 ( 参数列表 ) ；

    代码举例：

    public abstract void run () ；

    2.3 抽象类

    如果一个类包含抽象方法，那么该类必须是抽象类。

    定义的格式：

    abstract class 类名字 {
    }

    代码举例：

    public abstract class Animal {
            public abstract void run () ；
    }

    2.4 抽象方法和抽象类的使用

    继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法。

    抽象类不对创建对象，所以如果从最初的父类到所有的子类都没有重写父类的抽象方法，那么所有的类都不能创建对象，这样就失去了意义。

    代码示例：

    1. public abstract class AbstractClassAnimal {
    2.  
    3.     public static void main(String[] args) {
    4.         // 创建子类的对象
    5.         Cat cat = new Cat();
    6.         // 调用 run() 方法
    7.         cat.run();
    8.     }
    9. }
    10.  
    11. /**
    12.  * 这是一个抽象类（包含有一个抽象方法的类），抽象类动物
    13.  */
    14. abstract class Animal {
    15.     /**
    16.      * 这是一个抽象方法（只有方法声明，没有方法体），抽象方法跑
    17.      */
    18.     public abstract void run();
    19. }
    20.  
    21. class Cat extends Animal {
    22.  
    23.     @Override
    24.     public void run() {
    25.         System.out.println("小猫在轻轻地走~~~");
    26.     }
    27. }

    此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

    2.5 注意事项

    关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，则不需要记忆就能写出代码。

    • 1、抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

    理解方法：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，所以这样做没有意义。

    • 2、抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

    理解方法：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

    • 3、抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

    理解方法：子类的构造方法中，有默认的super()，可以访问父类构造方法。

    • 4、抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

    理解方法：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，这样做也没有意义。

    三、接口

    3.1 接口的概念

    接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，它包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。

    接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成 .class 文件，但一定要明确它并不是类，而是另外一种引用数据类型。

    引用数据类型：数组，类，接口。

    接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

    3.2 接口的定义

    public interface 接口名称 {
            // 抽象方法
            // 默认方法
            // 静态方法
            // 私有方法
    }

    3.2.1 含有抽象方法

    抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

    代码示例：

    1. /**
    2.  * 这是一个含有抽象方法的接口
    3.  */
    4. public interface InterfaceNameAbstractMethod {
    5.  
    6.     /**
    7.      * 这是一个抽象方法
    8.      */
    9.     public abstract void method();
    10. }

    3.2.2 含有默认方法

    默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

    代码示例：

    1. /**
    2.  * 这是一个含有默认方法的接口
    3.  */
    4. public interface InterfaceNameDefaultMethod {
    5.  
    6.     /**
    7.      * 这是一个默认方法
    8.      */
    9.     public default void method() {
    10.         System.out.println("这里就是一个默认方法体！");
    11.     }
    12. }

    3.2.3 含有静态方法

    静态方法：使用 static 修饰，供接口直接调用。

    1. /**
    2.  * 这是一个含有静态方法的接口
    3.  */
    4. public interface InterfaceNameStaticMethod {
    5.     /**
    6.      * 这里是一个静态方法
    7.      */
    8.     public static void method() {
    9.         System.out.println("这里是一个静态方法体！");
    10.     }
    11. }

    3.2.4 含有私有方法和私有静态方法

    私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

    示例代码：

    1. /**
    2.  * 这是一个含有私有方法和私有静态方法的接口，JDK9以及以上版本才支持
    3.  */
    4. public interface InterfaceNamePrivateMethod {
    5.  
    6.     /**
    7.      * 这里一个私有方法，JDK9以及以上版本才支持
    8.      */
    9.     private void method() {
    10.         System.out.println("这里一个私有方法！");
    11.     }
    12.  
    13.     /**
    14.      * 这里一个私有静态方法，JDK9以及以上版本才支持
    15.      */
    16.     private static void method() {
    17.         System.out.println("这里一个私有静态方法！");
    18.     }
    19. }

    3.3 基本的实现

    3.3.1 实现的概述

    类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。

    非抽象子类实现接口：

    • 1. 必须重写接口中所有抽象方法。
    • 2. 继承了接口的默认方法，即可以直接调用，也可以重写。

    实现格式：

    class 类名 implements 接口名 {
            // 重写接口中抽象方法【必须】
            // 重写接口中默认方法【可选】
    }

    3.3.2 抽象方法的使用

    接口里的抽象方法必须全部实现，代码如下：

    定义接口：

    1. /**
    2.  * 定义一个动物的接口
    3.  */
    4. public interface AnimalInterface {
    5.     // 定义动物吃的抽象方法
    6.     public abstract void eat();
    7.     // 定义动物睡的抽象方法
    8.     public abstract void sleep();
    9. }

    定义接口的实现类：

    1. /**
    2.  * 定义动物接口的实现类
    3.  */
    4. public class AnimalInterfaceImpl implements AnimalInterface {
    5.     
    6.     @Override
    7.     public void eat() {
    8.         System.out.println("动物吃东西！");
    9.     }
    10.  
    11.     @Override
    12.     public void sleep() {
    13.         System.out.println("动物睡觉！");
    14.     }
    15. }

    定义测试方法：

    1. public class AnimalInterfaceDemo {
    2.     public static void main(String[] args) {
    3.         // 创建子类对象
    4.         AnimalInterfaceImpl animalInterface = new AnimalInterfaceImpl();
    5.         // 调用实现后的方法
    6.         animalInterface.eat();
    7.         animalInterface.sleep();
    8.     }
    9. }

    3.3.3 默认方法的使用

    可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

    • 1、继承默认方法，代码如下：
    1. /**
    2.  * 定义接口
    3.  */
    4. public interface LiveAble {
    5.     
    6.     public default void fly() {
    7.         System.out.println("在天上飞！");
    8.     }
    9. }
    10.  
    11. /**
    12.  * 定义实现类
    13.  */
    14. class AnimalDemo1 implements LiveAble {
    15.     // 继承，什么都不用写，直接调用
    16. }
    17.  
    18. /**
    19.  * 定义测试类
    20.  */
    21. class AnimalDemo1Test {
    22.     public static void main(String[] args) {
    23.         // 创建子类的对象
    24.         AnimalDemo1 animalDemo1 = new AnimalDemo1();
    25.         // 调用默认方法
    26.         animalDemo1.fly();
    27.     }
    28. }
    • 2、重写默认方法，代码如下： 
    1. /**
    2.  * 定义接口
    3.  */
    4. public interface LiveAble1 {
    5.     /**
    6.      * 定义默认方法
    7.      */
    8.     public default void fly() {
    9.         System.out.println("在天上飞！");
    10.     }
    11. }
    12.  
    13. /**
    14.  * 定义实现类
    15.  */
    16. class AnimalDemo2 implements LiveAble1 {
    17.     @Override
    18.     public void fly() {
    19.         System.out.println("在天空自由自在的飞翔！");
    20.     }
    21. }
    22.  
    23. class AnimalDemo2Test {
    24.     public static void main(String[] args) {
    25.         // 创建子类对象
    26.         AnimalDemo2 animalDemo2 = new AnimalDemo2();
    27.         // 调用重写后的方法
    28.         animalDemo2.fly();
    29.     }
    30. }

    3.3.4 静态方法的使用

    静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，

    代码如下：

    1. /**
    2.  * 定义接口
    3.  */
    4. public interface LiveAble2 {
    5.     /**
    6.      * 定义静态方法
    7.      */
    8.     public static void run() {
    9.         System.out.println("兴高采烈的跑起来......");
    10.     }
    11. }
    12.  
    13. /**
    14.  * 定义实现类
    15.  */
    16. class AnimalDemo3 implements LiveAble2 {
    17.     // 无法重写静态方法
    18. }
    19.  
    20. /**
    21.  * 定义测试类
    22.  */
    23. class AnimalDemo3Test {
    24.     public static void main(String[] args) {
    25.         // 无法继承方法，也无法调用
    26.         // AnimalDemo3.run();
    27.         LiveAble2.run();
    28.     }
    29. }

    3.3.5 私有方法的使用

    • 私有方法：只有默认方法可以调用。
    • 私有静态方法：默认方法和静态方法可以调用。

    如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

    代码示例：

    1. /**
    2.  * 定义接口
    3.  */
    4. public interface LiveAble3 {
    5.  
    6.     default void run() {
    7.         run1();
    8.         run2();
    9.     }
    10.  
    11.     private void run1() {
    12.         System.out.println("run1 跑起来......");
    13.     }
    14.  
    15.     private void run2() {
    16.         System.out.println("run2 跑起来......");
    17.     }
    18. }

    3.4 接口的多实现

    咱们之前都学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

    实现格式：

    class 类名 [ extends 父类名 ] implements 接口名 1 , 接口名 2 , 接口名 3 ... {
            // 重写接口中抽象方法【必须】
            // 重写接口中默认方法【不重名时可选】
    }

    [ ]： 表示可选操作。

    3.4.1 抽象方法

    接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：

    1. public interface InterfaceA {
    2.     public abstract void printA();
    3.     public abstract void print();
    4. }
    5.  
    6. interface InterfaceB {
    7.     public abstract void printB();
    8.     public abstract void print();
    9. }
    10.  
    11. class C implements InterfaceA, InterfaceB {
    12.  
    13.     @Override
    14.     public void printA() {
    15.         System.out.println("printA");
    16.     }
    17.  
    18.     @Override
    19.     public void printB() {
    20.         System.out.println("printB");
    21.     }
    22.  
    23.     @Override
    24.     public void print() {
    25.         System.out.println("print");
    26.     }
    27. }

    3.4.2 默认方法

    接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。代码如下：

    1. /**
    2.  * 定义接口D
    3.  */
    4. public interface InterfaceD {
    5.     public default void methodD() {
    6.     }
    7.  
    8.     public default void printMethod() {
    9.     }
    10. }
    11.  
    12. /**
    13.  * 定义接口E
    14.  */
    15. interface InterfaceE {
    16.     public default void methodE() {
    17.     }
    18.  
    19.     public default void printMethod() {
    20.     }
    21. }
    22.  
    23. /**
    24.  * 定义实现类
    25.  */
    26. class F implements InterfaceD, InterfaceE {
    27.  
    28.     @Override
    29.     public void printMethod() {
    30.         System.out.println("这里是一个打印的方法！");
    31.     }
    32. }

    3.4.3 静态方法

    接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

    3.4.4 优先级的问题

    当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码如下：

    1. /**
    2.  * 定义一个接口G
    3.  */
    4. public interface InterfaceG {
    5.     public default void methodG() {
    6.         System.out.println("接口G的中方法G！");
    7.     }
    8. }
    9.  
    10. /**
    11.  * 定义一个父类
    12.  */
    13. class ClassG {
    14.     public void methodG() {
    15.         System.out.println("类G中的方法G！");
    16.     }
    17. }
    18.  
    19. /**
    20.  * 定义一个子类并继承父类实现接口G
    21.  */
    22. class ClassH extends ClassG implements InterfaceG {
    23.     // 未重写 methodG 方法
    24. }
    25.  
    26. /**
    27.  * 定义测试类
    28.  */
    29. class DemoTest {
    30.     public static void main(String[] args) {
    31.         // 创建子类对象
    32.         ClassH classH = new ClassH();
    33.         // 调用接口的方法
    34.         classH.methodG();
    35.     }
    36. }

    运行结果如下：

     

    完结！

  • 相关阅读:
    Unity切换到另一个场景的时候，发现该场景变暗了
    OpenCV4（C++）—— 几何图形的绘制
    云计算实战应用案例精讲-【概念篇】多模态（附实战应用案例）
    数据库 - 创建数据库、表、函数等
    SkyEye助力火箭“一”飞冲天
    大规模语言模型人类反馈对齐--RLHF
    nginx的下载安装配置（Window）
    大学生WEB前端静态网页——旅游介绍35页 响应式,
    中国范围逐月夜间灯光数据（2012-2021年）
    C#知识点、常见面试题
  • 原文地址：https://blog.csdn.net/weixin_44299027/article/details/125958706