Day13 - 面向对象进阶 - 3. 继承

原创 于 2025-04-26 17:11:17 发布 · 711 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言

第三章 继承

3.1 概述

3.1.1 引入

假如我们要定义如下类: 学生类,老师类和工人类，分析如下。

  1. 学生类 属性:姓名,年龄 行为:吃饭,睡觉

  2. 老师类 属性:姓名,年龄，薪水 行为:吃饭,睡觉，教书

  3. 班主任 属性:姓名,年龄，薪水 行为:吃饭,睡觉，管理

如果我们定义了这三个类去开发一个系统，那么这三个类中就存在大量重复的信息（属性:姓名，年龄。行为：吃饭，睡觉）。这样就导致了相同代码大量重复，代码显得很臃肿和冗余，那么如何解决呢？

假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：

其中，多个类可以称为子类，单独被继承的那一个类称为父类、超类（superclass）或者基类。

🔹 理论理解
继承是面向对象三大特性之一。它建立了**通用类（父类）与专用类（子类）之间的is-a（是一个）**关系，使得代码结构清晰，功能模块分明，减少重复开发，提升代码重用性。

🔹 企业实战理解

  • 阿里巴巴：明确继承树设计原则，不允许超过三层继承，避免继承链过深导致可维护性下降。

  • 字节跳动：服务端项目（如推荐系统）中，基类定义通用属性（如requestId、traceId），各子类继承扩展特有字段。

  • Google TensorFlow：核心计算单元（OpKernel）使用继承扩展不同类型的计算节点，标准化开发流程。

  • OpenAI GPT推理模块：底层组件统一继承基础类（如ModuleBase），保障接口统一、扩展灵活。

 

3.1.2 继承的含义

继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

3.1.3 继承的好处

  1. 提高代码的复用性（减少代码冗余，相同代码重复利用）。

  2. 使类与类之间产生了关系。

3.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
    ...
}
​
class 子类 extends 父类 {
    ...
}

需要注意：Java是单继承的，一个类只能继承一个直接父类，跟现实世界很像，但是Java中的子类是更加强大的。

🔹 理论理解
Java采用单继承模型（extends），一个子类只能直接继承一个父类，但可以间接继承多个祖先类，形成继承链。继承是子类对父类能力的增强或定制。

🔹 企业实战理解

  • 阿里P8技术规范：禁止继承混乱，必须确保继承层次清晰、意图明确，否则拒绝代码合并。

  • Google Android开发：Activity、Service等核心组件均通过继承抽象基类，统一生命周期管理。

3.3 继承案例

3.3.1 案例

请使用继承定义以下类:

  1. 学生类 属性:姓名,年龄 行为:吃饭,睡觉

  2. 老师类 属性:姓名,年龄，薪水 行为:吃饭,睡觉，教书

  3. 班主任 属性:姓名,年龄，薪水 行为:吃饭,睡觉，管理

3.3.2 案例图解分析

老师类，学生类，还有班主任类，实际上都是属于人类的，我们可以定义一个人类，把他们相同的属性和行为都定义在人类中，然后继承人类即可，子类特有的属性和行为就定义在子类中了。

如下图所示。

3.3.3 案例代码实现

1.父类Human类

 public class Human {
    // 合理隐藏
    private String name ;
    private int age ;
    
    // 合理暴露
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
 }

2.子类Teacher类

public class Teacher extends Human {
    // 工资
    private double salary ;
    
    // 特有方法
    public void teach(){
        System.out.println("老师在认真教技术！")；
    }
​
    public double getSalary() {
        return salary;
    }
​
    public void setSalary(double salary) {
        this.salary = salary;
    }
}

3.子类Student类

public class Student extends Human{
 
}

4.子类BanZhuren类

public class Teacher extends Human {
    // 工资
    private double salary ;
    
       // 特有方法
    public void admin(){
        System.out.println("班主任强调纪律问题！")；
    }
    
    public double getSalary() {
        return salary;
    }
​
    public void setSalary(double salary) {
        this.salary = salary;
    }
}

