• 菜鸟Java面向对象 1. Java继承

    1. Java继承

    Java继承

    1. 继承的概念_简单介绍继承的用处

    继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

    继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

    继承是面向对象编程中的一个重要概念，它允许在现有类的基础上创建新的类，并且新的类可以继承现有类的属性和方法，同时可以添加新的属性和方法，或者修改继承的方法的行为。

    在Java中，继承通过使用关键字 extends 来实现。子类可以继承父类的非私有成员（属性和方法），这样就可以重用已有的代码，同时也可以实现代码的扩展和重构。继承还可以形成类之间的层次关系，使得代码更加清晰、易于维护和扩展。

    继承的核心概念包括：

    1. 父类（基类、超类）：已存在的类，被继承的类。
    2. 子类（派生类）：基于父类创建的新类，继承了父类的属性和方法。
    3. 继承关系：子类可以访问父类的公有成员，但不能直接访问私有成员。子类可以添加新的成员或者重写父类的方法。

    通过继承，可以实现代码的重用和扩展，提高代码的可维护性和可扩展性。同时，继承也是面向对象编程的核心特征之一，它使得程序设计更加灵活和高效。

    生活中的继承：

    兔子和羊属于食草动物类，狮子和豹属于食肉动物类。

    食草动物和食肉动物又是属于动物类。

    所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

    虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

    2. 类的继承格式

    在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

    类的继承格式

    class 父类 {
} 
class 子类 extends 父类 {
}

    • 1
    • 2
    • 3
    • 4

    简单示例：

    class Animal {
    String species;
    
    public void eat() {
        System.out.println("The animal is eating.");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("The dog is barking.");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    在这个例子中，Animal 类是父类，Dog 类是子类，Dog 类继承了 Animal 类的属性和方法。

    3. 为什么需要继承

    接下来我们通过实例来说明这个需求。

    开发动物类，其中动物分别为企鹅以及老鼠，要求如下：

    - 企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
- 老鼠：属性（姓名，id），方法（吃，睡，自我介绍）

    • 1
    • 2

    企鹅类：

    /**
 * Penguin（企鹅）类表示一个拥有姓名和ID的企鹅。
 */
public class Penguin {
    // 企鹅的姓名
    private String name;
    
    // 企鹅的ID
    private int id;
    
    /**
     * 构造一个具有指定姓名和ID的企鹅对象。
     * 
     * @param myName 企鹅的姓名。
     * @param myid 企鹅的ID。
     */
    public Penguin(String myName, int myid) {
        name = myName;
        id = myid;
    }
    
    /**
     * 模拟企鹅进食。
     */
    public void eat() {
        System.out.println(name + "正在吃");
    }
    
    /**
     * 模拟企鹅睡眠。
     */
    public void sleep() {
        System.out.println(name + "正在睡");
    }
    
    /**
     * 介绍这只企鹅。
     */
    public void introduction() {
        System.out.println("大家好！我是" + id + "号" + name + ".");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    老鼠类：

    /**
 * Mouse（老鼠）类表示一个拥有姓名和ID的老鼠。
 */
public class Mouse {
    // 老鼠的姓名
    private String name;
    
    // 老鼠的ID
    private int id;
    
    /**
     * 构造一个具有指定姓名和ID的老鼠对象。
     * 
     * @param myName 老鼠的姓名。
     * @param myid 老鼠的ID。
     */
    public Mouse(String myName, int myid) {
        name = myName;
        id = myid;
    }
    
    /**
     * 模拟老鼠进食。
     */
    public void eat() {
        System.out.println(name + "正在吃");
    }
    
    /**
     * 模拟老鼠睡眠。
     */
    public void sleep() {
        System.out.println(name + "正在睡");
    }
    
    /**
     * 介绍这只老鼠。
     */
    public void introduction() {
        System.out.println("大家好！我是" + id + "号" + name + ".");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    从这两段代码可以看出，代码存在重复，导致代码量大且臃肿，而且维护性不高(主要表现是后期需要修改的时候，需要修改很多的代码，容易出错)。要从根本上解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成 一个父类：

    公共父类：

    /**
 * Animal（动物）类表示一个拥有姓名和ID的动物。
 */
public class Animal {
    // 动物的姓名
    private String name;
    
    // 动物的ID
    private int id;
    
    /**
     * 构造一个具有指定姓名和ID的动物对象。
     * 
     * @param myName 动物的姓名。
     * @param myid 动物的ID。
     */
    public Animal(String myName, int myid) {
        name = myName;
        id = myid;
    }
    
    /**
     * 模拟动物进食。
     */
    public void eat() {
        System.out.println(name + "正在吃");
    }
    
    /**
     * 模拟动物睡眠。
     */
    public void sleep() {
        System.out.println(name + "正在睡");
    }
    
    /**
     * 介绍这只动物。
     */
    public void introduction() {
        System.out.println("大家好！我是" + id + "号" + name + ".");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：

    企鹅类：

    /**
 * Penguin（企鹅）类是 Animal 类的子类，表示一个拥有姓名和ID的企鹅。
 */
public class Penguin extends Animal {
    /**
     * 构造一个具有指定姓名和ID的企鹅对象。
     * 
     * @param myName 企鹅的姓名。
     * @param myid 企鹅的ID。
     */
    public Penguin(String myName, int myid) {
        // 调用父类 Animal 的构造方法
        super(myName, myid);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    老鼠类：

    /**
 * Mouse（老鼠）类是 Animal 类的子类，表示一个拥有姓名和ID的老鼠。
 */
public class Mouse extends Animal {
    /**
     * 构造一个具有指定姓名和ID的老鼠对象。
     * 
     * @param myName 老鼠的姓名。
     * @param myid 老鼠的ID。
     */
    public Mouse(String myName, int myid) {
        // 调用父类 Animal 的构造方法
        super(myName, myid);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    4. 继承类型_多重继承

    需要注意的是 Java 不支持多继承，但支持多重继承。

    5. 继承的特性

    • 子类拥有父类非 private 的属性、方法。

    • 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

    • 子类可以用自己的方式实现父类的方法。

    • Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

    • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

    继承的几个重要特性：

    1. 子类拥有父类非 private 的属性、方法：

    这是继承的基本特性，子类可以访问父类中非私有的属性和方法。

    2. 子类可以拥有自己的属性和方法：

    继承不仅仅意味着子类可以继承父类的属性和方法，还可以在子类中添加新的属性和方法，从而实现对父类的扩展。

    3. 子类可以用自己的方式实现父类的方法：

    子类可以重写（override）父类的方法，以实现自己特定的行为，这样可以在不改变原有接口的情况下定制化功能。

    1. Java 的继承是单继承，但可以多重继承： Java 中一个类只能直接继承一个父类，但是可以通过多级继承实现多重继承的效果。这与C++不同，C++允许直接多重继承。

    2. 提高了类之间的耦合性： 继承可以提高类之间的关联性，但也会增加耦合性，使得代码更加紧密地联系在一起，降低了独立性。这是继承的一个缺点，需要谨慎使用。

    继承是面向对象编程中非常重要的概念，合理地使用继承可以使代码更加模块化、可扩展和易于维护。

    6. 继承关键字

    继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承 Object（这个类在 java.lang 包中，所以不需要 import）祖先类。

    extends关键字

    在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

    //extend 关键字
/**
 * Animal（动物）类表示一个拥有姓名和ID的动物。
 */
public class Animal {
    // 动物的姓名
    private String name;
    
    // 动物的ID
    private int id;
    
    /**
     * 构造一个具有指定姓名和ID的动物对象。
     * 
     * @param myName 动物的姓名。
     * @param myid 动物的ID。
     */
    public Animal(String myName, int myid) {
        // 初始化属性值
    }
    
    /**
     * 模拟动物进食。
     */
    public void eat() {
        // 吃东西方法的具体实现
    }
    
    /**
     * 模拟动物睡眠。
     */
    public void sleep() {
        // 睡觉方法的具体实现
    }
}

/**
 * Penguin（企鹅）类继承自 Animal 类。
 */
public class Penguin extends Animal {
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    implements关键字

    使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

    /**
 * A 接口定义了 eat() 和 sleep() 方法。
 */
public interface A {
    /**
     * 吃的行为。
     */
    public void eat();
    
    /**
     * 睡觉的行为。
     */
    public void sleep();
}

/**
 * B 接口定义了 show() 方法。
 */
public interface B {
    /**
     * 展示的行为。
     */
    public void show();
}

/**
 * C 类实现了 A 接口和 B 接口。
 */
public class C implements A, B {
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    super 与 this 关键字

    super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

    this关键字：指向自己的引用。

    class Animal { void eat() { System.out.println("animal : eat"); } } class Dog extends Animal { void eat() { System.out.println("dog : eat"); } void eatTest() { this.eat(); // this 调用自己的方法 super.eat(); // super 调用父类方法 } } public class Test { public static void main(String[] args) { Animal a = new Animal(); a.eat(); Dog d = new Dog(); d.eatTest(); } }

    • 1

    输出结果为：

    animal : eat
dog : eat
animal : eat

    • 1
    • 2
    • 3

    final 关键字

    final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

    final 含义为 “最终的”。

    使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：

    • 声明类：

    final class 类名 {//类体}

    • 声明方法：

    修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

    注： final 定义的类，其中的属性、方法不是 final 的。

    7. 构造器

    子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

    如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

    实例

    /**
 * SuperClass 类表示一个超类，具有一个私有整型属性 n。
 */
class SuperClass {
    private int n;
    
    /**
     * 构造一个无参数的 SuperClass 对象。
     */
    SuperClass(){
        System.out.println("SuperClass()");
    }
    
    /**
     * 构造一个带有参数的 SuperClass 对象。
     * 
     * @param n 初始化的整数值。
     */
    SuperClass(int n) {
        System.out.println("SuperClass(int n)");
        this.n = n;
    }
}

/**
 * SubClass 类继承自 SuperClass 类，表示一个子类。
 */
class SubClass extends SuperClass{
    private int n;
    
    /**
     * 构造一个无参数的 SubClass 对象。
     */
    SubClass(){
        // 自动调用父类的无参数构造器
        System.out.println("SubClass");
    }  
    
    /**
     * 构造一个带有参数的 SubClass 对象。
     * 
     * @param n 初始化的整数值。
     */
    public SubClass(int n){ 
        // 调用父类中带有参数的构造器
        super(300);  
        System.out.println("SubClass(int n):"+n);
        this.n = n;
    }
}

/**
 * SubClass2 类继承自 SuperClass 类，表示另一个子类。
 */
class SubClass2 extends SuperClass{
    private int n;
    
    /**
     * 构造一个无参数的 SubClass2 对象。
     */
    SubClass2(){
        // 调用父类中带有参数的构造器
        super(300);  
        System.out.println("SubClass2");
    }  
    
    /**
     * 构造一个带有参数的 SubClass2 对象。
     * 
     * @param n 初始化的整数值。
     */
    public SubClass2(int n){ 
        // 自动调用父类的无参数构造器
        System.out.println("SubClass2(int n):"+n);
        this.n = n;
    }
}

/**
 * TestSuperSub 类用于测试 SuperClass、SubClass 和 SubClass2 类。
 */
public class TestSuperSub{
    public static void main (String args[]){
        System.out.println("------SubClass 类继承------");
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass(100); 
        
        System.out.println("------SubClass2 类继承------");
        SubClass2 sc3 = new SubClass2();
        SubClass2 sc4 = new SubClass2(200); 
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93

    输出结果为：

    ------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    8. 总结

    这一章学习了

    1. 继承的概念和用处

    • 继承是面向对象编程的基石，允许创建分层次的类，实现代码的重用和扩展。
    • 通过继承，子类可以继承父类的属性和方法，同时可以添加新的属性和方法，或者重写父类的方法。
    • 继承形成类之间的层次关系，使得代码更加清晰、易于维护和扩展。

    2. 类的继承格式

    • 在Java中，使用extends关键字来实现继承。
    • 子类可以继承父类的非私有成员，形成类的层次关系。

    3. 为什么需要继承

    • 继承可以减少代码的重复，提高代码的复用性和可维护性。
    • 通过继承，可以构建类之间的层次关系，使代码更加清晰和易于理解。

    4. 继承类型

    • Java支持单继承和多重继承，通过extends关键字实现单继承，通过implements关键字实现多重继承。

    5. 继承的特性

    • 子类拥有父类的非私有属性和方法。
    • 子类可以拥有自己的属性和方法，同时可以重写父类的方法。
    • Java的继承是单继承，但支持多重继承。
    • 继承提高了类之间的耦合性，需要注意降低耦合度。

    6. 继承关键字

    • 使用extends关键字实现类的继承。
    • 使用implements关键字实现接口的继承。
    • 使用super关键字调用父类的构造方法。

    7. 构造器

    • 子类不继承父类的构造器，但可以通过super关键字调用父类的构造器。
    • 如果父类构造器带有参数，子类必须显式地调用父类构造器并传递参数。
  • 相关阅读:
    【PlasticSCM Could Edition】新版本云托管浅试2
    超硬核，拒绝内卷全靠阿里大能整理的这份 Java 核心手册，堪称强无敌，谁来不说一声牛 AC
    二十八、java版 SpringCloud分布式微服务云架构之Java 包(package)
    0基础学习PyFlink——用户自定义函数之UDTAF
    单片机学习记录
    8 路数字量输入兼容干接点、湿节点多功能RTU
    Zookeeper经典应用场景实战（一）
    [创业-46]：中小公司的组织架构与公司管理
    【skynet】skynet消息处理与协程
    MySql数据库允许外网访问连接
  • 原文地址：https://blog.csdn.net/m0_46211715/article/details/138123254