Loading [MathJax]/jax/input/TeX/config.js
首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >java中的继承详解

java中的继承详解

作者头像
全栈程序员站长
发布于 2022-09-08 06:40:31
发布于 2022-09-08 06:40:31
64200
代码可运行
举报
运行总次数:0
代码可运行

大家好,又见面了,我是你们的朋友全栈君。

继承的描述

在现实生活中,继承一般指的是子女继承父辈的财产。在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系。例如猫和狗都属于动物,程序中便可以描述为猫和狗继承自动物,同理,波斯猫和巴厘猫继承自猫,而沙皮狗和斑点狗继承自狗。这些动物之间会形成一个继承体系,具体如下图所示。

1500704359335

在Java中,类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类,子类会自动拥有父类所有可继承的属性和方法。在程序中,如果想声明一个类继承另一个类,需要使用extends关键字。

通过 extends 关键字让类与类之间产生继承关系。

多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。多个类可以称为子类,单独这个类称为父类或者超类。

注意事项:

  • 子类可以直接访问父类中的非私有的属性和行为。
  • 子类无法继承父类中私有的内容。
  • 父类怎么来的?共性不断向上抽取而来的。

示例:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Person{
    String name;
    int age ;
}
class Student extends Person{
    void study(){
        System.out.println("student study..." + age);
    }
}
class Worker extends Person{
    void work(){
        System.out.println("worker work..." + age);
    }
}
class ExtendDemo{
    public static void main(String[] args){
        Student s = new Student();
        s. name = "zhangsan" ;
        s. age = 20;
        s.study();
        Worker w = new Worker();
        w. name = "lisi" ;
        w. age = 30;
        w.work();
    }
}

运行结果:

1491308047866

好处:

  • 继承的出现提高了代码的复用性。
  • 继承的出现让类与类之间产生了关系,提供了多态的前提。

继承的特点

在类的继承中,需要注意一些问题,具体如下:

1.在Java中,类只支持单继承,不允许多重继承,也就是说一个类只能有一个直接父类,例如下面这种情况是不合法的。

1500704447701

2.多个类可以继承一个父类,例如下面这种情况是允许的。

1500704467099

3.在Java中,多层继承是可以的,即一个类的父类可以再去继承另外的父类,例如C类继承自B类,而B类又可以去继承A类,这时,C类也可称作A类的子类。例如下面这种情况是允许的。

1500704487847

4.在Java中,子类和父类是一种相对概念,也就是说一个类是某个类父类的同时,也可以是另一个类的子类。例如上面的示例中,B类是A类的子类,同时又是C类的父类。

Java只支持单继承,不支持多继承。一个类只能有一个父类,不可以有多个父类。 原因:因为多继承容易出现问题。两个父类中有相同的方法,子类到底要执行哪一个是不确定的。

示例:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class A{
    void show(){
        System.out.println("a" );
    }
}
class B{
    void show(){
        System.out.println("b" );
    }
}
class C extends B,A{
}

那么创建类C的对象,调用show方法就不知道调用类A中的show方法还是类B中的show方法。所以java不支持多继承,但将这种机制换了另一个安全的方式来体现,也就是多实现(后面会详细说明)。

Java支持多层继承(继承体系):

C继承B,B继承A,就会出现继承体系。多层继承出现的继承体系中,通常看父类中的功能,了解该体系的基本功能,建立子类对象,即可使用该体系功能。

定义继承需要注意:不要仅为了获取其他类中某个功能而去继承,类与类之间要有所属( “is a”)关系。

super关键字&函数覆盖

在继承关系中,子类会自动继承父类中定义的方法,但有时在子类中需要对继承的方法进行一些修改,即对父类的方法进行重写。需要注意的是,在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。

当子类重写父类的方法后,子类对象将无法访问父类被重写的方法,为了解决这个问题,在Java中专门提供了一个super关键字用于访问父类的成员。例如访问父类的成员变量、成员方法和构造方法。

在子父类中,成员的特点体现:

成员变量

  • this和super的用法很相似
  • this代表本类对象的引用
  • super代表父类的内存空间的标识
  • 当本类的成员和局部变量同名用this区分
  • 当子父类中的成员变量同名用super区分父类

示例:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Fu{
   private int num = 4;

   public int getNum(){
       return num ;
   }
}

class Zi extends Fu{
   private int num = 5;

   void show(){
       System.out.println(this.num + "..." + super.getNum());
   }
}

class ExtendDemo{
   public static void main(String[] args){
       Zi z = new Zi();
       z.show();
   }
}

