继承详细讲解

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量33 收藏
点赞数
文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68854873/article/details/132228093
版权

继承详细讲解

什么是继承

为什么要继承

Java使用类对现实世界中实体进行描述,类经过实例化的对象可以用来表示现实中实体,现实世界错综复杂,事物之间会存在关联,我们在设计的时候就要去考虑.
类如:猫和狗都是动物,我们使用java就可以设计出:

    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+"汪汪叫");
    }
}
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+"喵喵叫");
    }
}

我们会发现代码有大量重复:

image-20230810101819030
我们该如何将这些共性抽取?面向对象专门提出继承思想,用来对共性的抽取,实现代码的复用.

继承概念

继承机制:是面向对象程序设计使其代码可以实现复用,允许在原有类特性基础上进行扩展,增加新的功能,产生新的类被称为派生类,继承呈现了面向对象程序设计的设计结构.继承解决的问题是:
对共性的抽取,实现代码的复用.
例如:猫和狗都是动物,我们可以将共性的内容抽取,采用继承的思想达到共用.

image-20230810103756728
由上图可知,dogcat都继承了animal类,animal类称为父类或基类,sog和cat被称为子类,派生类,继承过后,子类可以实现复用父类中成员,子类只需关注自己新增加成员就好了.

继承的语法

在Java中使用继承,要借助extends关键字

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

我们可以去重新设计:

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

 class Dog extends Animal{
    void bark(){
        System.out.println(name+"汪汪叫");
    }
}
 class Cat extends Animal{
    void mew(){
        System.out.println(name+"喵喵叫");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.age = 10;
        //dog类没有定义成员变量,age属性是从父类Animal中继承下来的
        System.out.println(dog.age);
        dog.eat();
        //dog访问的eat方法也是从Animal中继承下来的
    }
}

注意

  1. 子类会将父类中成员方法或成员变量继承到子类当中.
  2. 子类继承父类,必须添加自己特有的成员,体现出与父类不同,否则就没有必要继承了.
    ###父类成员访问
    在继承体系中,子类将父类中方法和字段继承下来了,是否可以直接在子类中访问父类继承下来的成员
子类访问父类成员变量
  1. 子类父类不存在同名成员变量
class A{
    int a;
    int b;
}
class B extends A{
    int c;
    public void methon(){
        a = 10;//访问从父类继承下来的a
        b = 20;//访问从父类继承下来的b
        c = 30;//访问自己的c
    }
}
  1. 子类父类成员变量同名
class A{
    int a;
    int b;
}
class B extends A{
    int a;
    char b;
    int c;
    public void method(){
       a = 100;     // 访问父类继承的a，还是子类自己新增的a？
         b = 101;     // 访问父类继承的b，还是子类自己新增的b?
               c = 102;     // 子类没有c，访问的肯定是从父类继承下来的c
        // d = 103;   // 编译失败，因为父类和子类都没有定义成员变量b
    }
}

在子类方法或通过子类对象访问成员时:
1.如果访问的变量子类成员中有,优先访问自己的成员变量
2.如果访问的成员变量 与父类中同名,优先访问自己的
3.如果都没有定义,编译报错
成员1变量访问遵循就近原则,自己有则优先自己的,没有则向父类中找.

子类中访问父类的成员方法
  1. 成员方法名字不同
    在子类方法或通过子类对象访问方法,优先访问自己的,自己没有时再在父类中寻找,父类没有则编译器报错.
  2. 成员方法名字相同
    通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
    通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；
    那如果子类存在与父类相同成员时,如何在子类访问父类相同名称成员?

super关键字

子类父类可能会存在相同名称的成员,想要在子类成员中访问父类方法,直接访问肯定是做不到,这时就提供了super关键字, 作用就是在子类方法中访问父类成员.

