Java继承机制：让你的代码更高效、更有层次！

开篇语

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

你有没有想过，当我们写代码时，很多东西是可以被重复使用的，为什么我们要重复造轮子？这正是继承机制的核心思想，它让你能够复用已有的代码，减少冗余，提升开发效率。在面向对象编程（OOP）中，继承是最重要的特性之一，它让我们可以创建一个类，继承另一个类的属性和方法，从而达到代码复用和功能扩展的效果。

这篇文章，我们将详细探讨Java中的继承机制，涵盖如何使用extends关键字、方法重写、super关键字、Object类以及继承中的构造器调用。让我们一起从基础开始，深入理解继承是如何工作的，如何让它帮助我们编写更高效的代码。

1. extends关键字的使用：继承的基础

在Java中，继承是通过extends关键字来实现的。我们通过extends关键字让一个类继承另一个类的属性和方法，从而扩展现有的功能。这是面向对象编程的一个基本特性，能够让我们在不修改原始类的情况下，增加新的功能。

语法：

class SubClass extends SuperClass {
    // 子类可以拥有自己的属性和方法
}

示例：

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 从Animal类继承的方法
        dog.bark(); // Dog类自己的方法
    }
}

在这个例子中，Dog类通过extends关键字继承了Animal类，拥有了Animal类的eat方法，同时还可以自己定义其他方法（比如bark）。这就是继承的基本应用，它允许我们在子类中使用父类的方法和属性。

2. 方法重写（Override）：子类对父类方法的“重新定义”

继承使得子类可以继承父类的方法，但有时候，子类可能需要改变或扩展父类方法的行为，这时就需要使用方法重写（Override）。方法重写意味着子类可以定义自己的方法实现，替代从父类继承的实现。

语法：

@Override
void methodName() {
    // 子类重新定义父类方法的实现
}

示例：

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        
        animal.sound(); // 输出: Animal makes a sound
        dog.sound();    // 输出: Dog barks
    }
}

在这个例子中，Dog类重写了父类Animal的sound方法。当我们调用dog.sound()时，程序会调用子类Dog的实现，而不是父类Animal的实现。通过@Override注解，Java会在编译时检查是否正确重写了父类的方法，避免了由于拼写错误等问题导致的潜在错误。

3. super关键字：访问父类的成员

有时候，子类不仅需要重写父类的方法，还需要在子类的方法中调用父类的方法或构造函数。这时就需要使用super关键字。super关键字指代当前对象的父类，它可以用于调用父类的构造函数、方法或访问父类的属性。

super的使用场景：

1. 调用父类的构造函数：
   子类可以通过super()调用父类的构造函数，初始化继承自父类的属性。

2. 调用父类的方法：
   在子类中，如果需要调用被子类重写的父类方法，可以使用super。

3. 访问父类的属性：
   如果子类和父类有同名的属性，子类可以通过super来访问父类的属性。

示例：

class Animal {
    String name;
    
    Animal(String name) {
        this.name = name;
    }
    
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    
    Dog(String name) {
        super(name); // 调用父类的构造函数
    }
    
    void sound() {
        super.sound(); // 调用父类的方法
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        System.out.println(dog.name); // 输出：Buddy
        dog.sound(); // 输出：Animal makes a sound
                        //         Dog barks
    }
}

在这个例子中，super(name)调用了父类Animal的构造函数，初始化了name属性。super.sound()调用了父类的sound方法，确保父类的行为被保留，然后再执行子类自己的行为。

4. Object类详解：所有类的祖先

在Java中，每个类都直接或间接地继承自Object类。Object类是所有类的根类，它定义了所有Java类都具备的基本方法，比如toString()、equals()、hashCode()等。这些方法对于我们编程至关重要，因为它们提供了标准化的行为，帮助我们比较对象、打印对象信息等。

Object类常用方法：

1. toString()：
   toString()方法返回对象的字符串表示，默认返回类的名称和哈希码。我们通常会重写这个方法，以便返回对象的有意义的字符串描述。

2. equals()：
   equals()方法用于比较两个对象是否相等，默认是比较内存地址。如果需要根据对象的内容进行比较，我们通常会重写equals()方法。

3. hashCode()：
   hashCode()方法返回对象的哈希码，通常与equals()方法一起使用，确保相等的对象具有相同的哈希码。

示例：

class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal name: " + name;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Animal animal = (Animal) obj;
        return name.equals(animal.name);
    }
    
    @Override
    public int hashCode() {
        return name.hashCode();
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Animal("Buddy");
        Animal anotherDog = new Animal("Buddy");
        
        System.out.println(dog); // 输出：Animal name: Buddy
        System.out.println(dog.equals(anotherDog)); // 输出：true
        System.out.println(dog.hashCode() == anotherDog.hashCode()); // 输出：true
    }
}

在这个例子中，我们重写了toString()、equals()和hashCode()方法，使得Animal对象的比较和输出更加有意义。

5. 继承中的构造器调用

在继承中，子类的构造函数不会自动继承父类的构造函数，因此我们需要显式地调用父类的构造函数。在Java中，子类的构造函数默认会调用父类的无参构造函数。如果父类没有无参构造函数，子类必须显式调用父类的构造函数。

示例：

class Animal {
    Animal(String name) {
        System.out.println("Animal constructor: " + name);
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name); // 显式调用父类构造函数
        System.out.println("Dog constructor: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
    }
}

输出：

Animal constructor: Buddy
Dog constructor: Buddy

在这个例子中，Dog类的构造函数显式调用了super(name)，以确保父类Animal的构造函数被执行。这样，父类和子类的构造过程就能顺利进行。

结语：继承，让你的代码更简洁和灵活

通过继承，我们可以实现代码的复用、扩展和组织。继承不仅仅是让代码变得更短，更重要的是让代码变得更加有层次，结构更清晰。掌握了extends、方法重写、super关键字以及Object类，你就能够在开发中更灵活地使用继承，从而编写出高效、简洁的代码。

继承是面向对象编程中最强大的工具之一，它让你从已有的代码出发，不断扩展和改进。希望你能够在继承的世界中游刃有余，为自己和团队创造出更加优雅和高效的代码。

… …

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。
⭐️若有疑问，就请评论留言告诉我叭。

版权声明：本文由作者原创，转载请注明出处，谢谢支持！