【Java SE】继承

已于 2024-04-13 20:11:37 修改
阅读量2.2k 收藏 22
点赞数 33
分类专栏： JavaSE 文章标签： java 开发语言
于 2024-04-04 17:38:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61814277/article/details/137182210
版权
本文详细介绍了Java中的继承机制，包括其概念、语法，以及如何在子类中访问父类成员，通过实例展示了super和this关键字的区别，以及final关键字在修饰变量、类和方法时的作用。文章强调了继承在代码复用和面向对象设计中的重要性。
摘要由CSDN通过智能技术生成

🥰🥰🥰来都来了，不妨点个关注叭！
👉博客主页：欢迎各位大佬!👈

在这里插入图片描述

文章目录

1. 继承

面向对象三大特性：封装、继承、多态
今天我们一起来看看继承这一特性~~~

1.1 继承是什么

Java中使用类对现实世界中实体来进行描述，类实例化后的对象来表示现实中的实体，but现实世界错综复杂，事物之间可能会存在一些关联，对于这些有关联的事物，我们需要合理地设计程序。
比如：狗和猫，它们都是动物，我们可以用Java来描述狗和猫的属性和方法，如下：

public class Dog {
    int legNumber;
    String name;
    String gender;
    int age;
    float weight;

    void eat() {
        System.out.println(name+"在吃饭");
    }

    void sleep() {
        System.out.println(name+"在睡觉");
    }

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

public class Cat {
    int legNumber;
    String name;
    String gender;
    int age;
    float weight;

    void eat() {
        System.out.println(name+"在吃饭");
    }

    void sleep() {
        System.out.println(name+"在睡觉");
    }

    void meow() {
        System.out.println(name+"喵喵叫");
    }
}

从上述代码中，我们直观清晰看到，狗和猫类中存在大量重复，它们的属性都有腿的数量、名字、性别、年龄、体重和吃饭这个行为，它们的叫声不同。显然，这个代码存在大量重复，是不合理的。
解决办法：面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用
【继承】
继承是面向对象最显著的一个特性，继承是从已有的类(父类)中派生出新的类(子类)，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
在上述狗和猫的场景中，我们将狗和猫的共性抽取，它们都是动物，很多属性都有共性，我们将这些共性抽取出来，而狗和猫又各自有属于自己的属性，利用继承的思想达到代码共用的思想，动物类则是父类，狗和猫是子类，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员
在这里插入图片描述

1.2 继承的意义

继承有什么意义呢？
【继承的意义】在于对共性抽取，实现代码复用，是多态性的基础，子类能够更灵活地适应不同的需求，提高代码的通用性和可扩展性，并层次化分类，使程序结构更易于管理。

1.3 继承的语法

在Java中，表示类之间的继承关系，需借助extends关键字，具体语法如下：

class 父类名称 {
// 父类的属性和方法
}
修饰符 class 子类名称 extends 父类名称 {
// 子类特有的属性和方法
// 子类可以覆盖父类的方法
}

通过上述的分析，使用继承的思想重新设计，各部分代码如下：

public class Animal {
    int legNumber;
    String name;
    String gender;
    int age;
    float weight;

    void eat() {
        System.out.println(name+"在吃饭");
    }

