JavaSE（四）——继承

已于 2024-08-10 18:42:34 修改
阅读量690 收藏 13
点赞数 27
分类专栏： JavaSE 文章标签： java 开发语言
于 2024-05-20 18:07:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaokuer_/article/details/139071710
版权

文章目录

继承

继承是面向对象语言的一大特性，Java作为面向对象语言的代表，使用类实例化的对象对生活中的事物进行描述，而现实生活中的事物往往是错综复杂的，不同的对象之间可能会有紧密的联系，很多的相同点。我们用在类描述这些具有相同属性对象时，往往会定义重复的成员便变量或成员方法，造成代码冗余。

例如，我们定义猫类和狗类：

package demo1;

public class Cat {

    public String name;
    public int age;
    public String color;

    public void run() {
        System.out.println(this.name + " 正在跑");
    }

    public void mew() {
        System.out.println(this.name + "正在喵喵叫");
    }
}

package demo1;

public class Dog {

    public String name;
    public int age;
    public String color;

    public void run() {
        System.out.println(this.name + " 正在跑");
    }

    public void bark() {
        System.out.println(this.name + " 正在汪汪叫");
    }
}

名字、年龄、颜色成员变量重复了，run成员方法重复了，针对这种情况，我们需要继承。

面对对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用

继承的概念

继承机制：是面对对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行拓展，增加新功能，这样新产生的类，称为派生类。

继承主要解决的问题是：共性的抽取，实现代码复用。

紧接上面的猫狗例子，我们通俗地介绍一下继承的使用场景：

名字、颜色等描述猫和狗的属性，可以用来描述任何动物，那么我们创建一个动物类，将猫和狗的共性进行抽取，此时猫和狗的特有功能就是上面所讲的拓展，这两个类称为动物类的派生类。

在这里插入图片描述

图中给出了父类、子类的概念：

父类：被继承的类

子类：父类的拓展，继承的类

我们什么时候用到继承关系呢？

出现A is B的情况，我们可以考虑用继承。以上例，猫和狗都是动物，猫和狗类就可以继承动物类。

继承的语法

想在Java代码中体现继承关系，需要用到extends关键字：

修饰符 class 子类 extends 父类 {
    //...
}

我们将猫狗例子更改成继承体系：

//Animal.java
package demo1;

public class Animal {
    public String name;
    public int age;
    public String color;

    public void run() {
        System.out.println(this.name + " 正在跑");
    }
}

//Dog.java
package demo1;

public class Dog extends Animal {

    public void bark() {
        System.out.println(this.name + " 正在汪汪叫");
    }
}

//Cat.java
package demo1;

public class Cat extends Animal {

    public void mew() {
        System.out.println(this.name + "正在喵喵叫");
    }
}

如上，我们建立了继承体系。

【注意】

  • 父类中的成员变量和成员方法会继承到子类当中
  • 子类继承父类后，要添加自己特有的成员，体现出与父类的不同，否则就没必要继承了

继承体系下访问成员变量

子类继承了父类的成员，那么子类能直接访问父类的成员变量吗？

在上面的继承体系下，有代码：

package demo1;

public class Dog extends Animal {
    
    public void test() {
        name = " ";
        this.name = "";
        age++;
        this.age++;
    }

    public void bark() {
        System.out.println(this.name + " 正在汪汪叫");
    }
}

子类中能直接访问父类继承下来的成员变量（访问限定修饰符合理）

【子类和父类不存在同名变量】

这种情况下，根据访问的变量，访问父类或子类的成员变量。

【子类和父类变量同名】

这种情况下，访问同名变量，访问的是父类的还是子类的？

我们验证，打印结果是 1 还是 10：

public class Animal {
    public String name;
    public int age;//Animal中的age默认初始化为0
    public String color;

    public void run() {
        System.out.println(this.name + " 正在跑");
    }
}

public class Dog extends Animal {
    
    //Dog中的age就地初始化为10
    int age = 10;

    public void bark() {
        System.out.println(this.name + " 正在汪汪叫");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.age);
    }
}

在这里插入图片描述

打印 10 ，证明优先访问的是子类自己的成员变量。

在子类方法中或者通过子类对象访问成员时：（就近原则）

  • 如果子类存在要访问的成员变量，则优先访问自己的
  • 如果子类中不存在要访问的成员变量，则访问父类继承下来的，如果父类中也没有定义，则会编译报错
  • 如果子类和父类中都存在要访问的成员变量（同名），则优先访问自己的