运行结果

1491308096802

成员函数

当子父类中出现成员函数一模一样的情况,会运行子类的函数。这种现象,称为覆盖操作,这是函数在子父类中的特性。

在子类覆盖方法中,继续使用被覆盖的方法可以通过super.函数名获取。

函数两个特性:

  1. 重载,同一个类中。
  2. 覆盖,子类中,覆盖也称为重写,覆写,override。

示例:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Fu{
   public void show(){
       System.out.println("fu show run" );
   }
}

class Zi extends Fu{
   public void show(){
       System.out.println("zi show run" );
   }
}

class ExtendDemo{
   public static void main(String[] args){
       Zi z = new Zi();
       z.show();
   }
}

运行结果:

1491308113418

什么时候使用覆盖操作?

当子类需要父类的功能,而功能主体子类有自己特有内容时,可以复写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。

示例:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Phone{
   void call(){}
   void show(){
       System.out.println("number" );
   }
}

class NewPhone extends Phone{
   void show(){
       System.out.println("name" );
       System.out.println("pic" );
       super.show();
   }
}

class ExtendDemo{
   public static void main(String[] args){
       NewPhone p = new NewPhone();
       p.show();
   }
}

运行结果:

1491308129771

注意事项:

  • 父类中的私有方法不可以被覆盖
  • 父类为static的方法无法覆盖
  • 覆盖时,子类方法权限一定要大于等于父类方法权限

示例:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Fu{
    public void show(){
        System.out.println("fu show run" );
    }
}

class Zi extends Fu{
    private void show(){
        System.out.println("zi show run" );
    }
}

class ExtendDemo{
    public static void main(String[] args){
        Zi z = new Zi();
        z.show();
    }
}

运行结果:

1491308142717

构造函数

子父类中构造函数的特点:在子类构造函数执行时,发现父类构造函数也运行了。 原因:在子类的构造函数中,第一行有一个默认的隐式语句:super();。 注意:如果使用super(4);语句调用父类的其他构造函数,那么默认的父类构造函数将不会再被调用。

示例:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Fu{
    int num ;
    Fu(){
        num = 10;
        System.out.println("A fu run" );
    }
    Fu(int x){
        System.out.println("B fu run..." + x);
    }
}

class Zi extends Fu{
    Zi(){
        //super();//默认调用的就是父类中的空参数的构造函数
        System.out.println("C zi run " + num);
    }
    Zi(int x){
        super(4);
        System.out.println("D zi run " + x);
    }
}

class ExtendDemo{
    public static void main(String[] args){
        new Zi();
        System.out.println("-------------------" );
        new Zi(6);
    }
}

运行结果:

1491308168245

子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数。因为每一个构造函数的第一行都有一条默认的语句super();。

为什么子类实例化的时候要访问父类中的构造函数呢?

那是因为子类继承了父类,获取到了父类中内容(属性),所以在使用父类内容之前,要先看父类是如何对自己的内容进行初始化的。

注意事项:

  • 当父类中没有空参数的构造函数时,子类的构造函数必须通过this或者super语句指定要访问的构造函数。
  • 子类构造函数中如果使用this调用了本类构造函数,那么默认的super();就没有了,因为super和this都只能定义在第一行,所以只能有一个。但是可以保证的是,子类中肯定会有其他的构造函数访问父类的构造函数。
  • super语句必须要定义在子类构造函数的第一行!因为父类的初始化动作要先完成。

示例:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Fu{
    Fu(){
        super();
        //调用的是子类的show方法,此时其成员变量num还未进行显示初始化
        show();
        return;
    }
    void show(){
        System.out.println("fu show" );
    }
}
class Zi extends Fu{
    int num = 8;
    Zi(){
        super();
        //通过super初始化父类内容时,子类的成员变量并未显示初始化,等super()父类初始化完毕后,才进行子类的成员变量显示初始化
        return;
    }
    void show(){
        System.out.println("zi show..." + num);
    }
}
class ExtendDemo{
    public static void main(String[] args){
        Zi z = new Zi();
        z.show();
    }
}

运行结果:

1491308191041

总结:一个对象实例化过程,以Person p = new Person();为例

  1. JVM会读取指定的路径下的Person.class文件,并加载进内存,并会先加载Person的父类(如果有直接的父类的情况下)
  2. 在内存中开辟空间,并分配地址
  3. 并在对象空间中,对对象的属性进行默认初始化
  4. 调用对应的构造函数进行初始化
  5. 在构造函数中,第一行会先到调用父类中构造函数进行初始化
  6. 父类初始化完毕后,再对子类的属性进行显示初始化
  7. 再进行子类构造函数的特定初始化
  8. 初始化完毕后,将地址值赋值给引用变量