class A{
    int a;
    int b;
    public void methodA(){
        System.out.println("A中的方法A");
    }
    public void methodB(){
        System.out.println("A中的方法B");
    }
}
class B extends A{
    int a;//与父类成员变量同名类型相同
    char b;//与父类成员变量相同类型不同
    public void methodA(int a){
        System.out.println("B中的方法A");
    }
    //与父类中方法重载
    public void methodB(){
        System.out.println("B中的方法B");
    }
    //与父类中方法构成重写
    public void methodC(){
        a= 100;//等价于this.a =100;
        b= 101;//等价于this.b =101;
        //注意:this是当前对象的引用
        //访问父类成员变量,要借助super关键字
        //Ssuper获取的是子类对象从基类继承下来的部分
        super.a = 200;
        super.a = 201;
        //子类和父类构成重载,可以直接通过参数列表区分访问的是父类还是子类
        methodA();//没有传参,访问父类的
        methodA(a);//传递int参数,访问子类的
        //子类中访问重写的父类方法,要借助super关键字
        methodB();//直接访问,永远访问到的是是子类方法
        super.methodB();//访问父类方法
    }
}

注意:

  1. 只能在非静态方法中使用
  2. 在子类方法中,访问父类成员变量方法

子类构造方法

子类对象在构造时,需要先调用基类构造方法,再去执行子类构造方法

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

子类对象成员有两部分组成,父类继承下来及子类新增加的部分,在构造子类对象的时候,要先调用基类构造方法,将基类继承下来的成员构造完整,再调用自己的构造方法,将子类自己新增加的成员初始化完整.
注意:

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

super和this

他们都可以在成员方法中访问成员变量和调用其他的成员函数,都可以作为构造方法第一条语句,那有什么区别呢?
相同点:

  1. 都是Java关键字
  2. 在类的非静态方法使用,来访问非静态成员和字段
  3. 在构造方法中调用,需要是构造方法第一条语句,并且不能同时存在
    不同点:
  4. this是当前对象引用 ,当前对象调用实例方法对象,super相当于子类对象从父类继承下来部分的引用
  5. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
  6. 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造
    方法中出现
  7. 构造方法中一定会存在super(…)的调用，没有写编译器也会增加，但是this(…)不写则没有
    iage-20230810152122271

再谈初始化

我们之前就说过代码块,我们知道有几个重要的代码块:实例代码块,静态代码块,在没有继承时执行顺序.

 class Animal {
     public String name;
     public int age;
     public float weight;

     public Animal(String name, int age, float weight) {
         this.name = name;
         this.age = age;
         this.weight = weight;
         System.out.println("构造方法执行");
     }
     {
         System.out.println("实例代码块执行");
     }
     static {
         System.out.println("静态代码块执行");
     }
 }
 public class Test1 {
     public static void main(String[] args) {
         Animal animal1 =new Animal("zahngsan1",11,12.1f);
         System.out.println("================");
         Animal animal2 =new Animal("lisi",12,12);
     }
}

执行结果:

静态代码块执行
实例代码块执行
构造方法执行
================
实例代码块执行
构造方法执行
  1. 静态代码块只执行一次,最先执行,在类加载阶段执行
  2. 有对象创建,才执行实例代码块,实例代码块执行完成后 ,最后构造方法执行
    在继承关系上执行顺序:
 class Animal {
     public String name;
     public int age;
     public float weight;

     public Animal(String name, int age, float weight) {
         this.name = name;
         this.age = age;
         this.weight = weight;
         System.out.println("构造方法执行");
     }
     {
         System.out.println("实例代码块执行");
     }
     static {
         System.out.println("静态代码块执行");
     }
 }
 class Cat extends Animal{
     public Cat(String name, int age, float weight) {
         super(name, age, weight);
         System.out.println("构造方法执行");
     }
     {
         System.out.println("实例代码块执行");
     }
     static {
         System.out.println("静态代码块执行");
     }
 }
 public class Test1 {
     public static void main(String[] args) {
         Cat cat1=new Cat("zahngsan1",11,12.1f);
         System.out.println("================");
         Cat cat2 =new Cat("lisi",12,12);
     }
}
执行结果
静态代码块执行
静态代码块执行
实例代码块执行
构造方法执行
实例代码块执行
===========
实例代码块执行
构造方法执行
实例代码块执行
构造方法执行

我们可知:

  1. 父类静态代码块优先于子类代码块执行,且最早执行
  2. 父类实例代码块和父类构造方法再接着执行,其次是子类实例代码块和构造方法
  3. 第二次实例化子类对象,父类和子类静态代码块都不再被执行

protected关键字

