第三章：继承和父子构造器、方法重写

已于 2022-04-01 19:04:56 修改
阅读量388 收藏 2
点赞数
文章标签： java 开发语言 后端
于 2022-03-20 15:04:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47692173/article/details/123591826
版权

extends关键字

  1. 表示继承

  2. 概念：子类继承父类的属性及行为，使得子类的对象具有父类相同的属性及行为

  3. 父类别称：基类、超类
    子类别称：派生类

  4. 继承的优点：提高代码的可重用性、可维护性及可扩展性

  5. 继承的关系式：is-a的关系
    例 class 食肉动物 extends 动物 { }
    关系式：食肉动物 是 动物

代码演示：extends关键字的基本使用

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "仲永";
        student.run();
        student.study();

        System.out.println("---------------------");
        Teacher teacher = new Teacher();
        teacher.name = "卡卡";
        teacher.run();
        teacher.education();
    }
}

class Person {		 // 父类
    String name;	 // 共用属性
    void run () {	 // 共用方法
        System.out.println("每天运动一小时");
    }
}

// 继承格式：子类 extends 父类
class Student extends Person{
	// 学生特有的行为
    void study() {
        System.out.println(name +"学生的任务是学习");
    }
}

class Teacher extends Person{
	// 老师特有的行为
    void education() {
        System.out.println(name + "老师的任务是教书育人");
    }
}

父子类的访问特点

  1. 子类继承非私有的属性和方法，子类对象可以直接访问
  2. 针对私有的属性及方法，子类对象不能直接访问，但可通过父类提供的公共方法间接访问

代码演示：子类间接访问父类的属性及行为

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println("名字：" + student.getName());	// 解析：间接访问父类的属性
		//（student.getName()值为null）
        student.getRunMethod();	// 解析：间接访问父类的行为
    }
}
class Person {
	// 属性行为都私有化
    private String name;
    private void run () {
        System.out.println("每天运动一小时");
    }

    public String getName() {
        return name;
    }
    public void getRunMethod() {
        run();
    }
}
class Student extends Person{
    // 无法直接访问父类中私有的属性及行为
    // 解决方式：通过父类提供的公共方法间接访问
}

代码演示：子类访问父类的属性的优先级

在继承类中，子类访问属性的规则

  1. 子类优先在本类中访问属性
  2. 当子类中无属性，到父类中调用
  3. 当父类中无属性，到父类的父类中调用，
  4. 若父类的父类中有属性则进行调用；若没有继续向父类寻找，直至到Object结束访问

注意：子类无论是访问父类的属性或方法，规则与子类访问属性的规则同理

public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.name);   // 运行结果：大头
        // 子类优先调用本类中的属性或方法

        System.out.println(son.age);    // 运行结果：28
        // 当子类中无属性时，到父类中调用

        System.out.println(son.hobby);  // 运行结果：下棋
        // 当父子类中都无属性时，到爷类中调用，直至到Object结束访问

    }
}
class Grandpa { // 爷类
    String name = "大头爷爷";
    String hobby = "下棋";
}
class Father extends Grandpa {  // 父类
    String name = "大头爸爸";
    int age = 28;
}
class Son extends Father {  // 子类
    String name = "大头";
}

父子类的构造器

继承关系中，子类必须调用父类的构造器，完成父类的初始化

  1. 当创建子类对象时，子类不管使用哪个构造器，默认情况下调用父类的无参构造器
  2. 当父类中没有无参构造器，但存在有参构造器，说明父类中的无参构造器被覆盖
    子类构造器无法直接调用父类无参构造器，需手动添加一个“显式”无参构造器再调用
    子类构造器中调用父类有参构造器，使用super指定的父类有参构造器，并完成父类的初始化
  3. super() 与 this() 必须放置构造器第一行，因此一个构造器不能两个同时存放

代码演示：子类构造器 默认访问 父类无参构造方法

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();	// 证明：子类构造器中有个隐式的super()构造器
        Student student2 = new Student(12);
        /*	运行结果：
       		父类无参构造方法已运行！
			子类无参构造方法已运行！
			父类无参构造方法已运行！
			子类有参构造方法已运行！
        */
    }
}
class Person {
    Person() {
        System.out.println("父类无参构造方法已运行！");
    }
}
class Student extends Person {
    Student() {
        System.out.println("子类无参构造方法已运行！");
    }
    Student(int num) {
        super();	// 使用super，必须放置子类构造器第一行。可省略不写
        System.out.println("子类有参构造方法已运行！");
    }
}

