上一篇： Java学习（十一）—— Arrays类、Math类

第二十五部分 继承

25.1 概述

子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。继承描述的是事物之间的所属关系，这种关系是 is-a 的关系。

1. 提高代码的复用性。
2. 类与类之间产生了关系，是多态的前提。

25.2 格式

通过extends关键字，可以声明一个子类继承另外一个父类

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

创建父类

public class Employee { public void method() { System.out.println("方法执行！"); } } 

创建子类

public class Teacher extends Employee { } 

定义测试类

public class DemoExtends { public static void main(String[] args) { // 创建了一个子类对象 Teacher teacher = new Teacher(); // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。 teacher.method(); } } 

25.3 继承后的特点——成员变量

• 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

  • 直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有则向上找。
  • 间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则向上找。

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

创建父类

public class Fu { int numFu = 10; int num = 100; public void methodFu() { // 使用的是本类当中的，不会向下找子类的 System.out.println(num); } } 

创建子类

public class Zi extends Fu { int numZi = 20; int num = 200; public void methodZi() { // 因为本类当中有num，所以这里用的是本类的num System.out.println(num); } public void method() { int num = 300; System.out.println(num); // 30，局部变量 System.out.println(this.num); // 200，本类的成员变量 System.out.println(super.num); // 100，父类的成员变量 } } 

定义测试类

public class ExtendsField { public static void main(String[] args) { Fu fu = new Fu(); // 创建父类对象 System.out.println(fu.numFu); // 只能使用父类的东西，没有任何子类内容 System.out.println("==========="); Zi zi = new Zi(); System.out.println(zi.numFu); // 10 System.out.println(zi.numZi); // 20 System.out.println("==========="); // 等号左边是谁，就优先用谁 System.out.println(zi.num); // 优先子类，200 System.out.println("==========="); // 这个方法是子类的，优先用子类的，没有再向上找 zi.methodZi(); // 200 // 这个方法是在父类当中定义的， zi.methodFu(); // 100 } } 

Fu类中的成员变量是非私有的，子类中可以直接访问。若Fu类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

25.4 继承后的特点——成员方法

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

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

• 方法重载（Overload）： 方法的名称一样，参数列表不一样。

• 方法的覆盖重写特点： 创建的是子类对象，则优先用子类方法。

创建父类

public class Fu { public void methodFu() { System.out.println("父类方法执行！"); } public void method() { System.out.println("父类重名方法执行！"); } } 

创建子类

public class Zi extends Fu { public void methodZi() { System.out.println("子类方法执行！"); } public void method() { System.out.println("子类重名方法执行！"); } } 

定义测试类

public class ExtendsMethod { public static void main(String[] args) { Zi zi = new Zi(); zi.methodFu(); zi.methodZi(); // 创建的是子类对象，所以优先用子类方法 zi.method(); } } 

• 方法覆盖重写的注意事项

  • @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

  • 子类方法的返回值必须小于等于父类方法的返回值范围。
    扩展：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