5.测试类

  public class Test {
      public static void main(String[] args) {
          Teacher dlei = new Teacher();
          dlei.setName("播仔");
          dlei.setAge("31");
          dlei.setSalary(1000.99);
          System.out.println(dlei.getName());
          System.out.println(dlei.getAge());
          System.out.println(dlei.getSalary());
          dlei.teach();
          
          BanZhuRen linTao = new BanZhuRen();
          linTao.setName("灵涛");
          linTao.setAge("28");
          linTao.setSalary(1000.99);
          System.out.println(linTao.getName());
          System.out.println(linTao.getAge());
          System.out.println(linTao.getSalary());
          linTao.admin();
​
          Student xugan = new Student();
          xugan.setName("播仔");
          xugan.setAge("31");
          //xugan.setSalary(1000.99); // xugan没有薪水属性，报错！
          System.out.println(xugan.getName());
          System.out.println(xugan.getAge());
​
​
​
      }
  }

3.3.4 小结

1.继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。

2.子类继承父类，就可以直接得到父类的成员变量和方法。是否可以继承所有成分呢？请看下节！

 

🔹 理论理解
通过继承复用父类代码，避免重复定义相同属性和方法，同时保留子类的独特性，符合开闭原则（对扩展开放，对修改封闭）。

🔹 企业实战理解

  • 字节跳动中台系统：人、组织、部门等实体，统一继承基础Entity类，减少属性定义重复，提高系统一致性。

  • NVIDIA AI训练框架：模型定义继承标准Layer或Module基类，保证不同模型组件之间兼容性。

3.4 子类不能继承的内容

3.4.1 引入

并不是父类的所有内容都可以给子类继承的：

子类不能继承父类的构造方法。

值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。

3.4.1 演示代码

public class Demo03 {
    public static void main(String[] args) {
        Zi z = new Zi();
        System.out.println(z.num1);
//      System.out.println(z.num2); // 私有的子类无法使用
        // 通过getter/setter方法访问父类的private成员变量
        System.out.println(z.getNum2());
​
        z.show1();
        // z.show2(); // 私有的子类无法使用
    }
}
​
class Fu {
    public int num1 = 10;
    private int num2 = 20;
​
    public void show1() {
        System.out.println("show1");
    }
​
    private void show2() {
        System.out.println("show2");
    }
​
    public int getNum2() {
        return num2;
    }
​
    public void setNum2(int num2) {
        this.num2 = num2;
    }
}
​
class Zi extends Fu {
}

🔹 理论理解
子类不能继承父类的构造方法，但能通过super()调用。同时，子类虽然继承了父类的私有成员，但无法直接访问，只能通过公共getter/setter方法访问。

🔹 企业实战理解

  • 阿里巴巴：安全性要求严格，敏感字段一律private，子类只能通过接口访问，防止逻辑绕过。

  • OpenAI Codex系统：对加密模型参数采用private封装，子类无法直接访问底层权重，保障推理安全。

3.5 继承后的特点—成员变量

当类之间产生了继承关系后，其中各类中的成员变量，又产生了哪些影响呢？

3.5.1 成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：

class Fu {
    // Fu中的成员变量
    int num = 5;
}
class Zi extends Fu {
    // Zi中的成员变量
    int num2 = 6;
  
    // Zi中的成员方法
    public void show() {
        // 访问父类中的num
        System.out.println("Fu num="+num); // 继承而来，所以直接访问。
        // 访问子类中的num2
        System.out.println("Zi num2="+num2);
    }
}
class Demo04 {
    public static void main(String[] args) {
        // 创建子类对象
        Zi z = new Zi(); 
        // 调用子类中的show方法
        z.show();  
    }
}

​
演示结果：
Fu num = 5
Zi num2 = 6

3.5.2 成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：

class Fu1 {
    // Fu中的成员变量。
    int num = 5;
}
class Zi1 extends Fu1 {
    // Zi中的成员变量
    int num = 6;
  
    public void show() {
        // 访问父类中的num
        System.out.println("Fu num=" + num);
        // 访问子类中的num
        System.out.println("Zi num=" + num);
    }
}
class Demo04 {
    public static void main(String[] args) {
        // 创建子类对象
        Zi1 z = new Zi1(); 
        // 调用子类中的show方法
        z1.show(); 
    }
}

演示结果：
Fu num = 6
Zi num = 6

子父类中出现了同名的成员变量时，子类会优先访问自己对象中的成员变量。如果此时想访问父类成员变量如何解决呢？我们可以使用super关键字。