    void sleep() {
        System.out.println(name+"在睡觉");
    }
}

public class Dog extends Animal{
    void bark() {
        System.out.println(name+"汪汪叫");
    }
}

public class Cat extends Animal {
    void meow() {
        System.out.println(name+"喵喵叫");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        dog.name = "球球";
        cat.name = "毛毛";
        dog.bark();
        cat.meow();
    }
}

【注意事项】
1）一个.java文件写一个类，如下写法：
在这里插入图片描述
2）Dog类和Cat并没有定义成员变量，name是从父类Animal继承过来的，eat()和sleep()方法也是继承来的，即子类会将父类中的成员变量或者成员方法继承到子类中
3） 子类继承父类后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承，完全可以直接用父类呀~所以，必须要新添加自己特有的成员

1.4 继承的方式

在现实世界中，事物之间的关系是十分复杂的~那Java支持哪些继承方式呢！
在这里插入图片描述
Java支持单继承、多层继承、不同类继承同一类
不支持多继承(一个子类继承多个父类，不支持)！！！
在这里插入图片描述
Java中不支持多继承
尽管在写代码时候，我们可能会碰到类之间有非常复杂的关系，但是仍然不希望类之间的继承关系超过三层， 继承层次太多, 需要考虑对代码进行重构
如果想从语法上进行限制继承，使用 final 关键字修饰类，表示该类不可以被继承

1.5 子类中访问父类成员

1.5.1 子类中访问父类成员变量

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

public class Parent {
    String a;
    String b;
}

public class Child extends Parent{
    String c;
    public void method() {
        a = "我是父类的a";
        b = "我是父类的b";
        c = "我是子类特有的c";
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
        child.method();
    }
}

运行结果如图：
在这里插入图片描述
解释：子类中没有a和b变量，a、b访问从父类Parent类继承下来的a、b，子类中有变量c，c是访问子类自己的c
【子类和父类存在同名成员变量】

public class Parent {
    String a;
    String b;
    String c;
}

public class Child extends Parent{
   String a;
   char b;

    public void method() {
        a = "我是子类Child类中的a";
        b = 'b';
        c = "我是父类Parent类中的c";
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
        child.method();
    }
}

运行结果如图：
在这里插入图片描述
解释：子类中有变量a则访问的是自己的a，而变量b在父类与子类中均有，类型不同，可以看到，优先访问的是子类中的变量b，子类中没有变量c则访问从父类继承下来的c
【总结】
通过子类对象或者在子类方法中访问成员时，以下3种情况：
(1) 访问的成员变量子类中有，优先访问自己的成员变量
(2) 访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错
(3) 访问的成员变量与父类中成员变量同名，则优先访问自己的
即成员变量访问遵循就近原则，自己有则优先访问自己的，否则在父类中寻找

1.5.2 子类中访问父类成员方法

【子类和父类不存在同名成员方法】

public class Parent {
    public void methodA() {
        System.out.print("父类Parent类中的methodA()方法！");
    }
}

public class Child extends Parent{
    public void methodB() {
        System.out.print("子类Child类中的methodB()方法！");
    }

    public void methodC() {
        methodA();
        methodB();
    }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
        child.methodC();
    }
}

运行结果如图：
在这里插入图片描述
解释：子类中没有methodA()方法，子类访问父类Parent类继承下来的methodA()方法，methodB()方法是访问子类自己的methodB()方法
【子类和父类存在同名成员方法】

public class Child extends Parent{
    public void methodA(int a) {
        System.out.println("Child子类中的methodA(int)方法");
    }

    public void methodB() {
        System.out.println("子类Child类中的methodB()方法！");
    }

    public void methodC() {
        methodA();
        methodA(12);
        methodB();
    }
}


public class Parent {
    public void methodA() {
        System.out.println("父类Parent类中的methodA()方法！");
    }
    public void methodB() {
        System.out.println("父类Parent类中的methodB()方法！");
    }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
        child.methodC();
    }
}

运行结果如图：
在这里插入图片描述
解释：子类中的methodA()和父类中的methodA()构成重载，根据调用方法，调用哪个就是哪个，methodA()未传参，调用父类的，methodA(12)传参了，调用子类Child的methodA(12)方法。methodB同名，调用子类自己的methodB()方法
【总结】
(1) 子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问父类的，否则编译报错
(2) 子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果参数列表一致，优先在子类中找访问自己的
即成员方法访问遵循就近原则，自己有则优先访问自己的，否则在父类中寻找，如果方法重载，根据调用方法选择一致的

1.6 super关键字

我们知道，如果子类自己有变量c，那么优先访问子类的c，如果我想访问父类的c，该如何做捏！
在这里插入图片描述
此时super关键字，闪亮登场！！！
Java提供super关键字，该关键字主要作用就是在子类方法中访问父类的成员！

public class Parent {
    String a  = "我是父类Parent类中的a";
    String b  = "我是父类Parent类中的b";
    String c;
    public void methodA() {
        System.out.println("我是父类Parent类中的methodA()");
    }
}


