继承与多态：面向对象编程的核心力量！

开篇语

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

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

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

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

前言

  想要成为一名熟练的面向对象编程（OOP）开发者，继承与多态是你必须掌握的两个基石。它们不仅能够帮助你写出更简洁、灵活的代码，还能使你的程序更具扩展性和可维护性。在今天的讨论中，我们将一起深入理解继承的概念与应用，如何利用多态提升代码的灵活性，以及一些常见的关键词和技巧，包括 super、extends，以及向上转型与向下转型。

一、继承的概念与 extends 关键字

  继承是面向对象编程的核心特性之一。通过继承，子类可以获取父类的属性和方法，这样我们可以在不重复代码的前提下，扩展现有类的功能。继承实现了代码的复用，是创建层次结构的一种方式。

1.1 继承的基本概念

在 Java 中，子类通过 extends 关键字继承父类。例如，如果你有一个父类 Animal，你可以创建一个 Dog 类来继承 Animal，并且可以直接使用 Animal 类中的方法和属性。

代码示例：继承与 extends 关键字

// 父类 Animal
class Animal {
    String name;

    public void speak() {
        System.out.println(name + " makes a sound.");
    }
}

// 子类 Dog
class Dog extends Animal {
    // 子类特有的属性
    String breed;

    // 子类特有的方法
    public void wagTail() {
        System.out.println(name + " is wagging its tail.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.breed = "Golden Retriever";

        dog.speak();    // 继承父类的方法
        dog.wagTail();  // 子类的方法
    }
}

  在这个例子中，Dog 类通过 extends Animal 继承了 Animal 类的属性和方法。在 main 方法中，我们创建了一个 Dog 类的对象，它不仅能使用 Dog 类的 wagTail() 方法，还能调用继承自 Animal 类的 speak() 方法。

1.2 继承的特点

• 代码复用：子类继承父类后，可以直接使用父类的字段和方法，避免了重复代码。
• 父类与子类的关系：父类称为“超类”或“基类”，子类称为“派生类”或“子类”。
• 单继承：Java 不支持多继承，一个类只能继承一个父类。但子类可以通过接口实现多继承的效果。

二、方法的重写（Override）与多态的实现

  方法重写和多态是面向对象编程的关键技术。通过方法重写，子类可以修改从父类继承而来的方法，以便符合子类的需求。而多态允许不同的对象以相同的方式调用相同的方法，展示不同的行为。

2.1 方法重写（Override）

方法重写是指在子类中重新定义父类已经存在的方法。通过方法重写，子类可以根据自己的需要修改方法的实现。

代码示例：方法重写

// 父类 Animal
class Animal {
    public void speak() {
        System.out.println("Animal makes a sound.");
    }
}

// 子类 Dog
class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks.");
    }
}

// 子类 Cat
class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("Cat meows.");
    }
}

public class MethodOverrideExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dog = new Dog();
        Animal cat = new Cat();

        animal.speak();  // 父类的方法
        dog.speak();     // 子类 Dog 重写后的方法
        cat.speak();     // 子类 Cat 重写后的方法
    }
}

  在这个例子中，Dog 和 Cat 都重写了 Animal 类的 speak() 方法。尽管我们在 main 方法中都是通过 Animal 类型的引用来调用 speak() 方法，但程序运行时会根据实际对象的类型调用相应的 speak() 方法，这就是多态的体现。

2.2 多态的实现

多态是指同一操作作用于不同的对象时，可以产生不同的结果。在 Java 中，多态的实现依赖于方法重写。通过向上转型和向下转型，我们可以在父类和子类之间灵活切换，使用相同的方法进行不同的操作。

代码示例：多态实现

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型
        animal.speak();  // 调用 Dog 类的 speak() 方法

        animal = new Cat();  // 向上转型
        animal.speak();  // 调用 Cat 类的 speak() 方法
    }
}

  在这个例子中，我们通过父类 Animal 的引用，指向了子类 Dog 和 Cat 的对象。这就是向上转型，即父类引用指向子类对象。多态的效果是，在运行时根据实际对象的类型（Dog 或 Cat）来调用相应的 speak() 方法。

三、super 关键字的使用

  super 关键字在 Java 中有两种主要用途：

1. 调用父类的构造方法。
2. 访问父类的属性和方法，尤其是当子类覆盖了父类的方法时，可以通过 super 来访问父类的版本。

3.1 调用父类的构造方法

当子类需要调用父类的构造方法时，可以使用 super()。如果父类有无参构造方法，super() 可以自动调用。如果父类没有无参构造方法，则需要在子类的构造方法中显式调用父类的构造方法。

代码示例：super 调用父类构造方法

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 SuperConstructorExample {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
    }
}

  这里，我们通过 super(name) 调用了父类 Animal 的构造方法。

3.2 访问父类的属性和方法

如果子类重写了父类的方法，使用 super 关键字可以调用父类的原始方法。

代码示例：super 访问父类的方法

class Animal {
    public void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    @Override
    public void speak() {
        super.speak();  // 调用父类的 speak 方法
        System.out.println("Dog barks");
    }
}

public class SuperMethodExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.speak();
    }
}

  在这个例子中，Dog 类重写了 speak() 方法，但在重写的方法中使用 super.speak() 来调用父类 Animal 的 speak() 方法。

四、向上转型与向下转型

  向上转型（Upcasting）是指将子类对象赋值给父类引用。向下转型（Downcasting）是将父类引用强制转换为子类类型。虽然向上转型不需要显式的转换，向下转型则需要显式的类型转换，并且需要注意类型安全。

4.1 向上转型

向上转型是将子类对象赋给父类引用。这是安全的，因为子类是父类的一种扩展，任何子类的对象都是父类类型。

代码示例：向上转型

Animal animal = new Dog();  // 向上转型
animal.speak();  // 调用 Dog 类的 speak() 方法

4.2 向下转型

向下转型是将父类引用强制转换为子类类型。这种转换必须在运行时确保对象的类型确实是目标子类，否则会抛出 ClassCastException。

代码示例：向下转型

Animal animal = new Dog();  // 向上转型
Dog dog = (Dog) animal;  // 向下转型
dog.wagTail();  // 调用 Dog 类特有的方法

  需要注意，向下转型时，如果 animal 不是 Dog 类型，会抛出 ClassCastException。因此，在执行向下转型之前，通常需要使用 instanceof 操作符进行类型检查。

总结：继承与多态，让编程更灵活

  通过继承和多态，Java 提供了一种强大的面向对象编程能力。继承让你能够复用代码，扩展类的功能；而多态让你能够以相同的方式操作不同类型的对象，增强了代码的灵活性和扩展性。同时，super 关键字帮助你调用父类的构造方法和方法，而向上转型与向下转型则让你能够在父类和子类之间灵活切换。

  掌握了这些基础概念，你的代码将更加简洁、灵活，面向对象编程的力量将帮助你构建出更加优雅和高效的程序！

… …

文末

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

… …

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

wished for you successed ！！！

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

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

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