自己有优先自己，自己没有从父类找

继承体系下访问成员方法

与访问成员变量类似：

  • 通过子类对象访问父类与子类中不同名方法时，优先在子类中寻找，找到就访问，否则在父类中寻找，找到就访问，否则，编译出错。
  • 通过子类对象访问父类与子类同名方法时，如果父类和子类的同名方法构成重载，根据调用方法时传递的参数选择合适的方法访问，如果没有则报错。如果不构成重载，语法上子类必须重写同名方法，此时优先调用的是子类重写过的同名方法。（关于重写，会在多态的一篇中详解）

我们验证一下同名方法构成重载的情况：

//Animal.java
public class Animal {
    public String name;
    public int age;
    public String color;

    public void run() {
        System.out.println(this.name + " 正在跑");
    }
}


//Dog.java
public class Dog extends Animal {
    
    public void run(int a) {
        System.out.println("子类的run");
    }

    public void bark() {
        System.out.println(this.name + " 正在汪汪叫");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run(1);
    }
}

在这里插入图片描述

我们调用run传入的参数与子类中的参数列表对应，所以调用子类的成员方法。

super关键字

学习时，可以与this进行对比理解，后面会讲，我们先接着看：

super关键字，相当于子类对象从父类继承下来的部分成员的引用，其主要作用：在子类方法中访问父类成员

super的用法：

  • super访问父类的成员变量
  • super访问父类的成员方法
  • super()访问父类的构造方法

【super访问父类的成员变量】

//Animal.java
public class Animal {

    public String name;
    public int age;
    public String color;

    public void run() {
        System.out.println(this.name + "正在跑");
    }

    public void test() {
        System.out.println("这是父类的成员方法");
    }
}


//Dog.java
public class Dog extends Animal {

    public int age;

    public void bark() {
        System.out.println(this.name + "正在汪汪叫");
    }

    public void func() {
        age = 5;//等价于this.age
        this.age = 20;//覆盖掉之前的赋值
        super.age = 10;//super调用父类的age进行赋值，否则默认访问子类的age
    }

    public void printInfo() {
        System.out.println("子类成员变量age的值是：" + this.age);
        System.out.println("父类成员变量age的值是：" + super.age);
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.func();
        dog.printInfo();
    }
}

在这里插入图片描述

【super访问父类的成员方法】

一般来说，父类和子类成员方法有以下情况：

  1. 方法名不同。通过方法名访问指定的方法即可，先找子类再找父类
  2. 方法名相同，构成重载。通过调用时传入的参数即可访问指定参数列表的方法
  3. 方法名相同，子类方法对父类方法重写。这时候需要super关键字调用父类的同名方法（重写在多态时会介绍，我们先给出代码，观察现象即可）
//Animal.java
public class Animal {

    public String name;
    public int age;
    public String color;

    public void run() {
        System.out.println(this.name + "正在跑");
    }

    public void test() {
        System.out.println("这是父类的成员方法");
    }
}

//Cat.java
public class Cat extends Animal{

    public void mew() {
        System.out.println(this.name + "正在喵喵叫");
    }

    //重写test方法
    public void test() {
        System.out.println("重写父类的test方法");
    }

    public void use() {
        //默认调用
        System.out.println("这是Java默认调用的test方法：");
        test();
        System.out.println("利用super调用父类的被重写方法：");
        super.test();
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.use();
    }
}

在这里插入图片描述

【super()访问父类的构造方法】

这一用法的应用场景在下一模块子类构造方法中介绍：

class A {
    public int a;
    
    public A(int a) {
        this.a = a;
    }
}

class B extends A {
    public int b;

    //super调用父类的构造方法对父类成员变量初始化
    public B(int a) {
        super(a);
    }
}

【注意】

  • super只能在非静态方法中使用（构造代码块也可以），不过，super可以通过.调用静态方法

【this与super】

相同点：

  • 都是Java的关键字，用法类似，都有三种
  • 都不能在静态方法中使用，但是可以访问静态方法
  • 必须是构造方法的第一条语句（意味着this()与super()不能共存）

不同点：

  • this代表当前对象的引用，super相当于子类对象中从父类继承部分的成员的引用。它们指代的内容可以用一张图简单表示：

    在这里插入图片描述

  • 构造方法中一定存在super()语句，用户没有写编译器默认添加，但是this()不写则没有

  • 构造方法中，this()调用当前类的构造方法，super()调用父类的构造方法

  • 在非静态成员方法中，this用来访问本类的成员，super用来访问父类的成员

