Java中继承的详解（上）

已于 2023-04-17 23:09:55 修改
阅读量151 收藏 9
点赞数 15
分类专栏： Java之岛 文章标签： c++ 程序人生 c# c语言 java
于 2023-04-17 23:03:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73906153/article/details/130211076
版权

继承

1.1 引言

为什么需要继承？Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是 现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。

例如：猫和狗。我们先创建猫和狗的类，上代码

Dog.java

public class Dog{
    String name;
    int age;
    float weight;
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public void sleep(){
        System.out.println(name + "正在睡觉");
    }
    void Bark()
    {
        System.out.println(name + "汪汪汪~~~");
    }
}

Cat.java

public class Cat {
    String name;
    int age;
    float weight;
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public void sleep()
    {
        System.out.println(name + "正在睡觉");
    }
    void mew(){
        System.out.println(name + "喵喵喵~~~");
    }
}

我们可以发现这两个类中含有大量的重复，例如：name，age，weight。这是两个类共有的属性，我们每次创建类似的对象时，都要定义这些字段（成员变量），会显得麻烦，对此，我们可以将这些类含有的共性提取出来，归并到一个单独的类中。让这些类要使用到这些类时，可以直接继承该类。继承要通过extends关键字来实现，我们来看看具体的写法：这里是将这些类定义在同一个Java文件中。

Animal类

