欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java开发语言的继承

程序员文章站 2022-12-20 10:40:00
上一篇: Java学习(十一)—— Arrays类、Math类第二十五部分继承25.1概述子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。其中,多个类可以称为子类,单独那一个类称为父类、超类(superclass)或者基类。继承描述的是事物之间的所属关系,这种关系是 is-a 的关系。提高代码的复用性。类与类之间产生了关系,是多态的前提。25.2格式通过extends关键字,可以声明一个子类继承另外一个父....

上一篇: Java学习(十一)—— Arrays类、Math类

第二十五部分 继承

25.1 概述

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

  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; } } 
  • 重写的应用

子类可以根据需要,定义特定于自己的行为。既沿袭了父类的功能名称,又根据子类的需要重新实现父类方法,从 而进行扩展增强。(以新老手机为例)
java开发语言的继承
创建父类

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(); } } 

java开发语言的继承

25.9 Java继承的三个特点

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

25.10 综合案例

  • 题目

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

  1. 群主的一笔金额,从群主余额中扣除,平均分成n等份,让成员领取。
  2. 成员领取红包后,保存到成员余额中。
  • 分析
    java开发语言的继承
  • 实现

创建用户类

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