首页 > Java > java教程 > 正文

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

心靈之曲
发布: 2024-10-17 14:51:30
转载
763人浏览过

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

什么是继承?

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

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

豆包AI编程
豆包AI编程

智能代码生成与优化,高效提升开发速度与质量!

下载
来源:dev.to网
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn
最新问题
开源免费商场系统广告
热门教程
更多>
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
关于我们 免责申明 意见反馈 讲师合作 广告合作 最新更新
php中文网:公益在线php培训,帮助PHP学习者快速成长!
关注服务号 技术交流群
PHP中文网订阅号
每天精选资源文章推送
PHP中文网APP
随时随地碎片化学习
PHP中文网抖音号
发现有趣的

Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号