Java继承

已于 2022-06-08 01:04:13 修改
阅读量2.1k 收藏 8
点赞数 6
CC 4.0 BY-SA版权
文章标签： java java-ee 开发语言
于 2022-06-07 23:35:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61130325/article/details/125175471

Java继承

目录

1.继承的定义

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

相关代码:

class test1{
    public static void main(String[] args){
        test3 new1 = new test3();//调用子类
        new1.name="小胖";
        new1.age=20;
        new1.show();
    }
}

class test2{
    //父类
    String name;
    int age;
    public void show(){
		System.out.println(name);
    	System.out.println(age);
    }
}
class test3 extends test2{
    //子类继承了父类
}

最后输出:
小胖
20

2.继承的好处

继承过来的字段和方法，可以像任何其他字段和方法一样被直接使用；
在子类中可以声明一个与父类中同名的新字段或静态方法，从而“隐藏”父类中的字段或方法；
可以在子类中声明一个在父类中没有的新字段和方法；
可以在子类中编写一个父类当中具有相同名的新实例方法，这称为**“方法重写”或“方法覆盖”；
可以在子类中编写一个调用父类构造方法的子类构造方法**，既可以隐式地实现，也可以通过使用关键字super来实现。

但是要注意:

Java只支持单继承不支持多继承

即:Java中可以有多个子类继承1个父类但是1个子类不能继承多个父类。

3.this与super

3.1super的作用

super:代表对当前对象父类的引用

3.11super调用成员变量

代码

public class test1{
     //父类
    String name = "小胖";
    int age = 20;
}
public class test2 extends test1{
    //子类
    int age = 19;
    public void show(){
        System.out.println(name);
        System.out.println(age);
    }
}
public class test3{
    public static void main(String[] args){
        test2 in1 = new test2();
        in1.show();
    }
}

最后输出

小胖
19

而这个

public class test1{
     //父类
    String name = "小胖";
    int age = 20;
}
public class test2 extends test1{
    //子类
    int age = 19;
    public void show(){
        System.out.println(super.name);
        System.out.println(super.age);
    }
}
public class test3{
    public static void main(String[] args){
        test2 in1 = new test2();
        in1.show();
    }
}

最后输出

小胖
20

用super会调用父类的成员变量

注意:

在构造方法的过程中

如果没有写this或super,则会在构造方法的最上端自动加上一个super();

这个是super调用成员变量的结果

那么super调用构造方法呢

3.12super调用构造方法

看代码

