奇妙的Java“父子”继承

本文介绍了Java中的继承概念,如何通过继承实现代码复用,区分重载和重写,以及super和this关键字的作用。讲解了继承的语法、执行顺序和Java中关于final关键字的相关知识。
摘要由CSDN通过智能技术生成

继承

为什么要继承?首先Java中使用类对现实世界中实体来进行描述,类经过实例化之后的产物对象,可以用来表示现实中的实体,但是这些实体是否有共同特点呢?答案是有的。那既然是共同特点,是否就有重复的代码呢?答案是有的,答案是有的。那为了代码的简洁性来说,便出现了继承。

请看下面的代码:狗(dog)类

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)类

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,因此为了避免代码的重复,我们可以提取出一个animal类。所以我们将这些共性进行抽取,如下。

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

继承的概念

继承 (inheritance) 机制 :是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加新功能 ,这样产生新的类,称 派生类 。继承呈现了面向对象程序设计的层次结构, 体现了由简单到复杂的认知过程。继承主要解决的问题是:共性的抽取,实现代码复用
上述图示中, Dog Cat 都继承了 Animal 类,其中: Animal 类称为父类 / 基类或超类 Dog Cat 可以称为 Animal 子类/ 派生类,继承之后,子类可以复用父类中成员,子类在实现时 只需关心自己新增加的成员即可
从继承概念中可以看出继承最大的作用就是: 实现代码复用,还有就是来实现多态(后序)。

继承的语法

需要有extends关键字,如下

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

所以上述的dog类就可以写成如下形式

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

注意:

当创建一个子类对象的时候,并不会额外创建一个父类的对象,而是父类作为子类对象的一部分,子类对象内部有指向父类的引用,通过这个引用可以访问父类的成员。

子类应当由父类没有的成员变量或者成员方法,否则就不需要继承了

而这个引用就是依靠super关键字。(后续讲解)

父类成员访问

成员变量

1.父类和子类没有存在同名的成员变量

规则:子类有的访问子类,父类有的访问父类;

2.父类和子类存在同名的成员变量

规则:如果访问的成员变量与父类中成员变量同名,则优先访问自己的。

读者可以自己尝试写几个代码。

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

成员方法

1.成员方法名字不同

规则:优先访问子类的,子类没有时再到父类中找,如果父类中也没有则报错。
2. 成员方法名字相同
规则:通过子类对象访问父类与子类同名方法时,如果父类和子类同名方法的 参数列表不同 ( 重载 ) ,根据调用方法适传递的参数选择合适的方法访问,如果没有则报错;
如果参数列表都一样的情况下,就需要我们的 super关键字了;

super关键字

由于设计不好,或者因场景需要,子类和父类中可能会存在相同名称的成员,如果要在子类方法中访问父类同名成员时,Java 提供了 super 关键字,该关键字主要作用:在子类方法中访问父 类的成员
访问父类的成员方法:
public class Base{
  public void methodA(){
   System.out.println("Base中的methodA()");
 }
  public void methodB(){
   System.out.println("Base中的methodB()");
 }
}
public class Derived extends Base{
// 与父类中methodA()构成重载
  public void methodA(int a) {
   System.out.println("Derived中的method()方法");
}
// 与基类中methodB()构成重写(即原型一致,重写后序详细介绍)
  public void methodB(){
   System.out.println("Derived中的methodB()方法");
}

public void methodC(){
// 父类和子类中构成重载的方法,直接可以通过参数列表区分清访问父类还是子类方法
  methodA(); // 没有传参,访问父类中的methodA()
  methodA(20); // 传递int参数,访问子类中的methodA(int)
// 如果在子类中要访问重写的基类方法,则需要借助super关键字
  methodB(); // 直接访问,则永远访问到的都是子类中的methodA(),基类的无法访问到
  super.methodB(); // 访问基类的methodB()
}
}

重写和重载的辨析在后面部分

在methodc类中,如果我们要访问父类的methodB(),则需要用super.methodB();来访问,如果是要访问子类自己的,那么只需要写methodB();就行,等价于this.methodB();

访问父类的成员变量

例如上面的父类为Aniaml和子类Dog:

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

这边因为父类再没有创建构造方法的时候,会默认存在一个构造方法,而子类没有写super时,则会默认存在一个super();所以这种情况下编译器不会报错

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

但是如果父类写了带参数的构造方法:

public Animal(string name, int age, float weight){
  this.name =name;
  this.age = age;
  this.weight = weight;
}

则字类中需要存在带3个参数(即相同参数)的super

public class Dog extends Animal(){
  super(name,age,weight);
  void Bark(){
   System.out.println(name + "汪汪汪~~~");
}
}

注意

一、super不能用在静态方法中(即不能有static修饰);

二、子类的权限不可以比父类的权限来的大(可以记忆成:老子比儿子厉害)

如果父类为public,那么子类为public,包访问权限(default),protected,private都可以