代码演示：子类构造器 访问 父类有参构造方法

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        /*	运行结果：
			父类有参构造方法开始运行！
			子类无参构造方法开始运行！
		*/
    }
}
class Person {
    Person(int a) {
        System.out.println("父类有参构造方法开始运行！");
    }
}
class Student extends Person {
    Student() {
        super(20);	// 调用父类有参构造器，必须使用super指定的父类构造器
        System.out.println("子类无参构造方法开始运行！");
    }
}

代码演示：子类构造器 访问 父类构造器

子类构造器访问父类构造器，这是毋庸置疑的。但是子类构造器不能访问父类上级的构造器（子类构造器无法访问爷类的构造器）

public class Test {
    public static void main(String[] args) {
        C c = new C();
        /*	运行结果：
        	爷爷构造器
			爸爸构造器
			儿子构造器
        */
    }
}
class A {
    public A() {
        System.out.println("爷爷构造器");
    }
}
class B extends A {
    public B() {
        System.out.println("爸爸构造器");
    }
}
class C extends B {
    public C() {
        System.out.println("儿子构造器");
    }
}

super 与 this 的三种用法

super的三种用法

  1. 在子类的构造方法中，访问父类的构造方法

  2. 在子类的成员方法中，访问父类的成员变量

  3. 在子类的成员方法中，访问父类的成员方法

  4. super在访问属性或调用方法时，从父类开始查找
    若父类中没有该属性或方法，则在父类的上级类继续查找

代码演示：super的三种用法

public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.method1();
        son.method2();
    }
}

class Father {  // 父类
    int i = 10;
    public Father() {
        System.out.println("父类无参构造器已执行");
    }
    public void work() {
        System.out.println("父亲是秃头工程师");
    }
}

class Son extends Father {  // 子类
    // 1. 访问父类的构造方法
    public Son() {
        super();
    }
    // 2. 访问父类的属性
    void method1() {
        System.out.println("父类属性i=" + super.i);
    }
    // 3. 访问父类的方法
    void method2() {
        super.work();
    }
}

this的三种用法

  1. 在本类的构造方法中，访问本类的构造方法【注意：多个构造方法间不能相互调用避免死循环现象】

  2. 在本类的成员方法中，访问本类的成员变量

  3. 在本类的成员方法中，访问本类其他的成员方法

  4. this在访问属性或调用方法时，从本类开始查找
    若本类中没有该属性或方法，则在父类继续查找

代码演示：this的三种用法

public class Test {
    public static void main(String[] args) {
        Father father = new Father();
        father.method2();
    }
}

class Father {  // 父类
    int i;
    public Father() {
        this(66);   // 1. 访问本类的构造方法
        System.out.println("无参构造器已执行");
    }
    public Father(int i) {
        System.out.println("有参构造器已执行");
    }
    public void method1() {
        System.out.println("属性i=" + this.i);    // 2. 访问本类的属性
    }

    public void method2() {
        this.method1();    // 3. 访问本类的行为
    }
}

方法重写（Override）

方法重写的规则
	1. 重写发生在继承关系中
	2. 子类方法的参数列表和方法名称要与父类方法的的参数列表和方法名称完全一致
	3. 基本数据类型：子类成员方法的类型和父类成员方法的类型相同
	   引用数据类型：父类成员方法的类型可以是父类也可以是子类
	  					父类成员方法的类型是父类，子类的重写方法的类型可以是父类也可以是子类
	  					父类成员方法的类型是子类，子类的重写方法的类型只能是子类
	4. 子类成员方法的访问权限 “大于或等于” 父类成员方法的访问权限
		权限排序：public > protected > 默认 > private
		特殊情况：父类的成员方法权限是private，子类的成员方法权限无法重写
				 父类的成员方法权限是public，子类的成员方法权限必须是public

代码演示：方法重写的应用