3.5.3 super访问父类成员变量

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super 关键字，修饰父类成员变量，类似于之前学过的 this 。

需要注意的是：super代表的是父类对象的引用，this代表的是当前对象的引用。

使用格式：

super.父类成员变量名

子类方法需要修改，代码如下：

class Fu {
    // Fu中的成员变量。
    int num = 5;
}
​
class Zi extends Fu {
    // Zi中的成员变量
    int num = 6;
  
    public void show() {
        int num = 1;
      
        // 访问方法中的num
        System.out.println("method num=" + num);
        // 访问子类中的num
        System.out.println("Zi num=" + this.num);
        // 访问父类中的num
        System.out.println("Fu num=" + super.num);
    }
}
​
class Demo04 {
    public static void main(String[] args) {
        // 创建子类对象
        Zi1 z = new Zi1(); 
        // 调用子类中的show方法
        z1.show(); 
    }
}
​

演示结果：
method num=1
Zi num=6
Fu num=5

小贴士：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

🔹 理论理解
子类继承父类成员变量，但如果出现同名变量，子类的会隐藏父类的。需要用super.变量名来访问父类同名变量。

🔹 企业实战理解

  • 字节跳动广告平台：数据追踪对象字段规范，若父子类有同名属性，必须通过super明确区分，避免日志数据污染。

  • Google Protobuf结构设计：继承时强制规范字段命名，避免父子类字段冲突。

3.6 继承后的特点—成员方法

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？

3.6.1 成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：

