作为一名对技术充满热情的学习者，我一直以来都深刻地体会到知识的广度和深度。在这个不断演变的数字时代，我远非专家，而是一位不断追求进步的旅行者。通过这篇博客，我想分享我在某个领域的学习经验，与大家共同探讨、共同成长。请大家以开放的心态阅读，相信你们也会在这段知识之旅中找到启示。
文章目录
- 前言
- 一、什么是继承
- 二、方法重写的概念和原则
- 三、super关键词
- 四、java实战案例
- 五、java简单面试题
- 面试问题：
- 总结
前言
当你想象一个生物类别，比如动物，其中有许多不同的种类，比如狗、猫、鸟等等。现在假设你想在程序中模拟这些动物，你可能会创建一个名为"动物"的类，其中包含一些通用属性和方法，比如“移动”、“发出声音”等等。
现在，如果你想创建一个代表狗的类，你可以使用继承来实现。你可以创建一个名为"狗"的类，这个类继承自"动物"类。通过继承，“狗"类会自动获得"动物"类的所有属性和方法，比如"移动"和"发出声音”。然后，你可以在"狗"类中添加特定于狗的属性和方法，比如"吠叫"和"追逐尾巴"。
这样，通过继承，你可以避免在每个动物类别中重复编写相同的代码，而是可以在更高级别的"动物"类中编写一次通用代码，然后在每个具体的类别（比如"狗"）中添加特定于该类别的行为和特征。
一、什么是继承
继承是面向对象编程中的一种机制，它允许一个类（称为子类或派生类）从另一个类（称为父类或基类）继承属性和方法。在继承中，子类可以访问并使用父类中定义的非私有属性和方法，同时还可以添加自己的新属性和方法。
通过继承，子类可以拥有父类的特征和行为，从而实现代码重用和层次化设计。这意味着子类可以利用父类的功能，同时可以在不改变父类的情况下进行定制或扩展。
继承提供了代码重用的重要方式，同时也促进了代码的组织和维护。通过使用继承，可以创建出层次化结构的类，使得代码更加易于理解和扩展。
在Java中，继承是面向对象编程的核心概念之一，它允许一个类（称为子类）从另一个类（称为父类）继承属性和方法。Java中的继承通过使用关键字
extends来实现。
下面是一个简单的示例，演示了如何在Java中使用继承：
// 定义父类 Animal
class Animal {
String species;
public Animal(String species) {
this.species = species;
}
public void makeSound() {
System.out.println("The animal makes a sound");
}
}
// 定义子类 Dog，继承自 Animal
class Dog extends Animal {
String breed;
public Dog(String species, String breed) {
super(species); // 调用父类的构造方法
this.breed = breed;
}
// 子类可以重写父类的方法
@Override
public void makeSound() {
System.out.println("The dog barks");
}
// 子类可以添加自己的方法
public void wagTail() {
System.out.println("The dog wags its tail");
}
}
public class Main {
public static void main(String[] args) {
// 创建 Dog 对象
Dog dog = new Dog("Canine", "Labrador");
// 访问从父类继承的属性和方法
System.out.println("Species: " + dog.species);
dog.makeSound();
// 调用子类特有的方法
dog.wagTail();
}
}
在这个示例中：
Animal类是父类，Dog类是子类。Dog类使用extends关键字继承了Animal类。- 子类
Dog重写了父类Animal的makeSound()方法，并添加了自己的方法wagTail()。 - 在
Main类中，创建了Dog对象，并展示了如何访问从父类继承的属性和方法，以及调用子类自己的方法。
通过继承，子类可以获得父类的特性和行为，并且可以进一步扩展和定制。
二、方法重写的概念和原则
方法重写（Method Overriding）是面向对象编程中的一个重要概念，它允许子类覆盖（重写）父类中已经定义的方法。在Java中，方法重写发生在子类中重新定义一个与父类中方法签名相同的方法的情况下。
方法重写原则的关键点包括：
-
方法签名相同：子类中重写的方法必须与父类中被重写的方法具有相同的方法签名，包括方法名称、参数列表以及返回类型。方法签名不同的话，编译器将认为你在子类中创建了一个新的方法，而不是重写父类中的方法。
-
访问修饰符不能降低：在子类中重写的方法的访问修饰符不能比父类中被重写的方法的访问修饰符更低，可以是相同的或更高的访问修饰符。比如，如果父类中的方法是
public，那么子类中的方法可以是public或者protected，但不能是private。 -
返回类型要兼容：子类中重写的方法的返回类型必须是与父类中被重写方法的返回类型兼容的类型。这意味着如果父类方法返回一个特定类型，那么子类方法可以返回该类型或其子类型。如果父类方法返回
void，则子类方法必须返回void。 -
抛出的异常要小于等于父类方法的异常：子类中重写的方法可以不抛出任何异常，或者只抛出父类方法抛出异常的子集，不能抛出新的、更广泛的异常。
方法重写的目的在于子类能够定制和提供自己的实现，而不改变原有的方法签名。这样的灵活性让子类能够根据需要修改父类的行为，同时保持了多态性的特性，即在运行时，根据对象的实际类型来调用相应的方法实现。
三、super关键词
在Java中，super 是一个关键字，它具有多种用途，但最常见的用法是在子类中访问父类的属性、方法或构造方法。super 关键字的使用可以使得子类能够与父类进行交互，并调用父类的成员或构造方法。
super 关键字主要有以下两种用法：
-
访问父类的属性和方法： 在子类中使用
super关键字可以访问父类中的属性和方法。这在子类中重写父类方法时特别有用，可以在子类方法中调用父类方法的实现。 -
调用父类的构造方法： 在子类的构造方法中使用
super()可以调用父类的构造方法。这使得在子类构造对象时可以首先执行父类的初始化操作，确保父类中的属性得到正确的初始化。
下面是一个示例说明 super 关键字的使用：
// 父类 Animal
class Animal {
String species;
public Animal(String species) {
this.species = species;
}
public void makeSound() {
System.out.println("The animal makes a sound");
}
}
// 子类 Dog，继承自 Animal
class Dog extends Animal {
String breed;
public Dog(String species, String breed) {
super(species); // 调用父类的构造方法
this.breed = breed;
}
@Override
public void makeSound() {
super.makeSound(); // 调用父类的 makeSound 方法
System.out.println("The dog barks");
}
}
public class Main {
public static void main(String[] args) {
// 创建 Dog 对象
Dog dog = new Dog("Canine", "Labrador");
// 访问从父类继承的属性和方法
System.out.println("Species: " + dog.species);
dog.makeSound();
}
}
在这个示例中，Dog 类调用了父类 Animal 的构造方法 super(species) 来初始化 species 属性，并在重写的 makeSound() 方法中使用 super.makeSound() 调用了父类的 makeSound() 方法。
四、java实战案例
一个常见的Java继承案例是在图形用户界面（GUI）开发中。让我们以一个简单的图形界面按钮为例来说明。
在GUI开发中，通常会有各种类型的组件，比如按钮、文本框、标签等等。这些组件之间通常会有一些共同的特征和行为，比如它们都能够被点击、显示文本等。因此，可以创建一个通用的父类来表示这些共同的特征和行为，然后让各个组件的类继承这个父类，以便重用代码并确保统一的接口。
下面是一个简化的示例：
// 父类 Component
class Component {
private String text;
public Component(String text) {
this.text = text;
}
public void display() {
System.out.println("Displaying component with text: " + text);
}
public void onClick() {
System.out.println("Component clicked");
}
}
// 子类 Button，继承自 Component
class Button extends Component {
public Button(String text) {
super(text);
}
// Button 类可以添加自己的方法
public void press() {
System.out.println("Button pressed");
}
}
public class Main {
public static void main(String[] args) {
// 创建一个按钮对象
Button button = new Button("Click me");
// 使用从父类继承的方法
button.display();
button.onClick();
// 调用子类自己的方法
button.press();
}
}
在这个示例中：
Component类是父类，表示GUI组件的共同特征和行为，比如显示和点击。Button类是子类，继承自Component类。它继承了Component类的display()和onClick()方法，并且添加了自己的方法press()，用于表示按钮被按下的动作。- 在
Main类中，创建了一个Button对象，并展示了如何使用从父类继承的方法，以及调用子类自己的方法。
通过继承，我们可以实现代码的重用，同时也可以通过子类来扩展和定制父类的行为。在GUI开发中，这种继承的机制可以帮助开发者更有效地组织和管理UI组件，从而提高开发效率和代码的可维护性。
五、java简单面试题
面试问题：
问题： 什么是Java中的继承？请解释继承的概念，并举例说明。
答案：
在Java中，继承是一种面向对象编程的机制，它允许一个类（称为子类或派生类）从另一个类（称为父类或基类）继承属性和方法。子类可以使用父类中已经定义的属性和方法，同时还可以添加自己的新属性和方法。
继承的核心思想是通过建立类之间的层次结构，使得子类可以从父类继承通用的行为和特征，并且可以在此基础上进行定制和扩展。
示例：
// 父类 Animal
class Animal {
String species;
public Animal(String species) {
this.species = species;
}
public void makeSound() {
System.out.println("The animal makes a sound");
}
}
// 子类 Dog，继承自 Animal
class Dog extends Animal {
String breed;
public Dog(String species, String breed) {
super(species); // 调用父类的构造方法
this.breed = breed;
}
@Override
public void makeSound() {
System.out.println("The dog barks");
}
public void wagTail() {
System.out.println("The dog wags its tail");
}
}
public class Main {
public static void main(String[] args) {
// 创建 Dog 对象
Dog dog = new Dog("Canine", "Labrador");
// 访问从父类继承的属性和方法
System.out.println("Species: " + dog.species);
dog.makeSound();
// 调用子类特有的方法
dog.wagTail();
}
}
在这个示例中，Dog 类继承了 Animal 类，从而获得了 species 属性和 makeSound() 方法，并且在此基础上添加了自己的 breed 属性和 wagTail() 方法。
总结
感谢大家抽出宝贵的时间来阅读博主的博客,新人博主,感谢大家关注点赞,祝大家未来的学习工作生活一帆风顺,加油!!!