  • 子类方法的权限必须大于等于父类方法的权限修饰符。
    扩展：public > protected > (default) > private，(default)不是关键字default，而是什么都不写，留空。

创建父类

public class Fu { Object method() { return null; } } 

创建子类

public class Zi extends Fu { @Override public String method() { return null; } } 

• 重写的应用

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从 而进行扩展增强。（以新老手机为例）

创建父类

public class Phone { public void call() { System.out.println("打电话"); } public void send() { System.out.println("发短信"); } public void show() { System.out.println("显示号码"); } } 

创建子类

public class NewPhone extends Phone { @Override public void show() { super.show(); // 把父类的show方法拿过来重复利用 // 自己子类再来添加更多内容 System.out.println("显示姓名"); System.out.println("显示头像"); } } 

定义测试类

public class DemoPhone { public static void main(String[] args) { Phone phone = new Phone(); phone.call(); phone.send(); phone.show(); System.out.println("=========="); NewPhone newPhone = new NewPhone(); newPhone.call(); newPhone.send(); newPhone.show(); } } 

重写时，用到super.父类成员方法，表示调用父类的成员方法。

25.5 继承后的特点——构造方法

继承关系中，父子类构造方法的访问特点

• 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
• 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作，所以子类必须调用父类的构造方法。子类的构造方法中默认有一个 super() ，表示调用父类的无参构造方法，父类成员变量初始化后，才可以给子类使用。
• 子类构造可以通过super关键字来调用父类重载构造。手动调用父类构造会覆盖默认的super()。
• super的父类构造调用，必须是子类构造方法的第一个语句，而且一个子类构造不能调用多次super构造。

创建父类

public class Fu { public Fu() { System.out.println("父类无参构造"); } public Fu(int num) { System.out.println("父类有参构造！"); } } 

创建子类

public class Zi extends Fu { public Zi() { super(); // 在调用父类无参构造方法，写不写都可以，默认存在的 //        super(20); // 在调用父类重载的构造方法 System.out.println("子类构造方法！"); } public void method() { //        super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。 } } 

25.6 super关键字三种用法

• 在子类的成员方法中，访问父类的成员变量。
• 在子类的成员方法中，访问父类的成员方法。
• 在子类的构造方法中，访问父类的构造方法。

创建父类

public class Fu { int num = 10; public void method() { System.out.println("父类方法"); } } 

创建子类

public class Zi extends Fu { int num = 20; public Zi() { super(); } public void methodZi() { System.out.println(super.num); // 父类中的num } public void method() { super.method(); // 访问父类中的method System.out.println("子类方法"); } } 

25.7 this关键字的三种用法

• 在本类的成员方法中，访问本类的成员变量。
• 在本类的成员方法中，访问本类的另一个成员方法。
• 在本类的构造方法中，访问本类的另一个构造方法。
• this(...)调用也必须是构造方法的第一个且唯一一个语句。
• super()和this()都必须是在构造方法的第一行，所以super和this两种构造调用不能同时使用。

创建父类

public class Fu { int num = 30; } 

创建子类

public class Zi extends Fu { int num = 20; public Zi() { //        super(); // 这一行不再有 this(123); // 本类的无参构造，调用本类的有参构造 } public Zi(int n) { this(1, 2); } public Zi(int n, int m) { } public void showNum() { int num = 10; System.out.println(num); // 局部变量 System.out.println(this.num); // 本类中的成员变量 System.out.println(super.num); // 父类中的成员变量 } public void methodA() { System.out.println("AAA"); } public void methodB() { this.methodA(); // 访问本类的另一个成员方法 System.out.println("BBB"); } } 

25.8 super与this关键字图解

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

• super ： 代表父类的存储空间标识（可以理解为父类的引用）。
• this ： 代表当前对象的引用（谁调用就代表谁）。

创建父类

public class Fu { int num = 10; public void method() { System.out.println("父类方法"); } } 

创建子类

public class Zi extends Fu { int num = 20; @Override public void method() { super.method(); // 调用了父类方法 System.out.println("子类方法"); } public void show() { int num = 30; System.out.println(num); // 30 System.out.println(this.num); // 20 System.out.println(super.num); // 10 } } 

定义测试类

public class Demo { public static void main(String[] args) { Zi zi = new Zi(); zi.show(); zi.method(); } } 

25.9 Java继承的三个特点

• Java只支持单继承，不支持多继承。
• Java支持多层继承(继承体系)。顶层父类是Object类。所有的类默认继承Object，作为父类。
• 子类和父类是一种相对的概念。
  

25.10 综合案例

• 题目

某群有多名成员，群主给成员发普通红包。普通红包的规则：

1. 群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。
2. 成员领取红包后，保存到成员余额中。

• 分析
  
• 实现

创建用户类

public class User { private String name; // 姓名 private int money; // 余额，也就是当前用户拥有的钱数 public User() { } public User(String name, int money) { this.name = name; this.money = money; } // 展示一下当前用户有多少钱 public void show() { System.out.println("我叫：" + name + "，我有多少钱：" + money); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } } 

创建群主类

import java.util.ArrayList; public class Manager extends User { public Manager() { } public Manager(String name, int money) { super(name, money); } public ArrayList<Integer> send(int totalMoney, int count) { // 首先需要一个集合，用来存储若干个红包的金额 ArrayList<Integer> redList = new ArrayList<>(); int leftMoney = super.getMoney(); // 群主当前余额 if (totalMoney > leftMoney) { System.out.println("余额不足"); return redList; // 返回空集合 } // 扣钱，其实就是重新设置余额 super.setMoney(leftMoney - totalMoney); // 发红包需要平均拆分成为count份 int avg = totalMoney / count; int mod = totalMoney % count; // 余数，也就是零头 // 除不开的零头，包在最后一个红包当中 // 把红包一个一个放到集合当中 for (int i = 0; i < count - 1; i++) { redList.add(avg); } // 最后一个红包 int last = avg + mod; redList.add(last); return redList; } } 

创建群成员类

import java.util.ArrayList; import java.util.Random; class Member extends User { public Member() { } public Member(String name, int money) { super(name, money); } public void receive(ArrayList<Integer> list) { // 从多个红包当中随便抽取一个 // 随机获取一个集合当中的索引编号 int index = new Random().nextInt(list.size()); // 根据索引，从集合当中删除，并且得到被删除的红包 int delta = list.remove(index); // 当前成员自己本来有多少钱： int money = super.getMoney(); // 加钱，并且重新设置回去 super.setMoney(money + delta); } } 

定义测试类

import java.util.ArrayList; public class MainRedPacket { public static void main(String[] args) { Manager manager = new Manager("群主", 100); Member one = new Member("成员A", 0); Member two = new Member("成员B", 0); Member three = new Member("成员C", 0); manager.show(); // 100 one.show(); // 0 two.show(); // 0 three.show(); // 0 System.out.println("==============="); // 群主总共发20块钱，分成3个红包 ArrayList<Integer> redList = manager.send(20, 3); // 三个普通成员收红包 one.receive(redList); two.receive(redList); three.receive(redList); manager.show(); // 100-20=80 // 6、6、8，随机分给三个人 one.show(); two.show(); three.show(); } } 

上一篇： Java学习（十一）—— Arrays类、Math类
下一篇： Java学习（十三）—— 抽象类

本文地址：https://blog.csdn.net/liuliuliu561/article/details/107676492

如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！