java开发语言的继承
第二十五部分 继承
25.1 概述
子类继承父类的属性
和行为
,使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有
的属性和行为。其中,多个类可以称为子类,单独那一个类称为父类、超类(superclass)或者基类。继承描述的是事物之间的所属关系,这种关系是 is-a
的关系。
- 提高代码的复用性。
- 类与类之间产生了关系,是多态的前提。
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 综合案例
- 题目
某群有多名成员,群主给成员发普通红包。普通红包的规则:
- 群主的一笔金额,从群主余额中扣除,平均分成n等份,让成员领取。
- 成员领取红包后,保存到成员余额中。
-
分析
- 实现
创建用户类
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(); } }
本文地址:https://blog.csdn.net/liuliuliu561/article/details/107676492
上一篇: 芋头的功效与作用有哪些 是什么
下一篇: 生吃胡萝卜的功效和作用 还可以益肝明目