子类构造方法

Java中，子类对象构造时，需要先调用基类构造方法对基类的成员进行初始化，然后执行子类的构造方法

有父才有子，所以在构造子类对象的时候，要先调用父类的构造方法，将从基类继承下来的成员构造完整，再调用子类自己的构造方法，将子类自己新增的成员初始化完整。这里就要用到super的第三种用法：super()访问父类的构造方法

我们验证 子类先调用父类构造方法的强制性：

public class Demo {
    public int a;
    public String s;

    //父类的构造方法
    public Demo(int a, String s) {
        this.a = a;
        this.s = s;
    }
}


class Child extends Demo {
    public int b;
    //没有调用父类的构造方法初始化父类的成员变量
}

在这里插入图片描述

public class Demo {
    public int a;
    public String s;

    //父类的构造方法
    public Demo(int a, String s) {
        this.a = a;
        this.s = s;
    }
}

class Child extends Demo {
    public int b;

    //子类构造方法中先使用super()调用父类的构造方法对父类的成员变量进行初始化
    public Child(int a, String s) {
        super(a, s);
    }

    public static void main(String[] args) {
        Child child = new Child(10, "hello");
    }
}

完成上面的修改后，程序不再报错。

【注意】

  • 如果父类中显性提供了无参的构造方法或者没有显性提供任何构造方法（Java默认提供无参构造方法），子类的构造方法中默认有super();语句。
  • 如果父类中显性提供了有参的构造方法，那么子类必须手动补充super()语句，调用父类的构造方法对父类的成员变量进行初始化。
  • super()语句必须是构造方法的第一条语句，所以super()与this()不共存。

继承体系下的代码块

此模块主要讨论继承体系下的静态代码块、构造代码块、构造方法的执行顺序。

我们直接看一段代码：

//Animal.java
public class Animal {
    public String name;
    public int age;

    static {
        System.out.println("父类Animal的静态代码块执行了......");
    }

    {
        System.out.println("父类Animal的构造代码块执行了......");
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类Animal的构造方法被执行了......");
    }
}


//Dog.java
public class Dog extends Animal {

    static {
        System.out.println("子类Dog的静态代码块被执行了......");
    }

    {
        System.out.println("子类Dog的构造代码块被执行了......");
    }

    public Dog(String name, int age) {
        super(name, age);
        System.out.println("子类Dog的构造方法被执行了......");
    }

}


//Cat.java
public class Cat extends Animal {

    static {
        System.out.println("子类Cat的静态代码块被执行了......");
    }

    {
        System.out.println("子类Cat的构造代码块被执行了......");
    }

    public Cat(String name, int age) {
        super(name, age);
        System.out.println("子类Cat的构造方法被执行了......");
    }

}


//Test.java
//这是测试类
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("mimi", 2);
    }
}

当我们执行上面的代码，打印结果是多少？
在这里插入图片描述

根据打印结果，我们可以得到：

继承体系下的执行顺序：
父类的静态代码块 > 子类的静态代码块 > 父类的构造代码块 > 父类的构造方法 > 子类的构造代码块 > 子类的构造方法

了解了上面的知识后，我们修改一下Test测试类，判断修改后的打印结果：

public class Test {
    public static void main(String[] args) {
        Cat cat1 = new Cat("mimi", 2);
        System.out.println("=========");//分割线
        Cat cat2 = new Cat("lala", 3);
    }
}

在这里插入图片描述

  • 在类和对象篇中已经介绍了，静态代码块在类被加载时执行且只执行一次，所以静态代码块只执行一次

  • 每次实例化对象时，构造代码块和构造方法都会执行一次

protected关键字

protected关键字属于类和对象篇的遗留问题了，学习了继承后，我们对子类有了认识，现在我们详细介绍一下：

被protected修饰的成员，同包底下任何一个类都是可以访问的，不同的包下只有子类才能访问

在这里插入图片描述

注意： 被protected关键字修饰的成员可以在不同包的子类中访问。

对于注意事项，我们验证：

package Demo1;//Demo1中

public class Base {
    protected int a;//protected修饰

}

package Demo2;//Demo2中


//验证不同包下的子类的可访问性
import Demo1.Base;

public class Test1 extends Base {

    public int b;

    public void printInfo() {
        System.out.println(a);
    }

    public static void main(String[] args) {
        Test1 test1 = new Test1();
        test1.printInfo();
    }
}

在这里插入图片描述

package Demo2;//Demo2中