final关键字

final关键字可用于修饰类、变量和方法,它有“无法改变”或者“最终”的含义,因此被final修饰的类、变量和方法将具有以下特性:

  • final可以修饰类,方法,变量
  • final修饰的类不可以被继承
  • final修饰的方法不可以被覆盖
  • final修饰的变量是一个常量,只能被赋值一次
  • 为什么要用final修饰变量,其实,在程序中如果一个数据是固定的。那么直接使用这个数据就可以了,但是这种阅读性差,所以应该给数据起个名称。而且这个变量名称的值不能变化,所以加上final固定
  • 写法规范:常量所有字母都大写,多个单词,中间用_连接

示例1:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
 //继承弊端:打破了封装性
 class Fu{
        void method(){
        }
 }

 class Zi extends Fu{
        public static final double PI = 3.14;
        void method(){
             System.out.println(PI);
        }
 }

 class FinalDemo{
        public static void main(String[] args){
             Zi zi = new Zi();
             zi.method();
        }
 }

运行结果:

1491308214198

示例2:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class FinalDemo{
    public static void main(String[] args){
        final int x = 4;
        x = 5;
    }
}

运行结果:

1491308228930

内存结构

静态绑定,当方法被 static private final三个关键字其中一个修饰,执行的静态绑定

动态绑定,方法执行的动态绑定

属性看变量的类型,Person.this.salary

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
public class TestChunApp
{

    public static void main(String[] args) {
        Person p = new Manager();
          p.sing();
        //System.out.println(p);    //Person.this.salary
    }
}

class Person{
    private int salary = 10000;

    public static void sing(){
        System.out.println("忘情水");
    }
    int getSalary(){
        return salary;
    }
    public void printSalary(){
        System.out.println(salary);
    }
}

class Manager extends Person{
    int salary = 30000;

    public static void sing(){
        System.out.println("中国人");
    }
    public void printSalary(){
        System.out.println(getSalary());
    }
}

– EOF –

推荐阅读 点击标题可跳转

java精品入门-0基础第一篇

JDK、JRE、JVM的区别与联系

变量与数据类型 java基础03

运算符-小学生都能学会的java基础

java循环经典案例-学会它入行java

java基础之方法重载

java数组精讲-多案例-够详细

java中基本类型包装类

引用、指针和句柄的区别 面向对象-搞定她-搞定程序

面向对象(二)-搞定她-搞定程序

面向对象第一步封装

都来到这了,我需要你的点赞支持