在类和对象中,为实现封装,java要引入访问限定符,限定类或者类中成员是否在类外或其他包中访问.

image-20230811111501724
那父类中不同访问权限的成员,在子类中可见性是什么呢

// 为了掩饰基类中不同访问权限在子类中的可见性，为了简单类B中就不设置成员方法了
// extend01包中
public class B {
  private int a;
  protected int b;
  public int c;
  int d;
}
// extend01包中
// 同一个包中的子类
public class D extends B{
    public void method(){
    // super.a = 10;   // 编译报错，父类private成员在相同包子类中不可见
    super.b = 20;     // 父类中protected成员在相同包子类中可以直接访问
    super.c = 30;     // 父类中public成员在相同包子类中可以直接访问
    super.d = 40;     // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问
 }
}
// extend02包中
// 不同包中的子类
public class C extends B {
    public void method(){
    // super.a = 10;   // 编译报错，父类中private成员在不同包子类中不可见
    super.b = 20;     // 父类中protected修饰的成员在不同包子类中可以直接访问
    super.c = 30;     // 父类中public修饰的成员在不同包子类中可以直接访问
    //super.d = 40;   // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
 }
}
// extend02包中
// 不同包中的类
public class TestC {
  public static void main(String[] args) {
    C c = new C();
    c.method();
    // System.out.println(c.a);  // 编译报错，父类中private成员在不同包其他类中不可见
    // System.out.println(c.b);  // 父类中protected成员在不同包其他类中不能直接访问
    System.out.println(c.c);    // 父类中public成员在不同包其他类中可以直接访问
    // System.out.println(c.d);  // 父类中默认访问权限修饰的成员在不同包其他类中不能直接访问
 }
}

父类中private成员变量在子类中不能直接访问,但是会继承到子类中.
我们要让类尽量做到"封装",隐藏内部细节,只暴露出必要信息.
我们要在使用时使用比较严格的访问权限,不能对访问权限滥用

继承方式

在生活中,很复杂,如:

image-20230811114027030
在Java中支持以下几种:

image-20230811114115984

final关键字

final可以修饰类,变量和成员方法.

  1. 修饰变量字段,则成为常量,不能改变.
  2. 修饰类,则不能继承.
  3. 修饰方法则不能重写

继承和组合

组合也是表达类之间的关系,做到代码重用,就是将一个类的实例作为另外一个类的字段.
组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合
会继承到子类中.
我们要让类尽量做到"封装",隐藏内部细节,只暴露出必要信息.
我们要在使用时使用比较严格的访问权限,不能对访问权限滥用

继承方式

在生活中,很复杂,如:

[外链图片转存中…(img-9jiUqWVS-1691725704874)]
在Java中支持以下几种:

[外链图片转存中…(img-uYbsrOeg-1691725704874)]

final关键字

final可以修饰类,变量和成员方法.

  1. 修饰变量字段,则成为常量,不能改变.
  2. 修饰类,则不能继承.
  3. 修饰方法则不能重写

继承和组合

组合也是表达类之间的关系,做到代码重用,就是将一个类的实例作为另外一个类的字段.
组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合