父子类中都有 eat方法，子类优先调用本类的eat方法
这里不能很好的体现方法重写的作用，在后面“多态、抽象类”等章节中更好的体现

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();	// 运行结果：狗吃骨头
    }
}
class Animal {
    public void eat() {
        System.out.println("动物吃食物");
    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

代码演示：引用数据类型的重写

class AAA {  
    public BBB method() {
        return null;
    }
}
class BBB extends AAA {
    public BBB method() {
        return null;
    }
}

小练习：封装+构造器+重写 三者综合应用

题目
	1. 编写一个Person类，包含属性/private（name、age），构造器，方法say（返回自我介绍的字符串）
	2. 编写一个Student类，继承Person类，增加id、score属性/private，以及构造器，定义say方法（返回自我介绍的字符串）
	3. 在main中，分别创建Person和Student对象，调用say方法输出自我介绍

public class Test {
    public static void main(String[] args) {
        Person person = new Person("小黄",23);
        System.out.println(person.say());   // 运行结果：小黄 年龄：23
        Student student = new Student("大白",18,32,123);
        System.out.println(student.say());
        // 运行结果：大白 年龄：18 学号：32 分数：123
    }
}
class Person {
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String say() {
        return getName() + " 年龄：" + getAge();
    }
}
class Student extends Person {
    public Student(String name,int age,int id,int score) {
        super(name,age);
        this.id = id;
        this.score = score;
    }

    private int id;
    private int score;

    public int getId() {
        return id;
    }

    public int getScore() {
        return score;
    }

    @Override
    public String say() {
        return super.say() + " 学号：" + getId() + " 分数：" + getScore();
    }
}

自我总结

此练习遇到的问题
	1. say方法没有注意返回值类型。我本以为是void
	2. private修饰词一定想到两种解决方案
		a.初始化可通过构造器或set方法
		b.获取可通过get方法
	3. 本题提到构造器，则使用a方案
	4. 本提涉及父子类构造器，而我忘记了一个知识点
			父类中只有有参构造器，那么子类通过super(参数)指定调用
	5. String返回值可以直接（return 字符串），这是我第一次使用
鸠鸠不会编程
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA基础之继承与构造器
Montes的博客
11-04 413
继承就是子类可以通过继承获得父类非私有的属性和方法。换句话说，继承使得子类具有以及可以访问父类所有非私有的特征。 JAVA只支持单继承，也就是子类不可以继承自两个父类。 继承是面向对象的基石，继承的关系表示为“is-a”，在JAVA中用extends关键字表示继承。 一般来说，父类更为抽象，子类更为具体。 继承使得代码的复用性高。 但是继承会提高代码之间的耦合性，耦合性越高，代码联系越紧密，在后期...
构造器(继承)
hooandlee的博客
02-18 683
一个普通类（A）可以不定义构造器，此时它的构造器是默认构造器public A(){};。  一个普通类（A）定义了构造器（非默认），此时它的构造器只是声明的构造器。没有默认构造器了。   一个普通子类（Son）的构造器： 父类（Father）不定义构造器，或为 public Father(){};，子类可不用声明构造器，此时它的构造器是public Son(){super()；};。 父...
继承和构造器之间的关系
weixin_43637073的博客
04-05 225
不知道大家有没有遇到这样的问题。当两个类毫无关系时，你的构造器有参和无参都行，不会影响对方。但是当一个类和另一个类是继承关系呢？假设父类的构造器是有参的，而子类是无参的，此时就会报错，这里牵扯到super的用法。片 ...
Java继承——代码块与构造器
XCMercy
06-01 200
示例 class Parent { static { System.out.println("Parent's static code block..."); } { System.out.println("Parent's constructor code block..."); } public Parent() {...
java关于子类与父类构造器的继承与重写
weixin_45981960的博客
11-26 775
子类继承父类时 1、若父类有显式写出了有参构造器，父类必须显式写出无参构造器。 2、若父类没有显式写出有参构造器，父类的无参构造器可写可不写 子类无法重写父类的无参与有参的构造器 ...
Java-常见面试题.pdf
07-21
3. 创建第二个同名子类对象：父类动态块->父类无参构造器->被调子类动态块->被调子类无参构造器 注意：同名之类被创建之后，其同名静态块不会再次执行。 总结 1. 不同名子类之间的静态块不会相互调用，也没有任何...
java基础，入门的最好笔记
07-14
继承允许子类继承父类的属性和方法，增强了代码复用性。 8. **构造方法调用顺序**：创建子类对象时，会先调用父类的构造方法（如果没有指定，会调用无参构造器），然后执行子类的构造方法。 9. **super关键字**：...
21天学通Java-由浅入深
06-06
202 10.3.3 父子类间的构造器的调用流程 204 10.3.4 如何自定义构造器 207 10.4 什么是单子模式 208 10.5 构造器在程序中是何时运行的 211 10.6 综合练习 214 10.7 小结 215 10.8 习题 215 第11章 异常处理（精彩...
突破程序员基本功的16课.part2
06-11
第3课　常见Java集合的实现细节 3.1　Set和Map 3.1.1　Set和Map的关系 3.1.2　HashMap和HashSet 3.1.3　TreeMap和TreeSet 3.2　Map和List 3.2.1　Map的values（）方法 3.2.2　Map和List的关系 3.3　ArrayList和...
java多态之父子构造器
skyuck的专栏
09-29 152
下面这种情况大家知道编译器会报错 [code="java"] package com.unis.object; public class Parent { private String name; public Parent(String name) { this.name = name; } } class Child extends Paren...
《thinking in java》笔记9-父子类构造函数
与望
02-21 286
子类和父类都有构造函数，在构造子类的对象是，会隐式依次调用父类的同名同参构造函数。 public class ExtendTest { public static void main(String[] args) { Son son = new Son(); } } class Papa extends GrandPa{ public Papa(){...
面试一：JAVA继承需要注意的问题
人生智慧的博客
04-14 272
1 多继承问题 1.1 一个类不能同时继承多个类 原因：当前类不知道使用的是哪个父类的方法和属性。 1.2一个类可以继承多个接口 原因：依赖注入，接口中的方法是抽象的没有实现的，而具体是使用哪个父类的方法是有当前类决定的。 2 构造器问题 子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地...
JAVA父子类构造器问题
weixin_45003809的博客
01-29 397
父类的构造器只能调用，无法继承。 1，当父类有无参构造器时，子类实例化时总会默认先调用父类的无参构造器。 2，当父类没有任何构造器时，会默认自动生成一个无参构造器，子类实例化时总会先调用。 3，当父类只有有参构造器时，有两种方式实例化子类 ① 用super（…）直接调用父类的有参构造器 ② 用this（…）间接调用父类的有参构造器，如下图 ...
java多态中父类继承子类中的构造子
fyphome
11-15 291
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式
(转) 父子类之间构造方法执行与调用的问题
wuzqpassport的专栏
07-30 189
//假定一个子类Sub，继承自父类Super，那么在实例化Sub，也就是new Sub()时，构造方法是怎么执行的呢，下面的代码解释了这些，很重要 class Super{ static{System.out.println("静态代码块执行...");} {System.out.println("非静态代码块执行...");} public S...
【JVAVA】继承之子类构造器
最新发布
yinchenxihh的博客
11-25 378
如果父类只有有参数构造器，则子类构造器默认调用无参数构造器时，会报错。构造器：在子类有参数构造器中写下super(参数1，参数2,...参数n)。（继承自父类的数据）2.子类在初始化前，一定要调用父类构造器，先完成父类数据空间的初始化。原因：1.子类在初始化时有可能用到父类的数据。注意：子类构造器第一行。默认有super()，不写也存在。构造器默认先访问父类的。② 子类构造器继承父类。
Java继承 子类实例化：子类构造器和父类构造器
m0_51288996的博客
09-04 792
【代码】Java继承 子类实例化：子类构造器和父类构造器。
稳稳当当学java之抽象类和接口(11)
weixin_42405054的博客
06-09 720
第十三章 抽象类和接口 1.作业回顾 1，编写一个Person类，包括属性（name、age），有参构造器、方法say(返回自我介绍的字符串）。 2.编写一个Student类，继承Person类，增加sno、score属性，以及有参构造器，在子类中调用父类的构造器。 3.编写一个方法showInfo(返回自我介绍的字符串）。 ////1.编写一个Person类，包括属性（name、age），有参构造器、方法say(返回自我介绍的字符串）。 public class Person { //属性（name、
Java继承构造调用详解：子类生成与父类构造方法
在继承中，父子类调用是一个重要的概念，它涉及到子类构造方法的行为和父类构造方法的隐含调用。 1. **构造方法的初始化顺序**: - 子类的构造方法在实例化时，总是会首先执行父类的构造方法，即使程序员没有显式地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值