• 【Java快速入门】Java语言的三大基本特征--封装、继承和多态（九）

    本文目录

    一、本文目标

    二、封装

    2.1 封装的概念

    2.2 封装的原则

    2.3 封装的步骤

    2.4 封装的操作

    三、继承

    3.1 继承的概述

    3.2 继承的格式

    3.3 继承的特点

    3.3.1 成员变量

    3.3.2 成员方法

    四、多态

    一、本文目标

    本文内容包含面向对象的语言中的三大基本特征，即封装、继承和多态（面试的时候经常被问到哦，以后在代码开发过程中也会经常用到）。学完之后会理解封装思想和理解构造方法的含义，用封装思想定义一个标准类，了解继承的特点，什么是多态，多态的向上转型和向下转型等内容。

    二、封装

    2.1 封装的概念

    抛开抽象概念来讲，封装就是将一些复杂的或是不想让你看到的事物包装起来，叫做封装。从程序的角度来说就是，把一些内部复杂的逻辑或是不想让其他人员修改程序内部进而把部分程序包装起来，叫做封装。

    面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。

    封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

    2.2 封装的原则

    将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

    2.3 封装的步骤

    1. 使用 private 关键字来修饰成员变量。
    2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

    2.4 封装的操作

    使用 private 关键字封装

    private 关键字的含义

    1. private是一个权限修饰符，代表最小权限。
    2. 可以修饰成员变量和成员方法。
    3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。

    1、private 的使用格式

    private 数据类型 变量名 ；

    2、使用 private 修饰成员变量，示例代码如下：

    1. /**
    2.  * 定义一个学生类
    3.  */
    4. public class Student {
    5.     // private 修饰成员变量
    6.     // 姓名
    7.     private String name;
    8.     // 年龄
    9.     private int age;
    10. }

    3、提供 getXxx 方法 / setXxx 方法，可以访问成员变量，代码如下：

    其实，以下一个学生类的格式就是一个标准的 JavaBean 。

    1. /**
    2.  * 定义一个学生类
    3.  */
    4. public class Student {
    5.     // private 修饰成员变量
    6.     // 姓名
    7.     private String name;
    8.     // 年龄
    9.     private int age;
    10.  
    11.     // 对成员变量的 name 的 getter 方法
    12.     public String getName() {
    13.         return name;
    14.     }
    15.  
    16.     // 对成员变量的 name 的 setter 方法
    17.     public void setName(String name) {
    18.         this.name = name;
    19.     }
    20.  
    21.     // 对成员变量的 age 的 getter 方法
    22.     public int getAge() {
    23.         return age;
    24.     }
    25.  
    26.     // 对成员变量的 age 的 setter 方法
    27.     public void setAge(int age) {
    28.         this.age = age;
    29.     }
    30. }

    Tips：上述代码中的 this 代表什么含义呢？

    this 代表所在类的当前对象的引用（地址值），即对象自己的引用。

    重点：方法被哪个对象调用，方法中的 this 就代表哪个对象。即谁在调用，this 就代表谁。

    this 的使用格式

    this.成员变量名；

    三、继承

    3.1 继承的概述

    • 继承的概念

    继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

    • 继承的由来

    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。

    生活中继承示例如图所示：

    其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。

    继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，图中兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

    • 继承的优点

    继承是面向对象语言的重要机制。借助继承，可以扩展原有的代码，应用到其他程序中，而不必重新编写这些代码。

    所以它的优点就是 提高了代码的复用性。

    3.2 继承的格式

    通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

    class 父类 {
            ...
    }
    class 子类 extends 父类 {
            ...
    }

    继承的示例代码如下：

    1. /**
    2.  * 定义员工类 Employee，做为父类
    3.  */
    4. public class Employee {
    5.     // 定义员工姓名的属性
    6.     String name;
    7.     // 定义员工职位的属性
    8.     String position;
    9.  
    10.     // 定义员工的工作方法
    11.     public void goodWork() {
    12.         System.out.println("好好的工作！");
    13.     }
    14. }
    15.  
    16. /**
    17.  * 定义一个经理类 Manager 继承 员工类 Employee
    18.  */
    19. class Manager extends Employee {
    20.     // 定义一个打印 name 和 position 的方法
    21.     public void print() {
    22.         System.out.println("name = " + name);
    23.         System.out.println("position = " + position);
    24.     }
    25. }

     以下是测试类示例代码：

    1. public class ExtendDemo {
    2.     public static void main(String[] args) {
    3.         // 创建一个经理类对象
    4.         Manager manager = new Manager();
    5.         // 为该员工类的 name 属性进行赋值
    6.         manager.name = "小明";
    7.         // 为该员工类的 position 属性进行赋值
    8.         manager.position = "经理";
    9.         // 调用该员工的 print() 方法
    10.         manager.print(); // name = 小明，position = 经理
    11.  
    12.         // 调用 Manager 类继承来的work()方法
    13.         manager.goodWork(); // 好好的工作！
    14.     }
    15. }

    3.3 继承的特点

    Java 继承的特点有以下几个，希望读者能熟练掌握，面试的时候可能会经常被问到哦。生活中的例子，儿子、父亲、爷爷，可以用这三个身份来理解继承的特点，就会很容易理解啦。

    • Java 只支持单继承，不支持多继承。（可以这样理解，例如，在现实生活中，儿子只能有一个父亲，不可能同时有两个父亲）

    代码举例说明：

    // 一个类只能有一个父类，不可以有多个父类。
    class C extends A {} // 这样是正确的
    class C extends A ， B ... // 这样就是错误的，编译器就不会通过
    • Java 支持多层继承（继承体系）。（可以这样理解，儿子继承父亲，父亲继承爷爷）

    代码举例说明：C 继承 B，而 B 又继承 A

    // A 是爷爷，B 是父亲，C 是儿子
    class A {}
    class B extends A {}
    class C extends B {}

    Tips：在Java语言体系中，Object 类是顶层父类 。所有的类都默认继承 Object 类。

    • 子类和父类是一种相对的概念。

    3.4 继承后的变化

    3.4.1 成员变量的变化

    • 成员变量不重名

    如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。可以放心使用和访问。示例代码如下：

    1. public class FuClassDemo1 {
    2.     public static void main(String[] args) {
    3.         // 创建子类对象
    4.         ZiClass1 ziClass1 = new ZiClass1();
    5.         // 调用子类中的 print() 打印方法
    6.         ziClass1.print();
    7.     }
    8. }
    9.  
    10. class FuClass1 {
    11.     // Fu类中的成员变量
    12.     int num1 = 10;
    13. }
    14.  
    15. class ZiClass1 extends FuClass1 {
    16.     // Zi类中的成员变量
    17.     int num2 = 20;
    18.     // Zi类中的成员方法
    19.     public void print() {
    20.         // 访问父类中的 num1
    21.         System.out.println("Fu类中的 num1 = " + num1); // 这是从父类中继承而来的，所以能直接访问。
    22.         // 访问子类中的 num2
    23.         System.out.println("Zi类中的 num2 = " + num2);
    24.     }
    25. }

    上述代码运行后的结果如下：

    • 成员变量重名时

    但是如果子类中使用与父类中名字相同的成员变量时，这就会产生影响，下面举例说明：

    1. public class FuClassDemo2 {
    2.     public static void main(String[] args) {
    3.         // 创建子类对象
    4.         ZiClass2 ziClass2 = new ZiClass2();
    5.         // 调用子类中的 print() 打印方法
    6.         ziClass2.print();
    7.     }
    8. }
    9.  
    10. class FuClass2 {
    11.     // Fu类中的成员变量
    12.     int num = 30;
    13. }
    14.  
    15. class ZiClass2 extends FuClass2 {
    16.     // Zi类中的成员变量
    17.     int num = 40;
    18.  
    19.     // Zi类中的成员方法
    20.     public void print() {
    21.         // 访问父类中的 num
    22.         System.out.println("Fu类中的 num = " + num);
    23.         // 访问子类中的 num
    24.         System.out.println("Zi类中的 num = " + num);
    25.     }
    26. }

    运行结果如下：

    子类中有与父类中相同名字的成员变量时，结果运行和预期结果（Fu类中的 num = 30，Zi类中的 num = 40）大相径庭。

    • 什么原因导致的呢？

    程序访问变量时遵循了就近原则，所以在子类中访问同一个 非私有的成员变量时，就近的访问了子类中的 成员变量，所以就出现了上述运行结果。那么该怎么访问父类中的成员变量呢？这就会用到另外一个关键字，super 关键字。

    子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，super 关键字的用法类似于之前学过的 this 。

    Tips：在以后的实际代码开发过程中，我们应该尽量避免使用同名的成员变量。

    super 的使用格式：

    super . 父类成员变量名

    子类方法需要修改，代码如下： 

    1. public class FuClassDemo3 {
    2.     public static void main(String[] args) {
    3.         // 创建子类对象
    4.         ZiClass3 ziClass3 = new ZiClass3();
    5.         // 调用子类中的 print() 打印方法
    6.         ziClass3.print();
    7.     }
    8. }
    9.  
    10. class FuClass3 {
    11.     // Fu类中的成员变量
    12.     int num = 30;
    13. }
    14.  
    15. class ZiClass3 extends FuClass3 {
    16.     // Zi类中的成员变量
    17.     int num = 40;
    18.     // Zi类中的成员方法
    19.     public void print() {
    20.         // 访问父类中的 num
    21.         System.out.println("Fu类中的 num = " + super.num);
    22.         // 访问子类中的 num
    23.         System.out.println("Zi类中的 num = " + this.num);
    24.     }
    25. }

    修改后的程序运行结果便和我们预期的一致了：

    3.4.2 成员方法的变化

    • 成员方法不重名时

    如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

    代码如下：

    1. public class FuClassDemo4 {
    2.     public static void main(String[] args) {
    3.         // 创建子类对象
    4.         ZiClass4 ziClass4 = new ZiClass4();
    5.         // 调用子类中的方法
    6.         ziClass4.showZi();
    7.         // 子类中没有 showFu() 方法，所以它就会去它的父类中找 showFu() 方法去执行
    8.         ziClass4.showFu();
    9.     }
    10. }
    11.  
    12. class FuClass4 {
    13.     // 父类中的 showFu() 方法
    14.     public void showFu() {
    15.         System.out.println("Fu类中的 showFu()方法被执行!");
    16.     }
    17. }
    18.  
    19. class ZiClass4 extends FuClass4 {
    20.     // 父类中的 showZi() 方法
    21.     public void showZi() {
    22.         System.out.println("Fu类中的 showZi()方法被执行!");
    23.     }
    24. }
    • 成员方法重名时

    如果子类父类中出现重名的成员方法，这个时候，成员方法重名，就会出现一种特殊情况，叫做方法重写 (Override)。

    方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和入参列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

    示例代码如下：

    1. public class FuClassDemo5 {
    2.     public static void main(String[] args) {
    3.         // 创建子类对象
    4.         ZiClass5 ziClass5 = new ZiClass5();
    5.         // 子类中有 show() 方法，只执行重写后的 show() 方法
    6.         ziClass5.show();
    7.     }
    8. }
    9.  
    10. class FuClass5 {
    11.     // 父类中的 show() 方法，注意这里的返回是 void，方法名是 show，入参为空！
    12.     public void show() {
    13.         System.out.println("Fu类中的 show()方法被执行!");
    14.     }
    15. }
    16.  
    17. class ZiClass5 extends FuClass5 {
    18.     // 子类中的 show() 方法，注意这里的返回是 void，方法名是 show，入参为空！这三项都与父类相同
    19.     public void show() {
    20.         System.out.println("Zi类中的 show()方法被执行!");
    21.     }
    22. }

    运行结果：

    Tips：这里的重写，如果想用父类的方法，就需要用到 super 关键字，即 super.父类方法。表示调用父类的成员方法。

    注意事项：

    1. 子类方法覆盖父类方法，必须要保证该方法的访问权限大于等于父类权限。
    2. 子类方法覆盖父类方法，返回值类型、函数名和入参列表都要一模一样，否则就不是方法重写了。

    3.4.3 构造方法的变化

    首先我们要知道两个事情，即构造方法的定义格式和作用。

    1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
    2. 构造方法的作用是初始化成员变量的。

    所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super()，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

    示例代码如下：

    1. public class FuClassDemo6 {
    2.  
    3.     public static void main(String[] args) {
    4.         // 创建子类对象
    5.         ZiClass6 ziClass6 = new ZiClass6();
    6.     }
    7. }
    8.  
    9. class FuClass6 {
    10.     private int fu;
    11.     // 父类的构造方法
    12.     FuClass6() {
    13.         System.out.println("父类中的构造方法被执行了！");
    14.     }
    15.  
    16. }
    17.  
    18. class ZiClass6 extends FuClass6 {
    19.     // 子类中的构造方法
    20.     ZiClass6() {
    21.         // super() 方法，调用父类的构造方法
    22.         super();
    23.         System.out.println("子类中的构造方法被执行了！");
    24.     }
    25. }

    程序运行结果：

     

    四、多态

    完结！

  • 相关阅读:
    技术分享| anyRTC音视频混流技术解析
    Python内置函数--iter()&next()
    Leetcode—3148. 矩阵中的最大得分【中等】
    windows服务器限制特定ip访问指定端口(服务器ip白名单)
    【牛客刷题日记】— Javascript 通关秘籍
    洛谷P3369 【模板】普通平衡树 红黑树实现
    echart 两个柱状图并列，共用一个y轴的label
    Linux 多进程解决客户端与服务器端通信
    Redis集群
    Jenkinsfile+Dockerfile前端vue自动化部署
  • 原文地址：https://blog.csdn.net/weixin_44299027/article/details/125793577