小刘努力变强
关注
C++中的继承 详细讲解
foodsx的博客
05-23 1803
C++中的继承 详细讲解
详细讲解虚继承
galaxyrt的博客
06-23 7222
虚继承的作用：防止产生二义性 先来看一看下面的一段代码吧： #define _CRT_SECURE_NO_WARINGS #include<iostream> #include<string> using namespace std; class Grandfather { public: Grandfather() { cout << "爷爷的构造函数" << endl; } ~Grandfather() { cout << "爷爷的析
C++ 中的继承（详细讲解）
2302_76267737的博客
09-19 1872
下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。意思就是，我们拿基类成员的权限与派生类继承方式的权限作比较，基类的其他成员在子类的访问方式就是较小的那个权限方式。
JAVA继承和多态详细讲解
weixin_45536242的博客
07-08 3306
面向对象编程的重要知识：继承和多态。通过类的继承机制，可以使用已有的类为基础派生出新类，无需编写重复的程序代码，很好地实现程序代码复用。多态是面向对象编程中继封装和继承之后的另一大特征，它具体是指同一个行为具有多个不同表现形式或形态的能力。使用多态机制，可以提高程序的抽象程度和简洁性，最大程度地降低类和程序模块间的耦合性，并提高程序的可扩展性和可维护性。从Java语言的底层逻辑上看，封装和继承是为实现多态做准备的。6.1 类的继承继承描述了类的所属关系，多个类通过继承可形成一个关系体系，进而在原有类的基础上
java 继承讲解
weixin_42617075的博客
08-28 1996
java 继承 定义 ：继承遗产 继承父母的基因….程序也是源于生活的，程序的继承也是现实概念中的抽象。 举例：一个教java的老师 、教htm老师。,老师是不是很抽象有很多种老师，英语语文数学。。。 但是子类直接就具体的说明了是那种老师，java 的还是html。 兔子和羊属于食草动物类，狮子和豹属于食肉动物类。 食草动物和食肉动物又是属于动物类。 ...
C++中的菱形继承【详细讲解】
weixin_45688108的博客
10-19 1104
本篇文章主要对于C++语言中的菱形继承进行了详细的讲解。菱形继承是我们在编写C++程序时所应当避免的，所以希望读者能够从本篇文章中了解到菱形继承可能导致的问题，避免在编写程序是出现问题。
UML详细讲解
热门推荐
qq_29912325的博客
10-09 3万+
1.UML概述 1.1.什么是UML 统一建模语言（UML）是一种通用的可视化建模语言，可以用来描述、可视化、构造和文档化软件密集型系统的各种工件。 UML是独立于过程的，它适用于各种软件开发方法、软件生命周期的各个阶段、各种应用领域以及各种开发工具。 注：UML不是一种程序设计语言，其描述的模型可以和各种编程语言相联系。 1.2.UML的目标 为建模者提供可用的、富有表达力的、可视化的建模语言，以开发和交换有意义的模型。 提供可扩展性和特殊化机制以延伸核心概念。 支持独立于编程语言和开发过
List集合详细讲解
m0_65725031的博客
06-28 1万+
list集合想必大家都是不陌生的，我们用的也是非常的多，但是可能大家在使用中，也不是对list集合有非常详细的讲解，今天小编就详细的带大家了解list集合。目录 一.集合之间的关系 二.List集合三.ArrayList集合 for循环删除方法01 for循环删除方法02for循环删除方法03foreach删除方法迭代器删除01迭代器删除元素02list集合删除方法 四.LinkedList集合五.Vector集合 六.CopyOnWriteArrayList集合 下方是一张UML图，vector，Arr
Java面向对象——继承（超详细讲解）
Best_Basic的博客
08-11 5626
Java继承：是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。 JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口，从而克服单继承的缺点。......
详细剖析Java继承
Gremmie的博客
04-05 3159
十分详细得了讲解Java继承中的概念和运用
C++类与对象-继承（详细讲解）
03-24
### C++ 类与对象 - 继承（详细讲解） #### 一、继承的基础介绍 **继承** 是面向对象编程中的一个重要特性，它允许一个类（称为派生类或子类）继承另一个类（称为基类或父类）的属性和方法。通过这种方式，可以...
Python类和继承的完全代码实现、详细讲解
01-14
Python类和继承的完全代码实现、详细讲解
python中的多重继承实例讲解
12-23
python和C++一样，支持多继承。概念虽然容易，但是困难的工作是如果子类调用一个自身没有定义的属性，它是按照何种顺序去到父类寻找呢，尤其是众多父类中有多个都包含该同名属性。 对经典类和新式类来说，属性的查找...
代码讲解C++继承和派生
12-31
继承是是指一个对象直接使用另一对象的属性和方法。 继承的作用： 1.描述客观事物的层次结构 2.分类的方法进行分析和描述 3.复杂的系统层次化，提高代码的重用性 4.增强语言功能，提高软件开发效益 继承分为单...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1150
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 73
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 495
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 205
BI商业智能：数据可视化、报表可视化系统。
Java继承：构造器实例与继承层次讲解
此外，讲解了如何遵循 "is-a" 规则来验证继承设计的有效性，确保子类对象能够被视为父类对象。例如，如果有一个名为 "Transport" 的父类，然后有 "AirTransport", "LandTransport", 和 "WaterTransport" 子类，它们...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值