什么是继承？
继承是面向对象编程 (oop) 的基本支柱之一，它允许类（称为 子类 或 子类）从另一个类继承属性和方法（类调用父类或超类）。这个概念促进了代码重用和类层次结构的创建。
为什么要使用继承？
继承用于：
- 代码重用：允许子类重用超类的方法和属性，减少代码重复。
- 组织和结构：促进将类组织成逻辑层次结构，表示“is-a”关系。
- 可扩展性：可以轻松地向系统添加新功能，而无需更改现有代码。
继承如何运作？
在java中，继承是使用extends关键字来实现的。子类继承了超类的所有方法和属性，也可以添加自己的方法和属性或者覆盖现有的。
继承的例子
让我们创建一个简单的示例，使用名为 animal 的基类和两个名为 dog 和 cat 的子类来演示继承的概念。
// superclasse
public class animal {
// atributo comum a todos os animais
private string nome;
// construtor
public animal(string nome) {
this.nome = nome;
}
// método comum a todos os animais
public void fazersom() {
system.out.println("o animal faz um som.");
}
// getter para o nome
public string getnome() {
return nome;
}
}
// subclasse cachorro
public class cachorro extends animal {
// construtor da subclasse
public cachorro(string nome) {
super(nome); // chama o construtor da superclasse
}
// sobrescrevendo o método fazersom
@override
public void fazersom() {
system.out.println(getnome() + " faz au au.");
}
}
// subclasse gato
public class gato extends animal {
// construtor da subclasse
public gato(string nome) {
super(nome); // chama o construtor da superclasse
}
// sobrescrevendo o método fazersom
@override
public void fazersom() {
system.out.println(getnome() + " faz miau.");
}
}
使用类
public class main {
public static void main(string[] args) {
// criando instâncias de cachorro e gato
cachorro cachorro = new cachorro("rex");
gato gato = new gato("miau");
// chamando o método fazersom
cachorro.fazersom(); // saída: rex faz au au.
gato.fazersom(); // saída: miau faz miau.
}
}
预期输出：
rex faz au au. miau faz miau.
什么是抽象类？
抽象类是一种特殊类型的类，不能直接实例化。它们作为其他类的基础，可以包含抽象方法（没有实现的方法）和具体方法（有实现）。抽象类的主要目的是为其子类提供通用的结构，子类必须实现抽象方法。
抽象类如何工作？
在java中，要声明抽象类，我们使用abstract关键字。在抽象类中声明为抽象的方法没有主体，必须在子类中实现。
抽象类示例
让我们修改前面的示例以包含一个名为 animalabstrato 的抽象类：
// classe abstrata
public abstract class animalabstrato {
private string nome;
public animalabstrato(string nome) {
this.nome = nome;
}
// método abstrato
public abstract void fazersom();
// getter para o nome
public string getnome() {
return nome;
}
}
// subclasse cachorro que herda de animalabstrato
public class cachorro extends animalabstrato {
public cachorro(string nome) {
super(nome); // chama o construtor da superclasse
}
// implementando o método fazersom
@override
public void fazersom() {
system.out.println(getnome() + " faz au au.");
}
}
// subclasse gato que herda de animalabstrato
public class gato extends animalabstrato {
public gato(string nome) {
super(nome); // chama o construtor da superclasse
}
// implementando o método fazersom
@override
public void fazersom() {
system.out.println(getnome() + " faz miau.");
}
}
使用抽象类
public class main {
public static void main(string[] args) {
// criando instâncias de cachorro e gato
animalabstrato cachorro = new cachorro("rex");
animalabstrato gato = new gato("miau");
// chamando o método fazersom
cachorro.fazersom(); // saída: rex faz au au.
gato.fazersom(); // saída: miau faz miau.
}
}
预期输出：
rex faz au au. miau faz miau.
超类的继承问题
1. 子类和超类之间的强依赖
当一个类继承另一个类时，它会在子类和超类之间创建直接依赖关系。这意味着对超类的任何更改都会影响所有子类，这会使代码难以维护。
例子：
public class animal {
public void mover() {
system.out.println("o animal está se movendo.");
}
}
public class peixe extends animal {
@override
public void mover() {
system.out.println("o peixe está nadando.");
}
}
如果将来您更改 animal 的实现，例如更改 move 方法以包含不同的逻辑，此更改将自动传播到所有子类，这可能会产生意外的行为。
问题：维护困难
如果修改了超类，则需要重新测试所有子类，以确保这些更改不会破坏预期的行为。
2. 多重继承
在java中，一个类不能扩展多个类，即不可能有多重继承。这意味着子类只能从一个超类继承。此限制有助于避免多重继承可能产生的复杂性，例如方法的歧义（例如，如果两个超类具有同名的方法）。
例子：
public class A {
public void metodo() {
System.out.println("Método da classe A");
}
}
public class B {
public void metodo() {
System.out.println("Método da classe B");
}
}
// Isso não é permitido em Java
public class C extends A, B { // Erro: não pode estender mais de uma classe
}
3. 多态性和复杂层次结构
有时，类层次结构可能变得非常复杂，导致很难理解类之间的关系和代码行为的可预测性。这可能导致多态性使用效率低下，子类的行为不符合预期。
最后的考虑因素
继承和抽象类是 oop 中强大的概念，有助于创建更有组织性和可重用的系统。然而，谨慎使用继承至关重要，要认识到可能出现的潜在问题，例如强依赖性、单一继承的限制以及层次结构的复杂性。与其他方法（例如组合）相比，评估继承的需求可以带来更清晰、更易于维护的软件设计。