//验证不同包的非子类的不可访问性
public class Test2 {
    public int c;

    public void printInfo() {
        System.out.println(a);
    }

    public static void main(String[] args) {
        Test2 test2 = new Test2();
        test2.printInfo();
    }
}

在这里插入图片描述

【补充】

被private修饰的父类成员不能在子类中直接访问，但实际上它们被继承下来了。

class A {
    private int a;
    public int b;
}

class B extends A {
    public void test() {
        super.a = 10;//编译报错，被private修饰的父类成员不能在子类中直接访问
        super.b = 10;
    }
}

在这里插入图片描述

继承方式

继承方式有很多种，但Java中只支持以下几种继承方式：

JAVA继承类型【笔记】-云社区-华为云

  • Java不支持多继承，即一个子类只能有一个父类

    在这里插入图片描述

  • 我们的代码尽量不要出现超过三层的继承关系，如果出现过多层的继承，就要考虑对代码重构了

  • Java中如果想实现多继承，需要用到接口的知识，后面会讲

final关键字

final关键字可以用来修饰变量、成员方法或类。

  1. 修饰变量或字段，表示常量（即不能修改）

        public static void main(String[] args) {
        final int a = 10;
        a = 20;
    }

    在这里插入图片描述

  2. 修饰类：表示此类不能被继承

    被final修饰的类叫做密封类

    final class A {

}
class B extends A {

}

    在这里插入图片描述

  3. 修饰方法：表示该方法不能被重写

    被final修饰的方法叫做密封方法

    class A {
    public final void test() {
        System.out.println("被final修饰，不能重写");
    }
}

class B extends A {
    public void test() {
        System.out.println("失败");
    }
}

    在这里插入图片描述

继承与组合

组合也是一种表示类之间关系的方式，能够实现代码复用。

实现组合，只需要将一个类的实例作为另一个类的成员变量。

前面提到：继承是A is B的关系，而组合是A has B的关系，如，学校有老师、学生。

我们结合一段代码了解：

//Student.java
public class Student {
    public String name;
    public int age;
    //......
}

//School.java
public class School {
    //组合
    public Student[] students = new Student[100];
}

在实际应用中，组合的使用多余继承，我们在写代码时还是能用组合不用继承。

上面就是继承的所有内容了。
预告：多态

四角小裤儿儿
关注
专栏目录
javase继承.md
12-31
### JavaSE中的继承 #### 一、继承的基本概念与作用 **继承**(Inheritance)作为面向对象编程的一个核心特征，在Java编程语言中占有极其重要的地位。面向对象编程的三大特性——封装、继承与多态中，继承使得代码的...
JavaSE.xmind
07-10
案例 + 知识点：其中包括了方法，数组，继承多态封装，基本数据类型与引用数据类型；super关键字，方法的重载，构造方法的重载，排序（冒泡排序、选择排序、JDK排序案例）并对各个知识点进行了相应的案例进行分析。
大三上学期JavaSE期中考试
10-21
在大三上学期的JavaSE期中考试中，学生可能会面临一个实际的项目——汽车租赁系统。这个系统是基于Java编程语言实现的，主要目的是为了模拟真实的商业场景，让学生掌握JavaSE的基础知识并能将其应用到实际问题解决中...
javaSE代码实例
06-21
第8章　继承——多态的支柱　122 8.1　继承概述　122 8.1.1　类之间的关系　122 8.1.2　面向对象中的继承性　124 8.2　类的继承　125 8.3　成员变量的继承与隐藏　126 8.3.1　成员变量的继承规则　126 8.3.2　成员...
JavaSE知识点阶段考试题
05-25
### JavaSE知识点详解 #### 一、选择题解析 **1. Java应用程序主类中的main方法格式** - **选项分析**： - A: `public void main(String args[])` —— 缺少`static`关键字。 - B: `static void main(String ...
Java-网络
2301_81543552的博客
09-14 693
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 602
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 277
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1135
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 186
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 917
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 941
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 356
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1243
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 1154
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1090
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 772
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
JAVA开源项目 在线视频教育平台 计算机毕业设计
as230627的博客
09-14 1060
基于Vue.js和SpringBoot的在线视频教育平台是一个功能丰富的系统，它包括管理后台和用户网页端，为管理员、普通用户和教师角色提供了不同的功能。在管理后台，管理员可以进行用户管理，包括用户信息的增删改查。
JAVA——方法重载
bengbeng2345的博客
09-12 215
返回值不能作为重载条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值