class Fu {
    public void show() {
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu {
    public void show2() {
        System.out.println("Zi类中的show2方法执行");
    }
}
public  class Demo05 {
    public static void main(String[] args) {
        Zi z = new Zi();
        //子类中没有show方法，但是可以找到父类方法去执行
        z.show(); 
        z.show2();
    }
}

3.6.2 成员方法重名

如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法。

代码如下：

class Fu {
    public void show() {
        System.out.println("Fu show");
    }
}
class Zi extends Fu {
    //子类重写了父类的show方法
    public void show() {
        System.out.println("Zi show");
    }
}
public class ExtendsDemo05{
    public static void main(String[] args) {
        Zi z = new Zi();
        // 子类中有show方法，只执行重写后的show方法
        z.show();  // Zi show
    }
}

🔹 理论理解
子类继承父类方法，如果重名，子类优先；可以通过super.方法名()调用父类版本。支持方法重写（Override）以满足不同功能需求。

🔹 企业实战理解

  • 阿里：在框架设计中，父类提供基础默认实现（Template Method模式），子类根据业务需要重写关键方法。

  • Google TensorFlow：算子（Op）设计中，基类提供标准接口，子类重写以实现不同硬件优化版本。

 

3.7 方法重写

3.7.1 概念

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

3.7.2 使用场景与案例

发生在子父类之间的关系。 子类继承了父类的方法，但是子类觉得父类的这方法不足以满足自己的需求，子类重新写了一个与父类同名的方法，以便覆盖父类的该方 法。

例如：我们定义了一个动物类代码如下：

public class Animal  {
    public void run(){
        System.out.println("动物跑的很快！");
    }
    public void cry(){
        System.out.println("动物都可以叫~~~");
    }
}

然后定义一个猫类，猫可能认为父类cry()方法不能满足自己的需求

代码如下：

public class Cat extends Animal {
    public void cry(){
        System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
    }
}
​
public class Test {
    public static void main(String[] args) {
        // 创建子类对象
        Cat ddm = new Cat()；
        // 调用父类继承而来的方法
        ddm.run();
        // 调用子类重写的方法
        ddm.cry();
    }
}

3.7.2 @Override重写注解

  • @Override:注解，重写注解校验！

  • 这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。

  • 建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

    加上后的子类代码形式如下：

    public class Cat extends Animal {
     // 声明不变，重新实现
    // 方法名称与父类全部一样，只是方法体中的功能重写写了！
    @Override
    public void cry(){
        System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
    }
}

3.7.3 注意事项

  1. 方法重写是发生在子父类之间的关系。

  2. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

  3. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

🔹 理论理解
方法重写是指子类重新定义父类已有方法（方法签名相同，返回类型和参数一致），以实现行为差异化。

🔹 企业实战理解

  • 字节跳动推荐系统：不同推荐场景（短视频、直播、电商）通过重写推荐逻辑方法，实现不同策略下的推送。

  • OpenAI fine-tuning模块：在模型微调任务中，重写训练步骤（training_step）以适应不同损失函数和优化器。

3.8 继承后的特点—构造方法

3.8.1 引入

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？ 首先我们要回忆两个事情，构造方法的定义格式和作用。

  1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。

  2. 构造方法的作用是初始化对象成员变量数据的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。（先有爸爸，才能有儿子）

继承后子类构方法器特点:子类所有构造方法的第一行都会默认先调用父类的无参构造方法

3.8.2 案例演示

按如下需求定义类:

  1. 人类 成员变量: 姓名,年龄 成员方法: 吃饭

  2. 学生类 成员变量: 姓名,年龄,成绩 成员方法: 吃饭

代码如下：

class Person {
    private String name;
    private int age;
​
    public Person() {
        System.out.println("父类无参");
    }
​
    // getter/setter省略
}
​
class Student extends Person {
    private double score;
​
    public Student() {
        //super(); // 调用父类无参,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }
    
     public Student(double score) {
        //super();  // 调用父类无参,默认就存在，可以不写，必须再第一行
        this.score = score;    
        System.out.println("子类有参");
     }
​
}
​
public class Demo07 {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println("----------");
        Student s2 = new Student(99.9);
    }
}

​
输出结果：
父类无参
子类无参
----------
父类无参
子类有参

3.8.3 小结

  • 子类构造方法执行的时候，都会在第一行默认先调用父类无参数构造方法一次。

  • 子类构造方法的第一行都隐含了一个super()去调用父类无参数构造方法，super()可以省略不写。

🔹 理论理解
子类构造方法默认会先调用父类无参构造器super()，确保父类成员初始化完成后，再初始化子类成员。

🔹 企业实战理解

  • 阿里中间件：RPC请求对象继承通用请求基类，子类构造器强制调用父类构造器初始化traceId、rpcId等基础追踪信息。

  • NVIDIA TensorRT推理框架：推理模块子类构建时，必须保证父类（内存资源管理器）构造完整，避免内存泄漏。

 

3.9 super(...)和this(...)

3.9.1 引入

请看上节中的如下案例：

class Person {
    private String name;
    private int age;
​
    public Person() {
        System.out.println("父类无参");
    }
​
    // getter/setter省略
}
​
class Student extends Person {
    private double score;
​
    public Student() {
        //super(); // 调用父类无参构造方法,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }
    
     public Student(double score) {
        //super();  // 调用父类无参构造方法,默认就存在，可以不写，必须再第一行
        this.score = score;    
        System.out.println("子类有参");
     }
      // getter/setter省略
}
​
public class Demo07 {
    public static void main(String[] args) {
        // 调用子类有参数构造方法
        Student s2 = new Student(99.9);
        System.out.println(s2.getScore()); // 99.9
        System.out.println(s2.getName()); // 输出 null
        System.out.println(s2.getAge()); // 输出 0
    }
}

我们发现，子类有参数构造方法只是初始化了自己对象中的成员变量score，而父类中的成员变量name和age依然是没有数据的，怎么解决这个问题呢，我们可以借助与super(...)去调用父类构造方法，以便初始化继承自父类对象的name和age.

3.9.2 super和this的用法格式

super和this完整的用法如下，其中this，super访问成员我们已经接触过了。

this.成员变量       --    本类的
super.成员变量      --    父类的
​
this.成员方法名()    --    本类的    
super.成员方法名()   --    父类的

接下来我们使用调用构造方法格式：

super(...) -- 调用父类的构造方法，根据参数匹配确认
this(...) -- 调用本类的其他构造方法，根据参数匹配确认

3.9.3 super(....)用法演示

代码如下：

class Person {
    private String name ="凤姐";
    private int age = 20;
​
    public Person() {
        System.out.println("父类无参");
    }
    
    public Person(String name , int age){
        this.name = name ;
        this.age = age ;
    }
​
    // getter/setter省略
}
​
class Student extends Person {
    private double score = 100;
​
    public Student() {
        //super(); // 调用父类无参构造方法,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }
    
     public Student(String name ， int age，double score) {
        super(name ,age);// 调用父类有参构造方法Person(String name , int age)初始化name和age
        this.score = score;    
        System.out.println("子类有参");
     }
      // getter/setter省略
}
​
public class Demo07 {
    public static void main(String[] args) {
        // 调用子类有参数构造方法
        Student s2 = new Student("张三"，20，99);
        System.out.println(s2.getScore()); // 99
        System.out.println(s2.getName()); // 输出 张三
        System.out.println(s2.getAge()); // 输出 20
    }
}

注意：

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

super(..)是根据参数去确定调用父类哪个构造方法的。

3.9.4 super(...)案例图解

父类空间优先于子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造七调用时，一定先调用父类的构造方法。理解图解如下：

3.9.5 this(...)用法演示

this(...)

  • 默认是去找本类中的其他构造方法，根据参数来确定具体调用哪一个构造方法。

  • 为了借用其他构造方法的功能。

package com.itheima._08this和super调用构造方法;
/**
 * this(...):
 *    默认是去找本类中的其他构造方法，根据参数来确定具体调用哪一个构造方法。
 *    为了借用其他构造方法的功能。
 *
 */
public class ThisDemo01 {
    public static void main(String[] args) {
        Student xuGan = new Student();
        System.out.println(xuGan.getName()); // 输出:徐干
        System.out.println(xuGan.getAge());// 输出:21
        System.out.println(xuGan.getSex());// 输出： 男
    }
}
​
class Student{
    private String name ;
    private int age ;
    private char sex ;
​
    public Student() {
  // 很弱，我的兄弟很牛逼啊，我可以调用其他构造方法：Student(String name, int age, char sex)
        this("徐干",21,'男');
    }
​
    public Student(String name, int age, char sex) {
        this.name = name ;
        this.age = age   ;
        this.sex = sex   ;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public char getSex() {
        return sex;
    }
​
    public void setSex(char sex) {
        this.sex = sex;
    }
}

3.9.6 小结

  • 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

  • super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

  • super(..)和this(...)是根据参数去确定调用父类哪个构造方法的。

  • super(..)可以调用父类构造方法初始化继承自父类的成员变量的数据。

  • this(..)可以调用本类中的其他构造方法。

3.10 继承的特点

  1. Java只支持单继承，不支持多继承。

// 一个类只能有一个父类，不可以有多个父类。
class A {}
class B {}
class C1 extends A {} // ok
// class C2 extends A, B {} // error

  1. 一个类可以有多个子类。

// A可以有多个子类
class A {}
class C1 extends A {}
class C2 extends  A {}

  1. 可以多层继承。

class A {}
class C1 extends A {}
class D extends C1 {}

顶层父类是Object类。所有的类默认继承Object，作为父类。

🔹 理论理解

  • 单继承：一个子类只能有一个直接父类。

  • 多层继承：支持子类继承父类，父类继承祖父类，形成继承链。

  • 继承提高代码复用，但过度继承会增加系统复杂性，应适度使用。

🔹 企业实战理解

  • 阿里P8级规范：继承链最多3层，超过3层需使用组合、委托、接口等替代。

  • OpenAI系统设计：核心模块采用浅继承+多接口组合，保证系统灵活扩展与高可维护性。

  • Google Android源码：Activity、Service等核心组件仅继承一层，鼓励组合而非深度继承。

4. 关于今天知识的小结：

会写一个继承结构下的标准Javabean即可

需求：

猫：属性，姓名，年龄，颜色

狗：属性，姓名，年龄，颜色，吼叫

分享书写技巧：

1.在大脑中要区分谁是父，谁是子

2.把共性写到父类中，独有的东西写在子类中

3.开始编写标准Javabean（从上往下写）

4.在测试类中，创建对象并赋值调用

代码示例：

package com.itheima.test4;
​
public class Animal {
    //姓名，年龄，颜色
    private String name;
    private int age;
    private String color;
​
​
    public Animal() {
    }
​
    public Animal(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
}
​
​
public class Cat extends Animal{
    //因为猫类中没有独有的属性。
    //所以此时不需要写私有的成员变量
​
    //空参
    public Cat() {
    }
​
    //需要带子类和父类中所有的属性
    public Cat(String name, int age, String color) {
        super(name,age,color);
    }
}
​
​
public class Dog extends Animal{
    //Dog ：吼叫
    private String wang;
​
    //构造
    public Dog() {
    }
​
    //带参构造：带子类加父类所有的属性
    public Dog(String name, int age, String color,String wang) {
        //共性的属性交给父类赋值
        super(name,age,color);
        //独有的属性自己赋值
        this.wang = wang;
    }
​
    public String getWang() {
        return wang;
    }
​
    public void setWang(String wang) {
        this.wang = wang;
    }
}
​
public class Demo {
    public static void main(String[] args) {
        //Animal ： 姓名，年龄，颜色
        //Cat :
        //Dog ：吼叫
​
        //创建狗的对象
        Dog d = new Dog("旺财",2,"黑色","嗷呜~~");
        System.out.println(d.getName()+", " + d.getAge() + ", " + d.getColor() + ", " + d.getWang());
​
        //创建猫的对象
        Cat c = new Cat("中华田园猫",3,"黄色");
        System.out.println(c.getName() + ", " + c.getAge() + ", " + c.getColor());
    }
}

​
​

day18-面向对象进阶
m0_74653634的博客
05-27 970
本课程讲解了Python面向对象编程的进阶知识，重点包括： 成员变量：实例变量（对象独有）与类变量（所有对象共享） 方法类型：绑定方法（带self）、类方法（带@classmethod）、静态方法（带@staticmethod） 成员修饰符：公有与私有成员的访问控制 对象嵌套：对象间的关联关系 特殊成员：如__init__等内置方法 课程通过实例演示了类变量与实例变量的区别、不同方法的调用方式，以及@property装饰器创建属性的技巧。还包含常见面试题如继承关系中变量的读写规则、@classmetho
Java零基础学习Day13——面向对象进阶
最新发布
m0_68932052的博客
05-14 1194
JavaBean类用于描述一类事物的类比如Student、Cat等测试类用来检查其他类是否书写正确带有main方法的类，是程序的入口工具类用来帮我们做一些事情的类私有化构造方法，目的是为了不让外界创建其对象方法定义为静态public（其他的非私有同理）private构造方法NONO成员变量YESYES成员方法虚方法YES非虚方法NO构造方法：违背了构造方法的名字和类名（class）不一致成员变量：private是继承了但不能直接使用成员方法：只有基类的虚方法才能被派生类继承。
简述java什么是继承_Java基础教程：Java继承概述
weixin_39805720的博客
02-25 484
继承概述假如我们要定义如下类：学生类，老师类和工人类，分析如下。学生类属性：姓名，年龄行为：吃饭，睡觉老师类属性：姓名，年龄，薪水行为：吃饭，睡觉，教书班主任属性：姓名，年龄，薪水行为：吃饭，睡觉，管理如果我们定义了这三个类去开发一个系统，那么这三个类中就存在大量重复的信息(属性：姓名，年龄。行为：吃饭，睡觉)。这样就导致了相同代码大量重复，代码显得很臃肿和冗余，那么如何解决呢？假如多个类中存在相...
015——继承(来 ， 看看Java中的继承关系)
遇事不决 ， 可问春风
10-09 2944
继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。}Student称为子类（派生类），People称为父类(基类 或超类)。作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。
java 继承是什么_java中继承指的是什么
weixin_32841641的博客
02-21 5674
java中继承指的是什么发布时间：2020-08-20 14:46:11来源：亿速云阅读：55作者：小新这篇文章将为大家详细讲解有关java中继承指的是什么，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。java中继承是什么？Java中的继承是一个对象获取父对象的所有属性和行为的机制。它是面向对象编程系统(OOP)的重要组成部分。Java中继承的思想是，创建基于现...
java 继承_Java 继承
weixin_42318912的博客
02-18 314
Java 继承继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承可以理解为一个对象从另一个对象获取属性的过程。如果类A是类B的父类，而类B是类C的父类，我们也称C是A的子类，类C是从类A继承而来的。在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类继承中最常使用的两个关键字是extends和implements。这两个关键字的使用决定了一个对象和另一个对...
Java 继承是什么？
唐衡三
12-22 6995
继承是面向对象最显著的一个特性。 继承是从已有的类中派生出新的类， 新的类能吸收已有类的数据属性和行为，并能扩展新的能力。 简单来说，就是你父亲有的东西，你就不用再自己去创建了；减少不必要的创建，实现拿来主义的最好证明。 继承优点： 1、子类拥有父类非 private 的属性、方法。 2、子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。 3、子类可以用自己的方式实现父类的方法。 4、Java 的继承是可以单继承和多重继承，也可以不同类的继承组成兄弟关系，同一个源头不同的个人。 继承缺点：
day01-03讲义(面向对象进阶).zip
03-05
在本讲义中，我们将深入探讨面向对象进阶的主题，主要包括类与对象、继承、多态以及封装等核心概念。 1. 类与对象 类是创建对象的蓝图，它定义了对象的属性（数据成员）和行为（成员函数）。对象是类的实例，拥有类...
8天高强度Python训练营day1-4天课件(3).zip
09-29
6. **面向对象编程**：类和对象的概念，继承、封装和多态等面向对象特性。 7. **异常处理**：理解和使用try-except语句进行错误处理。 8. **函数式编程**：高阶函数、闭包、装饰器等概念及其应用。 【压缩包子文件...
接口高级-day01-笔记、代码.rar
02-21
在面向对象编程中，接口定义了一组方法签名，但不提供具体的实现。通过接口，不同类之间可以进行通信，实现了松耦合。 2. **Python中的接口**：Python不同于Java等语言，它没有明确的接口关键字。但是，我们可以...
Java继承的基本概念及其限制 总结
weixin_33785108的博客
05-29 228
一、继承的基本概念及其限制 继承：就是扩展已有类的功能，在继承中分为子类和父类，父类有时候也称为超类（super class）,子类有时候称为派生类。 继承的基本语法为：class子类extends父类 {} 继承的限制：1）在java中不允许多重继承，一个子类只能继承一个父类，不能继承多个父类；2）java中允许多层继承；3）在继承中子类不能访问父类中的私有成员，只能继...
java什么是继承_什么是java继承
weixin_39558754的博客
02-12 241
什么是java继承继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。(推荐教程：java教程 )比如可以先定义一个类叫车...
java什么是继承简答_Java继承知识点总结
weixin_42138545的博客
02-23 274
继承利用继承，人们可以基于已存在的类构造一个新类，继承已存在的类就是复用(继承)这些类的方法和域。在此基础上，还可以添加一下新的方法和域，以满足新的需求。覆盖方法简答的代码示例：public class Employee{private String name;private double salary;private LocalDate hireDay;public Employee(Strin...
Java---继承详解
fly的博客
06-16 6113
就是子类继承父类的和，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的的属性和行为。
简述Java中的继承
离名
01-25 1512
作为面向对象语言的四大核心特性之一，继承（inheritance）占据着举足轻重的地位，从一段代码开始： import java.util.*; /** * This program demonstrates inheritance. * @version 1.21 * @author LiMing */ public class ManagerTest { public st
java什么是继承_JAVA中什么是继承？
weixin_35223524的博客
02-12 2550
展开全部继承在本职上是32313133353236313431303231363533e78988e69d8331333366306435特殊一般的关系，即常说的is-a关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的 一些属性或方法。1.Java继承的语法格式:Java继承的关键字是：extendspublic class 子类名 extends 父类名{...}如： pub...
Java继承
weixin_44543324的博客
04-24 461
开发工具与关键技术：MyEclipse 10，Java基础知识 作者：丁晓娟 撰写时间：2019-4-22 继承（extends）：Java是一个单一继承的跨平台语言，一个类在现有类的基础上，对父类进行扩充，也就是子类继承父类的特征和行为，一个类只有一个直接父类，如果没有声明父类，则默认的父类为Object类。它们的关系是所属关系，也就是说当两个类之间存在这种关系的时候，才是具备了继承的关系。怎么...
Java继承详解
qq_45638342的博客
07-27 408
java继承
什么是继承？
dcujcivw769565的博客
02-14 150
一，继承是C#中面向对象的特性之一。 继承，简单一句话就是建立类之间的关系，实现代码的重用性，方便系统扩展。继承的两大特性是单根性和传递性。 1》继承的单根性：是指子类只能继承一个父类，不能同时继承多个父类。就好比儿子只能有一个父亲（亲生），派生类只能从一个类中继承，继承不支持多重继承。避免代码结构的复杂性。 2》派生类(子类)继承的共同基类(父类)可以让代码更简洁明了,可扩展性和...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

夏驰和徐策

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

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

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

打赏作者

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

抵扣说明：

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

余额充值