public class Child extends Parent{
   String a = "我是子类Child类中的a";
   char b;

   public void methodA() {
       System.out.println("我是子类Child类中的methodA()");
   }
    public void method() {
        System.out.println(a);//a相当于this.a
        System.out.println(super.a);
        methodA();//methodA()相当于this.methodA()
        super.methodA();
    }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
        child.method();
    }
}

运行结果如下：
在这里插入图片描述

优先访问子类中的成员，无法访问到父类中的成员，通过关键字super可以访问到父类的成员变量和方法
【注意事项】
(1) 只能在非静态方法中使用
(2) 在子类方法中，访问父类的成员变量和方法。

1.7 子类构造方法

父子，即先有父再有子，在子类构造方法内，必须先帮助父类构造
在子类构造方法中，虽然并没有写任何关于父类的构造的代码，通过代码运行结果得知，在构造子类对象时，先执行父类的构造方法，后执行子类的构造方法

public class Parent {
    public Parent() {
        System.out.println("父类Parent构造方法");
    }
}


public class Child extends Parent{
   public Child() {
//super(); 被隐藏了 
//子类构造方法中默认会调用父类的无参构造方法super()
//没有写时,编译器会自动添加,且super()必须是子类构造方法中第一条语句，
//且只能出现一次
       System.out.println("子类Child构造方法");
   }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
    }
}

运行结果如下：
在这里插入图片描述
【原因】子类对象中成员由两部分组成，父类继承下来的＋子类新增加的部分，先有父再有子，所以在构造子类对象时候 ，先要调用父类的构造方法，将从父类继承下来的成员构造完整，再调用子类自己的构造方法，将子类自己新增加的成员初始化完整
在这里插入图片描述

【注意事项】
(1) 父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用父类构造方法

public Parent() {
}

public Child() {
    super(); 
}

(2) 父类构造方法是带有参数的，此时需要为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败，即子类必须先帮助父类构造

