继承在java中通过extends关键字实现，是面向对象编程的重要特性之一。1. 继承允许子类继承父类的非私有成员，形成“is-a”关系；2. 使用extends声明子类，语法为class childclass extends parentclass；3. 子类可重写父类方法，保持方法签名一致并使用@override注解；4. super关键字用于调用父类构造方法或访问父类成员；5. 继承具有单继承、访问权限限制及final类/方法不可继承等约束。继承的优点包括代码重用、结构清晰和便于扩展，但也可能导致紧耦合和维护复杂性。合理使用继承应基于“is-a”关系，并结合组合、接口和抽象类等机制优化设计。
extends 在 Java 中用于实现类的继承，允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码重用和扩展。理解 extends 的关键在于掌握继承的核心概念，包括父类、子类、方法重写、super 关键字以及继承的限制。
继承extends的5个核心知识点
什么是继承？
立即学习“Java免费学习笔记（深入）”；
继承是面向对象编程的三大特性之一（封装、继承、多态）。它允许我们创建一个新类（子类），从已存在的类（父类或超类）那里获得属性和方法。子类可以继承父类的所有非私有成员，并且可以添加新的成员或修改继承的成员。这是一种“is-a”关系，例如，Dog 类继承 Animal 类，表示 Dog 是一种 Animal。
如何使用 extends 关键字？
在 Java 中，使用 extends 关键字来声明一个类继承另一个类。语法如下：
class ParentClass {
// 父类的属性和方法
}
class ChildClass extends ParentClass {
// 子类可以添加自己的属性和方法，也可以重写父类的方法
}例如：
class Animal {
String name;
public void eat() {
System.out.println("Animal is eating");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("Dog is barking");
}
}
public class Main {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.name = "Buddy"; // 继承自 Animal 类
myDog.eat(); // 继承自 Animal 类
myDog.bark(); // Dog 类自己的方法
}
}方法重写（Override）
子类可以重写（override）父类的方法，提供自己的实现。方法重写必须保持方法签名（方法名、参数列表、返回类型）一致，但可以修改方法体。使用 @Override 注解可以帮助检查是否正确重写了方法。
class Animal {
public void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal();
Cat myCat = new Cat();
myAnimal.makeSound(); // 输出：Animal makes a sound
myCat.makeSound(); // 输出：Cat meows
}
}super 关键字
super 关键字用于在子类中调用父类的构造方法、方法或访问父类的成员变量。
-
调用父类构造方法：
super()必须是子类构造方法的第一行代码。class Animal { String name; Animal(String name) { this.name = name; } } class Dog extends Animal { String breed; Dog(String name, String breed) { super(name); // 调用父类的构造方法 this.breed = breed; } } -
调用父类方法：
super.methodName()调用父类中被重写的方法。class Animal { public void eat() { System.out.println("Animal is eating"); } } class Dog extends Animal { @Override public void eat() { super.eat(); // 调用父类的 eat() 方法 System.out.println("Dog is eating bones"); } }
继承的限制
- 单继承： Java 只支持单继承，一个类只能继承一个父类。
-
构造方法： 父类的构造方法不会被子类继承，但子类可以通过
super()显式调用父类的构造方法。 -
访问权限： 子类只能访问父类中
public和protected的成员。private成员无法被子类直接访问。 -
final类：final类不能被继承。 -
final方法：final方法不能被子类重写。
继承的优点和缺点有哪些？
继承的主要优点是代码重用，减少了代码冗余，提高了开发效率。它也使得代码结构更清晰，易于维护和扩展。通过继承，可以更容易地实现多态性。
然而，继承也有一些缺点。过度使用继承可能导致类之间的紧耦合，降低代码的灵活性。当父类发生变化时，所有子类都可能受到影响。此外，Java 的单继承限制有时会使得设计变得复杂。
什么时候应该使用继承？
当两个类之间存在“is-a”关系时，应该考虑使用继承。例如，Car 类和 Vehicle 类，Car 是一种 Vehicle，因此 Car 类可以继承 Vehicle 类。
另外，当多个类具有相似的属性和方法时，可以将这些共同的属性和方法提取到父类中，然后让子类继承父类，从而减少代码冗余。
但是，应该避免过度使用继承。如果两个类之间仅仅是具有一些相似的属性和方法，而没有明显的“is-a”关系，那么应该考虑使用组合（Composition）而不是继承。组合是一种“has-a”关系，它通过将一个类的实例作为另一个类的成员变量来实现代码重用。
如何避免继承的陷阱？
为了避免继承的陷阱，应该遵循以下原则：
- 谨慎使用继承： 只有在确实存在“is-a”关系时才使用继承。
- 保持父类稳定： 尽量避免修改父类的接口，以免影响子类。
- 使用组合代替继承： 当两个类之间仅仅是具有一些相似的属性和方法时，可以考虑使用组合。
- 遵循 Liskov 替换原则： 子类应该能够替换父类，并且程序的行为不会发生改变。
继承和接口有什么区别？
继承和接口都是实现多态性的重要手段，但它们之间存在一些关键区别：
- 继承： 一个类只能继承一个父类（单继承）。子类继承父类的属性和方法，包括实现和声明。
- 接口： 一个类可以实现多个接口（多实现）。接口只包含方法的声明，不包含实现。实现接口的类必须提供接口中所有方法的实现。
选择使用继承还是接口取决于具体的需求。如果需要代码重用，并且类之间存在“is-a”关系，那么应该使用继承。如果只需要定义一组规范，而不需要代码重用，那么应该使用接口。
如何使用抽象类？
抽象类是一种特殊的类，它不能被实例化。抽象类可以包含抽象方法和非抽象方法。抽象方法是没有实现的方法，必须在子类中被重写。
使用 abstract 关键字来声明抽象类和抽象方法。
abstract class Animal {
abstract public void makeSound(); // 抽象方法
public void eat() {
System.out.println("Animal is eating");
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
// Animal myAnimal = new Animal(); // 错误：抽象类不能被实例化
Dog myDog = new Dog();
myDog.makeSound(); // 输出：Dog barks
myDog.eat(); // 输出：Animal is eating
}
}抽象类通常用于定义一组相关的类的通用行为。例如，可以定义一个 Animal 抽象类，包含 makeSound() 抽象方法，然后让 Dog、Cat 等子类继承 Animal 类，并实现 makeSound() 方法。