public class test1{//父类
    private String name;
    private int age;
	public test1(){
        System.out.println("父类的无参构造");
    } 
    public test1(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("父类的有参构造");
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

public class test2 extends test1{//子类
   public test2(){
       	super("渊酱",19);//调用父类中的构造方法
        System.out.println("子类的无参构造");
    } 
    public test2(String name,int age){
       	super(name,age);
      	
        System.out.println("子类的有参构造");
    }
    
}

public class test3{
    public static void main(String[] args){
        test2 in1 = new test2();//无参构造
        in1.setName("渊酱");
        in1.setAge(19);
        System.out.println(in1.getName()+in1.getAge());
        System.out.println("------------------");
        test2 in2 = new test2("小胖",20);//有参构造
        System.out.println(in2.getName()+in2.getAge());
    }
}

最后输出

父类的有参构造
子类的无参构造
渊酱19
------------------
父类的有参构造
子类的有参构造
小胖20

这个比较简单,无需解释

如果无参构造过程中没有加super(“渊酱”,19)

最后输出

父类的无参构造
子类的无参构造
渊酱19
------------------
父类的有参构造
子类的有参构造
小胖20

3.13super调用成员方法

代码

public void test1{
    public void show(){
        System.out.println("父类");
    }
}
public void test2 extends test1{
    public void show(){
        super.show();
        System.out.println("子类");
    }
}
public void test3{
    public static void main(String[] args){
        test2 in1 =new test2();
        super.in1.show();
    }
}

最后输出

父类
子类

而如果去掉super.show()

则输出

子类

3.2this的作用

this:代表当前对象的引用,谁来调用我,我就代表谁

3.21this调用成员变量

public class test1{
    //父类
    String name = "小胖";
    int age = 20;
}

public class test2 extends test1{
    //子类
    int age = 19;//就近原则,子类有了就不用父类了
    public void show(){
        System.out.println(this.name);
        System.out.println(this.age);
    }
}

public class test3{
    public static void main(String[] args){
        test2 in1 = new test2();
        in1.show();
    }
}

最后输出:

小胖
19

而这个

public class test1{
    //父类
    String name = "小胖";
    int age = 20;
}

public class test2 extends test1{
    //子类
    int age = 19;
    public void show(){
        System.out.println(super.name);
        System.out.println(super.age);
    }
}

public class test3{
    public static void main(String[] args){
        test2 in1 = new test2();
        in1.show();
    }
}

最后输出

小胖
20

注意:最后输出年龄的时候输出的是子类中的年龄，而非父类中的年龄。

当子类有了相应的成员变量就不需调用父类的成员变量。

而当子类没有相对应的成员变量,便用父类已有的成员变量。

这个是this调用成员变量的结果

那么this调用构造方法呢

3.22this调用构造方法

看代码

public class test1{//父类
    private String name;
    private int age;
	public test1(){
        System.out.println("父类的无参构造");
    } 
    public test1(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("父类的有参构造");
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

public class test2 extends test1{//子类
   public test2(){
       	this("渊酱",19);//调用本类中的构造方法
        System.out.println("子类的无参构造");
    } 
    public test2(String name,int age){
       	super(name,age);
      	
        System.out.println("子类的有参构造");
    }
    
}

public class test3{
    public static void main(String[] args){
        test2 in1 = new test2();//无参构造
        in1.setName("渊酱");
        in1.setAge(19);
        System.out.println(in1.getName()+in1.getAge());
        System.out.println("------------------");
        test2 in2 = new test2("小胖",20);//有参构造
        System.out.println(in2.getName()+in2.getAge());
    }
}

最后输出

父类的有参构造
子类的有参构造
子类的无参构造
渊酱19
------------------
父类的有参构造
子类的有参构造
小胖20

无参构造时,在子类的无参构造方法时,因为有this(“渊酱”,19);调用本类的构造方法,就相当于走了子类有参构造

的构造方法

之后将name=“渊酱”,age=19传入父类的有参构造

于是输出:父类的有参构造

然后继续进行子类的有参构造输出:子类的有参构造

这步走完后接着进行之前子类无参构造的步骤

输出:子类的无参构造

经历in1.setName(“渊酱”);
in1.setAge(19);

于是输出:渊酱19

再输出**------------------**

下一步是有参构造了

很容易写出后面:

父类的有参构造

子类的有参构造

小胖20

如果无参构造过程中没有加this

则最后输出

父类的无参构造
子类的无参构造
渊酱19
------------------
父类的有参构造
子类的有参构造
小胖20

3.23this调用成员方法

在一个类的内部，成员方法之间的互相调用时也可以使用“this.方法名(参数)”来进行引用，只是所有这样的引用中this都可以省略，所以这里就不详细介绍了。

3.3this与super的区别

1.this与super分别代表什么

[1]this代表对当前对象的引用,谁来调用我,我就代表谁

[2]super代表对对象父类的引用

2.this与super的使用区别

[1]调用成员变量

this.成员变量 既可以调用本类的成员变量也可以调用父类的

super.成员变量 只可以调用父类的

[2]调用构造方法

this(…)使用本类的构造方法

super(…)使用父类的构造方法

[3]调用成员变量

this.成员变量 调用本类的成员变量,也可以调用父类的成员变量

super.成员变量 调用父类的成员变量

4.继承中的经典题目(用到了继承和代码块的知识)

运行结果并解释:

public   static   void  main( String [] args) {
        Zi z =  new  Zi();
    }
}
class  Fu {
     static  {
        System.out.println( "静态代码块Fu" );
    }

    {
        System.out.println( "构造代码块Fu" );
    }

     public  Fu() {
        System.out.println( "构造方法Fu" );
    }
}

class  Zi  extends  Fu {
     static  {
        System.out.println( "静态代码块Zi" );
    }

    {
        System.out.println( "构造代码块Zi" );
    }

     public  Zi() {
        System.out.println( "构造方法Zi" );
    }

静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi

1,jvm调用了main方法,main进栈
2,遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存,再创建对象,当Fu.class加载进内存
父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载
第一个输出,静态代码块Fu,第二个输出静态代码块Zi
3,走Zi类的构造方法,因为java中是分层初始化的,先初始化父类,再初始化子类,所以先走的父类构造,但是在执行
父类构造时,发现父类有构造代码块,构造代码块是优先于构造方法执行的所以
第三个输出构造代码块Fu,第四个输出构造方法Fu
4,Fu类初始化结束,子类初始化,第五个输出的是构造代码块Zi,构造方法Zi

Java 继承复用避坑指南：五个血泪案例揭示高频陷阱
张彦峰的博客
05-11 3万+
本文系统剖析了继承滥用在实际系统中的五类典型陷阱，包括逻辑被绕过、构造失控、行为不一致、初始化混乱等问题，并通过真实业务案例与测试验证，逐一展示问题根源与演进优化方案。文章强调：继承是一把双刃剑，设计不慎将带来系统性隐患。 最终，我们总结出继承的适用边界，倡导以组合、接口、策略等手段替代非必要的继承，实现更健壮、可演进的业务架构。希望本文能为你在系统设计与代码演进中提供深度启发。
Java 继承
m0_74012211的博客
01-11 1110
Java 继承
类继承--
weixin_50866517的博客
03-29 1274
类继承基类&派生类二级目录三级目录 面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。 当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。 基类&派生类 一个类可以派生多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一
java 继承的写法_Java 类的继承详解
weixin_30357183的博客
02-12 1万+
/*文章中用到的代码只是一部分，需要完整代码的可通过邮箱联系我[email protected]*/在面向对象的语言中如C++和JAVA，都有一个比较重要的机制——类的继承。这里将对JAVA中的类的继承机制进行讨论。先提一个问题：为什么要使用继承(后面再解答)。1.首先是类继承的写法：继承的关键字：extends格式：public class 类名(子类、派生类、超类) extends 类名(父...
JAVA继承（详解）
最新发布
2301_79482961的博客
05-15 548
继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性 的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了 由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
图解Java继承内存分配
01-20
　（1）Java不支持多继承，也是说子类至多只能有一个父类。 　（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法。 　（3）子类中定义的成员变量和父类中定义的成员变量相同时，...
浅谈Java继承中的转型及其内存分配
08-28
浅谈Java继承中的转型及其内存分配 在Java继承中，转型和内存分配是两个非常重要的概念，本文将详细介绍这两个概念，并通过一个具体的例子来加深读者的理解。 在Java中，继承是面向对象编程的基本机制，它允许一个...
Java继承超详细
热门推荐
霖hero
03-03 5万+
前言 继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法，如何修改从父类继承过来的子类的方法呢。今天我们开始学习有关Java继承的知识。 继承 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。
继承java_继承（JAVA）
weixin_36352415的博客
02-19 615
继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。一、继承的基本语法：在Java语言中，用extends关键字表示一个类继承了另一个类。例如：public class Sub extends Base{.......}Sub类到底继承了Base类的哪些东西呢？分为以下两种情况：① 当Sub类和Base类位于同一个包中：Sub类继承...
java继承类怎么写
花生日记
04-13 2150
重写和重载是等价的。声明类是创建一个类，我们知道 Java的基本类型是 JVM （Java虚拟机），而对象的属性和方法则是由 Java虚拟机通过一些算法生成的，也就是说在 java虚拟机中只有对象，而没有 JVM。为了说明继承机制，我们先来看一个例子： 假设我们有一个名叫“student”的对象，这个对象有三个属性： student （）、student_datetime （）@_undefined （），这三个属性中，只有 student是 new出来的，而另外两个属性则是通过类继承的。
面向对象三大特征之继承
weixin_39660224的博客
09-10 286
上次我总结到了封装，今天来总结下继承 继承顾名思义就是儿子继承老爸的东西，在java中我们为了减少代码的重复性、复杂度，减少系统冗余等等（其实也就是偷个懒，省时省力） 换而言之什么时候用呢，就是存在多个类中存在相同属性和行为时，将这些内容抽取到单独A类中，那么多个类无需再定义这些属性和行为，只要继承A类即可。 A类即为父类，其他继承A类的类就是子类，子类可以继承父类中非私有的属性和方法 这之
Java继承初学者经典教程案例解析
### 经典Java继承例子知识点 Java是一种广泛使用的面向对象编程语言，其中继承是面向对象编程的三大特性之一（另外两个是封装和多态）。继承的主要目的是实现代码复用和创建更为具体和详细的类。在Java中，继承是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值