public class Parent {
    String name;
    int age;
    public Parent(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Child extends Parent{
     int index;
     public Child(String name, int age,int index) {
       super(name,age); //必须先帮助父类构造且super为第一条语句,交换顺序则会报错,且super只出现一次！
       this.index = index;
   }
}

(3) 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句，且只能出现一次并且不能和this同时出现！！！即this和super调用构造器不能同时出现

public class Child extends Parent{
    int index;
   public Child(String name, int age,int index) {
       super(name,age);
       this("1",2,4);//将会报错！！不能同时出现
   }
}

2. super与this关键字

【相同点】
(1) 均为Java中的关键字
(2) 均只能在类的非静态方法中使用，用来访问非静态成员方法和变量
(3) 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
【不同点】
(1) this是当前对象的引用，当前对象即调用实例方法的对象，super是子类对象中从父类继承下来部分成
员的引用
(2) 在非静态成员方法中，this访问本类的方法和属性，super访问父类继承下来的方法和属性
(3) 在构造方法中：this(…)调用本类构造方法，super(…)调用父类构造方法，两种调用不能同时在构造方法中出现
(4) 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

3. final 关键字

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

3.1 修饰变量或字段

表示该变量不能被修改(即常量)

final int a = 100;
a = 20;
//编译出错,变量a被final修饰,不能被修改

3.2 修饰类

表示该类不能被继承

final public class Animal {
	...
}

public class Cat extends Animal{
	...
}
//编译出错,Animal类被final关键字修饰,表示不能被继承

3.3 修饰方法

表示该方法不能被重写

本期内容到这里结束啦~以下为本期内容回顾！
在这里插入图片描述下期再见啦~

明天不吃。
关注
  • 33
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java SE文档（全）
02-09
Java SE（标准版）是Java编程语言的核心组成部分，它提供了编写桌面应用程序所需的全部工具和类库。本文档全面覆盖了Java程序设计的各种方面，旨在帮助开发者深入理解和掌握Java语言。 1. **人机交互**：在Java编程...
Java SE重点总结
09-06
Java SE，全称为Java Standard Edition，是Java平台的核心部分，主要面向桌面应用和服务器端开发。这个学习总结涵盖了从基础到高级的Java编程知识点，旨在帮助初学者建立坚实的编程基础，同时也适合有经验的开发者...
Java SE继承和组合
m0_54470078的博客
01-31 1350
继承和组合 JavaSe
【Java SE】继承与组合
m0_61814277的博客
04-04 2274
本期主要介绍各代码块执行顺序，protected关键字用法，访问修饰限定符的选择，继承和组合
【Java SE】继承和多态(保姆级教学)
热门推荐
书生-w的博客
11-24 2万+
子类继承了父类的属性和方法，并且可以扩展 ,多态是建立在继承的基础上的，多个不同的子类拥有各自不同的形态，也就是多态,了解继承和多态这也是学好java的前提
JAVA SE
举目沧桑的博客
01-11 3031
JAVA SE（Java Platform Standard Edition ,Java标准版） JRE（运行环境）：提供Java虚拟机和运行Java应用程序所必需的类库 JDK(Java SE开发工具集)：包括JRE和命令行开发工具（编译，运行，调试Java程序所需要的基本工具） JRE与JDK的区别： 如果只需要在某种操作系统下运行Java应用程序，则安装支持该操作系统的JRE软件即可； 如果不仅要运行Java应用程序，还要开发Java应用程序，就需要安装支持该操作系统的JDK软件； .
【Java SE】继承的详解
程序猿教你打篮球的博客
09-08 9984
本期主要讲解： 1、继承 1.1 继承的概念 1.2 继承的语法和简单使用 1.3 子类中访问父类成员出现同名 2、 super关键字 2.1 如何使用 super 关键字 2.2 子类构造方法 2.3 super 和 this 的区别 3、再谈代码块 3.1 回顾 3.2 继承关系中的执行顺序 4、 protected 关键字 4.1 protected关键字的作用 4.2 子类如何访问父类 private 修饰的成员？ 4.3 为什么 private 和 protected 不能修饰...
Java SE
weixin_43038557的博客
03-18 1637
字节码是java程序经过编译产生的.class文件，字节码能够被虚拟机识别，从而实现java程序的跨平台。java程序从源代码到运行主要有三步：1.编译：将代码从.java编译成.class2.解释：虚拟机执行.class，将其翻译成机器能识别的机器码3.执行，对应的机器执行二进制机器码6.为什么说java语言编译与解释共存？高级编程语言执行方式分为编译型和解释型。java语言既具有编译型语言的特征也有解释型语言的特征，因为java程序要先经过编译，后经过解释两个步骤。
Java SE(Java Platform, Standard Edition)
m0_64021225的博客
06-09 781
Java SE 学习笔记 基础知识点总结
java se kit 6_Java SE Development Kit (JDK) 6 Update 18
weixin_29876887的博客
02-26 504
这是Java SE Development Kit (JDK) 6 Update 18，Java开发工具包 (Java Development Kit ) 的缩写，用于构建在 Java 平台上发布的应用程序、applet 和组件的开发环境，一切java应用程序的基础，所有的java应用程序饰淦鞴建在这个之上的，它是一组API，也可以说是一些java Class。相关介绍Java是一门面向对象编程语...
Java SE_day6_继承性
黑夜中的向日葵
10-13 267
JavaSE 继承性
java SE 例子
07-27
此外，面向对象编程的概念——类、对象、继承、封装和多态性也是Java SE的基础内容。通过例子，我们可以更直观地看到这些概念如何在实际代码中应用。 在Java中，类库提供了丰富的功能，比如集合框架（ArrayList、...
Java学习资料 java se
06-29
"Java SE"代表了Java Standard Edition，它是Java平台的核心，主要用于桌面应用程序和服务器端开发。 Java SE包括Java虚拟机（JVM）、类库和开发者工具。JVM是Java程序的运行环境，它负责解释执行字节码并提供内存...
java se学习教程
04-06
Java SE（标准版）是Java开发平台的核心，用于构建桌面应用程序和服务器端应用。这个"Java SE学习教程"涵盖了Java编程的基础以及面向对象的概念，旨在帮助开发者深入理解Java语言。 一、Java语言基础 Java是一种强...
golang 接口
m0_70982551的博客
07-24 825
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 370
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 441
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 515
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值