发布者:全栈程序员栈长,转载请注明出处:https://javaforall.cn/156614.html原文链接:https://javaforall.cn

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
编辑精选文章
换一批
JDK1.9-继承
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
cwl_java
2019/12/03
3980
Java三大特性(二)—继承
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那一个类即可。如图所示:
共饮一杯无
2022/11/28
2880
Java三大特性(二)—继承
Java学习之继承与抽象篇
概述:多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要 继承那一个类即可。其中,多个类可以称为子类,单独那一个类称为父类、超类(superclass)或者基类。 继承描述的是事物之间的所属关系。
全栈程序员站长
2021/12/13
5530
第二十八节:Java基础-进阶继承,抽象类,接口
在子类和父类中都有构造函数,运行时,先执行父类中的构造函数,在执行子类的构造函数,因为子类的所有构造函数中第一行都有一句,隐式的super();,表示为调用父类的无参的构造函数。
达达前端
2019/07/03
3780
第二十八节:Java基础-进阶继承,抽象类,接口
【愚公系列】2021年12月 Java教学课程 31-继承详解
​ 子类会继承父类中的数据,可能还会使用父类的数据。所以,子类初始化之前,一定要先完成父类数据的初始化,原因在于,每一个子类构造方法的第一条语句默认都是:super()
愚公搬代码
2022/01/04
2080
【愚公系列】2021年12月 Java教学课程 31-继承详解
java 继承 test
那么,我们什么时候考虑使用继承呢? 继承中类之间体现的是:”is a”的关系。 如果两个类满足这个关系:xxx is a yyy,那么他们就可以使用继承。
Cell
2022/02/25
6610
Java--继承
注解@Override:写在方法前面,用来检测是不是有效的正确重写。(也可以不写。建议书写,起到检测作用)
花猪
2022/02/16
2550
09(01)总结final,多态,抽象类,接口
1:final关键字(掌握) (1)是最终的意思,可以修饰类,方法,变量。 (2)特点: A:它修饰的类,不能被继承。 B:它修饰的方法,不能被重写。 C:它修饰的变量,是一个常量。 /* final可以修饰类,方法,变量 特点: final可以修饰类,该类不能被继承。 final可以修饰方法,该方法不能被重写。(覆盖,复写) final可以修饰变量,该变量不能被重新赋值。因为这个变量其实常量。 常量: A:字面值常量 "hello",10,true B:自定义常量 final
Java帮帮
2018/03/15
7010
面向对象练习题【从零开始学Java】
Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机,Java 仍是企业和开发人员的首选开发平台。
用户4919348
2024/05/25
1200
JAVA17/JAVA21继承和抽象类
​ 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,这个类就是父类,那么多个子类无需再定义这些属性和行为,只要继承那一个类即可。如图所示:
张哥编程
2024/12/13
2120
JAVA17/JAVA21继承和抽象类
Java继承中的几道面试题
第一题: 1 /* 2 看程序写结果: 3 A:访问成员变量的原则:就近原则。 4 B:this和super的问题: 5 this 访问本类的成员 6 super 访问父类的成员(可以理解为的) 7 C:子类的所有构造方法执行前默认先执行父类的无参构造方法。 8 D:一个类的初始化过程: 9 成员变量进行初始化过程如下: 10
黑泽君
2018/10/11
6740
【day11】面向对象编程进阶(继承)
本文深入探讨面向对象编程的核心概念,包括继承、方法重写、this和super关键字的使用,以及抽象类和方法的定义与实现。通过本文的学习,你将能够:
程序员波特
2024/12/23
1910
【day11】面向对象编程进阶(继承)
Java基础笔记08
08.01_面向对象(代码块的概述和分类) A:代码块概述 在Java中,使用{}括起来的代码被称为代码块。 B:代码块分类 根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块(多线程讲解)。 C:常见代码块的应用 a:局部代码块 在方法中出现;限定变量生命周期,及早释放,提高内存利用率 b:构造代码块 在类中方法外出现;多个构造方法方法中相同的代码存放到一起,每次调用构造都执行,并且在构造方法前执行 c:静态代码块 在类中方法外出现,加了static修饰 在类中方法
dreamkong
2018/06/21
5040
JAVA入门零基础小白教程day07_继承&抽象
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,这个类就是父类,那么多个子类无需再定义这些属性和行为,只要继承那一个类即可。如图所示:
张哥编程
2024/12/13
650
JAVA入门零基础小白教程day07_继承&抽象
Java学习笔记之继承与修饰符
继承是面向对象三大特征之一,可以使得子类具有父类的属性和方法,还可以在子类中重新定义,以及追加属性和方法。
Jetpropelledsnake21
2021/11/30
4600
Java学习笔记之继承与修饰符
Java 继承详解
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
用户7886150
2020/12/08
8630
Java面向对象三大特性
利用抽象数据类型将数据和基于数据的操作封装在一起,使其构成一个不可分割的独立实体。 数据被保护在抽象数据类型的内部,尽可能地隐藏内部的细节, 只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节, 但可以通过对象对外提供的接口来访问该对象。
李红
2019/06/06
4490
Java面向对象三大特性
java中的继承 (extends) 详解
Teacher类继承了Employee类,也就继承了它的 public void method() 方法,达到了代码复用的效果,当父类有我们子类需要用的方法时,我们就不用再去重新打一次,直接可以拿来用。
全栈程序员站长
2022/09/09
7350
java中带继承类的加载顺序详解及实战
  在面试中,在java基础方面,类的加载顺序经常被问及,很多时候我们是搞不清楚到底类的加载顺序是怎么样的,那么今天我们就来看看带有继承的类的加载顺序到底是怎么一回事?在此记下也方便以后复习巩固!
阿豪聊干货
2018/08/09
5200
java中带继承类的加载顺序详解及实战
JAVA零基础小白学习教程之day08_接口&多态
由于多态特性的支持,showAnimalEat方法的Animal类型,是Cat和Dog的父类类型,父类类型接收子类对象,当然可以把Cat对象和Dog对象,传递给方法。当eat方法执行时,多态规定,执行的是子类重写的方法,那么效果自然与showCatEat、showDogEat方法一致,
张哥编程
2024/12/13
1030
相关推荐
JDK1.9-继承
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档
本文部分代码块支持一键运行,欢迎体验
本文部分代码块支持一键运行,欢迎体验