面向对象编程中的继承和抽象类

什么是继承？

继承是面向对象编程 (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 中强大的概念，有助于创建更有组织性和可重用的系统。然而，谨慎使用继承至关重要，要认识到可能出现的潜在问题，例如强依赖性、单一继承的限制以及层次结构的复杂性。与其他方法（例如组合）相比，评估继承的需求可以带来更清晰、更易于维护的软件设计。

以上就是面向对象编程中的继承和抽象类的详细内容，更多请关注其它相关文章！