class Animal{`
    String name;
    int age;
    float weight;
}

Dog类

//语法格式：class 子类 extends 父类
class Dog extends Animal{
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public void sleep(){
        System.out.println(name + "正在睡觉");
    }
    void Bark()
    {
        System.out.println(name + "汪汪汪~~~");
    }
}

对于Dog类的第一行代码，Dog类继承了Animal类，我们就称Animal类是父类/基类/超类，Dog类称为子类/派生类。经过继承之后，子类可以反复使用父类中的成员，子类在实现时只需关心自己新增加的成员即可。经过继承之后，子类就会将父类的成员变量和成员方法都继承到子类中了。子类继承了父类之后，必须要有自己的特有的成员，否则就没有必要了，因为继承就是为了实现对共性的抽取。

我们还可以写一个Cat类来继承Animal：

class Cat extends Animal {
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public void sleep()
    {
        System.out.println(name + "正在睡觉");
    }
    void mew(){
        System.out.println(name + "喵喵喵~~~");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wQ7hJcJn-1681743551470)(C:\Users\30539\AppData\Roaming\Typora\typora-user-images\image-20230414213746235.png)]

class Animal{
    String name;
    int age;
    float weight;
}
class Cat extends Animal {
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public void sleep()
    {
        System.out.println(name + "正在睡觉");
    }
    void mew(){
        System.out.println(name + "喵喵喵~~~");
    }
}

 class Dog extends Animal{
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public void sleep(){
        System.out.println(name + "正在睡觉");
    }
    void Bark()
    {
        System.out.println(name + "汪汪汪~~~");
    }
}

public class Test {
    public static void main(String[] args) {
    Cat cat = new Cat();
    cat.name ="喵喵";
    cat.age = 19;
    cat.weight =14.5f;
    }
}

此处通过cat可以访问name和age，但是Cat类中并没定义name ，age ，weight。所以这三个属性一定是是从父类中继承下来的。当然若父类中含有方法，父类中的方法也可以被继承下来。

1.2 父类成员的访问

1.2.1 子类和父类不存在同名的变量

此时在子类中访问的是自己的成员变量。

public class Base {
    int a;
    int b;
}

public class Derived extends Base{
	int c;
    public void method(){
    a = 10; // 访问从父类中继承下来的a
    b = 20; // 访问从父类中继承下来的b
    c = 30; // 访问子类自己的c
    }
}

1.2.2 子类和父类存在同名的变量

看个例子：

public class Base {
    int a;
    int b;
    int c;
}

public class Derived extends Base{
    
    int a; // 与父类中成员a同名，且类型相同
    char b; // 与父类中成员b同名，但类型不同
    
    public void method(){
    a = 100; // 访问父类继承的a，还是子类自己新增的a？
    b = 101; // 访问父类继承的b，还是子类自己新增的b?
    c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
    // d = 103; // 编译失败，因为父类和子类都没有定义成员变量b
    }
  }

此时在子类方法中 或者 通过子类对象访问成员时:

  • 如果访问的成员变量子类中有，优先访问自己的成员变量。
  • 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
  • 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

1.2.3 子类访问父类中不同名的方法

public class Base {
    public void methodA(){
    System.out.println("Base中的methodA()");
    }
}

public class Derived extends Base{
    public void methodB(){
    System.out.println("Derived中的methodB()方法");
    }

public void methodC(){
    methodB(); // 访问子类自己的methodB()
    methodA(); // 访问父类继承的methodA()
    // methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
    }
}

总结：当成员方法没有同名时，在子类方法中或者子类对象访问方法时，则优先访问自己的，若子类自己没有再到父类中去找，若父类也没有，就会报错。

1.2.4 子类访问父类中同名的方法

看个例子：

public class Base {
    public void methodA(){
    System.out.println("Base中的methodA()");
    }

public void methodB(){
    System.out.println("Base中的methodB()");
    }
  }

public class Derived extends Base{
    public void methodA(int a) {
    System.out.println("Derived中的method(int)方法");
  }

public void methodB(){
	System.out.println("Derived中的methodB()方法");
}

public void methodC(){
    methodA(); // 没有传参，访问父类中的methodA()
    methodA(20); // 传递int参数，访问子类中的methodA(int)
    methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
   }
}

注意：

  • 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到 则访问，否则编译报错。
  • 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用 方法适传递的参数选择合适的方法访问，如果没有则报错；

提问：假设子类存在与父类相同的成员时，那如何在子类中访问父类中同名的成员呢？这时就需要用到super关键字了。

1.3 super关键字

当子类与父类含有相同名称的成员，我们想要在子类方法中访问父类的同名成员时，就需要用到super关键字。

示例：

public class Base {
    int a;
    int b;
    public void methodA(){
    System.out.println("Base中的methodA()");
}

public void methodB(){
    System.out.println("Base中的methodB()");
   }
}

public class Derived extends Base{
    int a; // 与父类中成员变量同名且类型相同
    char b; // 与父类中成员变量同名但类型不同
    
// 与父类中methodA()构成重载
public void methodA(int a) {
    System.out.println("Derived中的method()方法");
 }
  
// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
public void methodB(){
    System.out.println("Derived中的methodB()方法");
   }
    
public void methodC(){
    // 对于同名的成员变量，直接访问时，访问的都是子类的
    a = 100; // 等价于： this.a = 100;
    b = 101; // 等价于： this.b = 101;
    // 注意：this是当前对象的引用
    // 访问父类的成员变量时，需要借助super关键字
    // super是获取到子类对象中从基类继承下来的部分
    super.a = 200;
    super.b = 201;
    
    // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
    methodA(); // 没有传参，访问父类中的methodA()
    methodA(20); // 传递int参数，访问子类中的methodA(int)
    
    // 如果在子类中要访问重写的基类方法，则需要借助super关键字
    methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
    super.methodB(); // 访问基类的methodB()
  }
}

总结：在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。

注意事项：

  • super关键字只能在非静态方法中使用。
  • 在子类方法中，访问父类的成员变量和方法。

1.4 子类构造方法

当子类含有构造方法时，必须要先调用基类/父类的构造方法，再执行子类的构造方法。

例子：

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

public class Derived extends Base{
public Derived(){
    // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
    // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
    // 并且只能出现一次
    System.out.println("Derived()");
   }
}


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

结果打印：

Base()
Derived()

在此例子的子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子 ，肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整 ，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。

注意事项：

  • 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法。
  • 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
  • . 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
  • super(…)只能在子类构造方法中出现一次，并且不能和this同时出现。

1.5 super和this的区别

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数。并且都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

相同点：

  1. 都是Java中的关键字
  2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段.
  3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在.

不同点：

  1. this是当前对象的引用，当前对象即调用实例方法的对象,当在子类的非静态方法中使用this访问某个成员时，则会优先访问子类的成员，若子类没有，就会在父类中访问，若父类也没有则报错。
  2. super相当于是子类对象中从父类继承下来部分成员的引用。
  3. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性。
  4. 功能不同：在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造 方法中出现
  5. . 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有。

1.6 和代码块的联系

【没有继承关系时】：

我们谈谈之前的 实例代码块 和 静态代码块 在没有继承关系时的执行顺序：

class Person {
    public String name;
    public int age;
public Person(String name, int age) {
    this.name = name;
    this.age = age;
    System.out.println("构造方法执行");
}

{
	System.out.println("实例代码块执行");
}

static {
    System.out.println("静态代码块执行");
   }
}

public class TestDemo {
    public static void main(String[] args) {
    Person person1 = new Person("张山",19);
    System.out.println("============================");
    Person person2 = new Person("李四",20);
    }
}

执行结果：

静态代码块执行
实例代码块执行
构造方法执行
============================
实例代码块执行
构造方法执行

注意：

  • 静态代码块最先执行，并且只执行一次，在类加载阶段执行。
  • 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行。

【有继承关系时】：

当其在继承关系下时，我们再来看看其执行顺序：

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
    this.name = name;
    this.age = age;
	System.out.println("Person：构造方法执行");
}
    
{
    System.out.println("Person：实例代码块执行");
}
    
static {
    System.out.println("Person：静态代码块执行");
  	    }
}

class Student extends Person{
public Student(String name,int age) {
super(name,age);
    System.out.println("Student：构造方法执行");
}
    
{
    System.out.println("Student：实例代码块执行");
}
static {
    System.out.println("Student：静态代码块执行");
	   }
}

public class TestDemo4 {
    
public static void main(String[] args) {
    Student student1 = new Student("张山",19);
    System.out.println("===========================");
    Student student2 = new Student("李四",20);
}
    
public static void main1(String[] args) {
    Person person1 = new Person("张山",19);
    System.out.println("============================");
    Person person2 = new Person("李四",20);
}

运行结果：

Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行

通过分析，我们有以下结论：

  1. 父类静态代码块优先于子类静态代码块执行，且是最早执行。
  2. 父类实例代码块和父类构造方法紧接着执行。
  3. 子类的实例代码块和子类构造方法紧接着再执行。
  4. 第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行。

1.7 总结

本章的内容就到这里啦，若有不足，欢迎评论区指正，最后，希望大佬们多多三连吧，下期见！

这里是彪彪
关注
  • 15
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
Java继承详解
01-20
什么是继承？ 　多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。... 　1.Java只支持单继承，不支持多继承。 　//一个类只能有
java教程之java继承示例详解
09-04
主要介绍了java继承示例详解,需要的朋友可以参考下
Java继承
l_ll888的博客
07-03 151
继承概念 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 类的继承格式 class 父类 { } lass 子类 extends 父类 { } 为什么继承（复用代码） 企鹅:属性(姓名,id),方法(吃，睡，自我介绍) 企鹅:属性(姓名...
面向对象三大特征之继承
weixin_39660224的博客
09-10 226
上次我总结到了封装，今天来总结下继承 继承顾名思义就是儿子继承老爸的东西，在java中我们为了减少代码的重复性、复杂度，减少系统冗余等等（其实也就是偷个懒，省时省力） 换而言之什么时候用呢，就是存在多个类中存在相同属性和行为时，将这些内容抽取到单独A类中，那么多个类无需再定义这些属性和行为，只要继承A类即可。 A类即为父类，其他继承A类的类就是子类，子类可以继承父类中非私有的属性和方法 这之
Java集合继承体系详解
08-28
主要为大家详细介绍了Java集合继承体系，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java继承详解
06-20
nal关键字 1、 被final修饰的成员变量，一旦赋值就不能被修改。那么这种变量我们称之为常量： 常量的定义格式： public static final 数据类型 变量名 定义常量的时候，常量的名字要大写，如果存在两个单词组合起来...
详解java封装继承多态
08-26
主要介绍了java封装继承多态，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java delayqueue_详解java中DelayQueue的使用
最新发布
06-06
Java中的DelayQueue是一个基于优先级队列实现的延迟队列。它可以用于定时任务调度、缓存过期等场景。 DelayQueue中的元素必须实现Delayed接口，该接口继承自Comparable接口，因此元素需要实现compareTo方法，以便在队列中维护元素的优先级。 DelayQueue中的元素按照延迟时间的大小进行排序，即延迟时间短的元素排在队列的前面。当从队列中取出元素时，只有延迟时间到了的元素才会被取出。 以下是一个使用DelayQueue的简单示例： ```java import java.util.concurrent.DelayQueue; import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; public class DelayQueueDemo { public static void main(String[] args) throws InterruptedException { DelayQueue<DelayedElement> queue = new DelayQueue<>(); queue.add(new DelayedElement("task1", 3000)); // 延迟3秒执行 queue.add(new DelayedElement("task2", 2000)); // 延迟2秒执行 queue.add(new DelayedElement("task3", 1000)); // 延迟1秒执行 while (!queue.isEmpty()) { DelayedElement element = queue.take(); // 取出元素 System.out.println(System.currentTimeMillis() + ": " + element); } } } class DelayedElement implements Delayed { private String name; private long expireTime; public DelayedElement(String name, long delay) { this.name = name; this.expireTime = System.currentTimeMillis() + delay; } @Override public long getDelay(TimeUnit unit) { return unit.convert(expireTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS); } @Override public int compareTo(Delayed o) { return Long.compare(this.getDelay(TimeUnit.MILLISECONDS), o.getDelay(TimeUnit.MILLISECONDS)); } @Override public String toString() { return "DelayedElement{" + "name='" + name + '\'' + ", expireTime=" + expireTime + '}'; } } ``` 在上面的示例中，我们创建了一个DelayQueue对象，并向其中添加了三个DelayedElement元素，分别表示3秒、2秒和1秒后执行的任务。然后在一个循环中不断取出元素，直到队列为空。由于每个元素的延迟时间不同，因此取出的顺序也是不同的。 以上就是Java中DelayQueue的简单使用方法。需要注意的是，DelayQueue是线程安全的，可以在多线程环境下使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

这里是彪彪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值