17.11.2024

Aula 052: Herança em Solidity

Herança é um conceito fundamental na programação orientada a objetos que permite a criação de um novo contrato baseado em um contrato existente. Em Solidity, a herança possibilita a reutilização de código e estrutura, tornando o processo de desenvolvimento mais eficiente e organizado.

Nesta aula, vamos explorar como a herança funciona em Solidity, incluindo herança simples e múltipla, assim como o uso da palavra-chave is.

Herança Simples

A herança simples ocorre quando um contrato herda de um único contrato base. Aqui está um exemplo simples para ilustrar esse conceito:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Animal {
    string public especie;

    constructor(string memory _especie) {
        especie = _especie;
    }

    function fazerSom() public virtual pure returns (string memory) {
        return "Um som genérico";
    }
}

contract Cachorro is Animal {
    constructor() Animal("Cachorro") {}

    function fazerSom() public override pure returns (string memory) {
        return "Au au!";
    }
}

Explicação:

• Neste exemplo, o contrato Animal serve como um contrato base com um construtor que define a espécie e um método que retorna um som genérico.
• O contrato Cachorro herda de Animal usando a palavra-chave is e chama o construtor do contrato base.
• O contrato Cachorro sobrepõe o método fazerSom para fornecer um som específico para cães.

Herança Múltipla

Solidity também suporta herança múltipla, que permite a um contrato herdar de vários contratos base. Aqui está um exemplo para demonstrar isso:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Escritor {
    function escrever() public pure returns (string memory) {
        return "Escrevendo um livro.";
    }
}

contract Artista {
    function criar() public pure returns (string memory) {
        return "Criando uma obra-prima.";
    }
}

contract Polímata is Escritor, Artista {
    function descrever() public pure returns (string memory) {
        return "Um polímata escreve e cria.";
    }
}

Explicação:

• Os contratos Escritor e Artista fornecem seus próprios métodos.
• O contrato Polímata herda de ambos, Escritor e Artista, permitindo que acesse métodos de ambos os contratos.
• A função descrever adiciona funcionalidade adicional para descrever o polímata.

Construtor na Herança

Ao lidar com herança múltipla, é essencial considerar como os construtores são chamados. Solidity exige que os construtores dos contratos pai sejam chamados explicitamente dentro do construtor do contrato derivado.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract PaiA {
    uint public dadoA;

    constructor(uint _dadoA) {
        dadoA = _dadoA;
    }
}

contract PaiB {
    uint public dadoB;

    constructor(uint _dadoB) {
        dadoB = _dadoB;
    }
}

contract Filho is PaiA, PaiB {
    constructor(uint _dadoA, uint _dadoB) 
        PaiA(_dadoA) 
        PaiB(_dadoB) 
    {}
}

Explicação:

• Os contratos PaiA e PaiB têm seus próprios construtores que definem suas respectivas variáveis de estado.
• O contrato Filho chama os construtores de ambos os pais em seu próprio construtor usando o formato PaiA(_dadoA) e PaiB(_dadoB).

Sobrescrita de Funções

Quando um contrato derivado possui uma função com o mesmo nome que uma função em um contrato base, o contrato derivado pode sobrescrever essa função. A sobrescrita deve ser declarada explicitamente usando a palavra-chave override.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Base {
    function cumprimentar() public pure virtual returns (string memory) {
        return "Olá do Base!";
    }
}

contract Derivado is Base {
    function cumprimentar() public pure override returns (string memory) {
        return "Olá do Derivado!";
    }
}

Explicação:

• O contrato Base define uma função virtual cumprimentar.
• O contrato Derivado sobrescreve a função cumprimentar para proporcionar uma saudação diferente.

Conclusão

A herança em Solidity promove a reutilização de código e ajuda a criar uma estrutura hierárquica que torna o código mais fácil de gerenciar e estender. Utilizando herança simples e múltipla, juntamente com a sobrescrita de funções, os desenvolvedores podem elaborar contratos inteligentes robustos e flexíveis.

Nesta aula, abordamos os conceitos básicos de herança em Solidity com exemplos práticos. No futuro, você poderá explorar conceitos mais avançados, como interfaces e contratos abstratos, para aprimorar suas habilidades no desenvolvimento de contratos inteligentes.

Video

Navigation