Java---继承

于 2024-07-14 23:49:35 发布
阅读量1.1k 收藏 36
点赞数 67
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/optimistic_chen/article/details/140423205
版权

乐观学习，乐观生活，才能不断前进啊！！！

我的主页：optimistic_chen
我的专栏：c语言
欢迎大家访问~
创作不易，大佬们点赞鼓励下吧~

前言

经过前面的知识的理解，我们已经对Java语言有了一个初步的认识，通过对类和对象的反复学习，接下来就进入Java的重难点继承与多态，这节博客我们将展开继承来谈。。。

文章目录

什么是继承

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。

继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用

为什么需要继承

Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界存在同一性，事物之间可能会有一些共同点，那在设计程序是就需要考虑。

在这里插入图片描述
通过观察上述代码会发现，猫和狗的类中存在大量重复。
这里我们就要用继承来解释：进行共性抽取，实现代码复用
在这里插入图片描述

继承的语法

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

对刚才的猫类和狗类进行一个动物类的继承设计：

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


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


//Cat类
public class Cat extends Animal{ 
  void mew(){
    System.out.println(name + "喵喵喵~~~");
 }
}

//继承的测试
public class TestExtend {
  public static void main(String[] args) {
    Dog dog = new Dog();
    // dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
    System.out.println(dog.name);
    System.out.println(dog.age);
    // dog访问的eat()和sleep()方法也是从Animal中继承下来的
    dog.eat();
    dog.sleep();
    dog.bark();//子类自身的方法
 }
}

注意：

  1. 子类会将父类中的成员变量或者成员方法继承到子类中
  2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

访问

子类中访问父类中继承下来的成员变量

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

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
 }
}

子类和父类成员变量同名

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;     
    b = 101;     
    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()
 }
}

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问子类的，子类没有时再到父类中找，如果父类中也没有则报错。

成员方法名字相同

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关键字

在子类方法中访问父类的成员。

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();    // 直接访问，则永远访问到的都是子类中的methodB()，父类的无法访问到
    super.methodB(); // 访问父类的methodB()
 }
}

注意：
和子类中访问父类中继承下来的成员变量不同的是super关键字在子类方法中访问父类的成员.
只能在非静态方法中使用.

子类构造方法

子类对象构造时，需要先调用父类构造方法，然后执行子类的构造方法

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();
 }
}

子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整

注意：

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

super和this的相同点：

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

super和this的不同点：

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

代码块执行顺序

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 Test {
  public static void main(String[] args) {
    Student student1 = new Student("张三",19);
    System.out.println("===========================");
    Student student2 = new Student("李四",20);
    }
}

在这里插入图片描述

通过分析执行结果，得出以下结论：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

final关键字

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

//修饰变量或字段，表示常量(即不能修改)
final int a=10;
a=20;//编译出错

//修饰类，表示此类不能被继承
final public class Animal {
 ...
}
public class Bird extends Animal {
 ...
}//编译出错

//修饰方法：表示该方法不能被重写
class Dog{
     final public void bark(){
        System.out.println("woof");
    }
}
class Huang extends Dog{
    public void sniff(){
        System.out.println("sniff");
    }
    //编译出错
    public void bark(){
        System.out.println("bowl");
    }
}

继承方式

在这里插入图片描述

完结

好了，这期的分享到这里就结束了~
如果这篇博客对你有帮助的话，可以点一个免费的赞并收藏起来哟~
可以点点关注，避免找不到我~
我们下期不见不散~~

下期预告：java—多态

optimistic_chen
关注
专栏目录
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值