但是如果父类为default,那么子类只能为包访问权限(default),protected,private,以此类推。

上面涉及到了重载和重写,

不得不用一个小篇幅来帮助读者区分:大致如下:

在Java中,重写(Override)和重载(Overload)是两个不同的概念,它们在多态性的实现中扮演着重要的角色。

重写(Override)

重写是指子类有一个方法,这个方法的签名(包括方法名和参数列表)与父类中的某个方法的签名完全相同。通过重写,子类能够提供一个特定的实现,这个实现将会覆盖父类中的方法。

  • 重写发生在两个类之间,父类和子类之间。
  • 方法名称和参数列表必须与父类方法完全相同
  • 返回类型必须相同或是父类返回类型的子类(称为协变返回类型),如下:
class Fruit {
    public Fruit getFruit() {
        return new Fruit();
    }
}

class Apple extends Fruit {
    @Override
    public Apple getFruit() {
        return new Apple();
    }
}

在这个例子中,Fruit 类有一个 getFruit 方法,返回一个 Fruit 对象。Apple 类继承自 Fruit,并重写了 getFruit 方法,但这里它返回了一个 Apple 对象,而 AppleFruit 的子类。这就是协变返回类型的应用。

  • 访问权限不能比父类中被重写的方法更严格。
  • 重写的方法可以抛出与原方法相同的异常或其子异常,但不能抛出更广泛的异常。(暂且不考虑异常这个知识点)
  • 使用@Override注释可以帮助确保你正确地重写了父类方法。

重载(Overload)

重载是指在同一个类中,有多个同名方法,但它们的参数列表不同(参数的数量不同、参数类型不同或参数的顺序不同)。

  • 重载发生在同一个类中,或者在子类中(子类可以重载继承自父类的方法)。
  • 方法名称相同,但参数列表必须不同。
  • 返回类型可以相同,也可以不同,并不影响重载。
  • 访问权限没有特殊要求。
  • 可以抛出不同的异常。(暂且不考虑异常这个知识点)
class Animal {
    void sound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    // 这是一个重写
    @Override
    void sound() {
        System.out.println("Woof");
    }
    
    // 这是一个重载
    void sound(int times) {
        for (int i = 0; i < times; i++) {
            System.out.println("Woof");
        }
    }
}

总结重写是子类对父类方法的具体实现,参数列表和返回值都需相同。重载是在同一个类中创建多个方法名相同但参数列表不同(也可相同),返回值不同(也可相同)的方法。

super和this

接下来在来区分这一组关键字,

super this 都可以在成员方法中用来访问:成员变量和调用其他的成员函数,都可以作为构造方法的 第一条语句 ,那他们之间有什么区别呢?
相同点
1. 都是 Java 中的关键字
2. 只能在类的 非静态方法中使用 ,用来访问非静态成员方法和字段
3. 在构造方法中调用时,必须是构造方法中的 第一条语句,并且不能同时存在
不同点
1. this 是当前对象的引用,当前对象即调用实例方法的对象, super 相当于是子类对象中从父类继承下来部分成
员的引用
2. 在非静态成员方法中, this 用来访问本类的方法和属性, super 用来访问父类继承下来的方法和属性
3. 在构造方法中: this(...) 用于调用本类构造方法, super(...) 用于调用父类构造方法,两种调用不能同时在构造
方法中出现
4. 构造方法中一定会存在 super(...) 的调用,用户没有写编译器也会增加,但是 this(...) 用户不写则没有

继承关系的执行顺序

一、在没有继承代码时。执行的顺序是:

1. 静态代码块先执行, 并且只执行一次 ,在类加载阶段执行
2. 当有对象创建时,才会执行实例代码块,实例代码块执行完成后,最后构造方法执行
即 (以两次为例)                                 
二、有继承代码时,执行的顺序:
1.父类静态代码执行
2.子类静态代码执行
3.父类的实例代码块执行
4.父类的构造方法执行
5.子类的实例代码块执行
6.子类的构造方法执行
并且静态的只执行一次
如果有多次执行(这里以两次为例) 即      

继承方式

注意Java中不支持多继承

在多层继承的情况下,最底层的类可以继承此类往上的所有类的成员变量和成员方法(只要不是私有的)而不是只能继承到父类的

final 关键字

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

1、修饰变量或字段,表示常量 ( 即不能修改 )
2.、修饰类:表示此类不能被继承
3、修饰方法:表示该方法不能被重写
将会再多态部分深入展开

感谢您耐心阅读这篇关于Java继承的文章!如果这些内容对您有所启发,或者您有更多的见解和疑问,欢迎在下方评论区留言分享您的想法。交流和讨论可以帮助我们共同进步!

如果您喜欢这篇文章,请不要吝啬您的点赞👍,您的每一个赞都是对我写作的最大鼓励。同时,您可以收藏🌟这篇博客,方便日后查阅或与朋友分享。

再次感谢您的阅读与支持!期待在评论区与您的精彩互动!💬

  • 25
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值