Herança

A herança é um princípio fundamental da programação orientada a objetos (OOP) que também está presente em Solidity. A herança permite que um contrato herde propriedades e comportamentos (variáveis de estado e funções) de um ou mais contratos "pais", promovendo assim a reutilização de código e a criação de relações hierárquicas entre contratos.

Características da Herança em Solidity

• Reutilização de Código: A herança permite que contratos inteligentes reutilizem o código de outros contratos. Isso não apenas reduz a redundância, mas também promove a prática do princípio DRY (Don't Repeat Yourself - Não se Repita).

• Hierarquia de Contratos: Solidity permite a criação de uma hierarquia de contratos, onde um contrato filho pode herdar de múltiplos contratos pais, seguindo um padrão de herança múltipla.

• Sobrescrita de Funções: Os contratos filhos podem sobrescrever funções herdadas de seus contratos pais, permitindo personalizar ou estender a funcionalidade base. Para isso, utiliza-se o atributo override na função.

• Modificadores de Visibilidade: Solidity utiliza modificadores de visibilidade (public, internal, private e external) para controlar o acesso às funções e variáveis de estado. As regras de visibilidade também se aplicam a contratos herdados.

Exemplo Básico de Herança

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

// Contrato pai
contract Base {
    uint public data;

    constructor(uint _data) {
        data = _data;
    }

    function setData(uint _data) public {
        data = _data;
    }
}

// Contrato filho que herda Base
contract Derived is Base {
    constructor(uint _initialData) Base(_initialData) {
        // Inicializa o contrato pai com _initialData
    }

    // Sobscreve a função setData
    function setData(uint _data) public override {
        data = _data + 10; // Altere a implementação para somar 10 antes de armazenar.
    }
}

Neste exemplo, Derived herda de Base. Isso significa que Derived tem acesso à variável data e pode usar ou sobrescrever a função setData. Na função setData sobrescrita, modificamos a implementação para somar 10 ao _data antes de armazená-lo.

Herança multinivel

A herança multinível é um conceito onde um contrato herda de outro contrato, que por sua vez herda de outro, criando assim uma hierarquia de herança "multinível". Esse padrão permite a construção de relações hierárquicas complexas e a reutilização de código através de vários níveis de contratos.

Aqui está um exemplo de herança multinível em Solidity, que ilustra como um contrato pode herdar propriedades e comportamentos de vários contratos pai situados em diferentes níveis da hierarquia:

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

// Contrato de nivel base
contract Grandparent {
    uint public grandparentValue;

    constructor(uint _value) {
        grandparentValue = _value;
    }

    function setGrandparentValue(uint _value) public {
        grandparentValue = _value;
    }
}

// Primeiro nivel de herança
contract Parent is Grandparent {
    uint public parentValue;

    constructor(uint _grandparentValue, uint _parentValue) Grandparent(_grandparentValue) {
        parentValue = _parentValue;
    }

    function setParentValue(uint _value) public {
        parentValue = _value;
    }
}

// Segundo nivel de herança
contract Child is Parent {
    uint public childValue;

    constructor(uint _grandparentValue, uint _parentValue, uint _childValue) Parent(_grandparentValue, _parentValue) {
        childValue = _childValue;
    }

    function setChildValue(uint _value) public {
        childValue = _value;
    }
}

Explicação do código:

• Grandparent: Este é o contrato de nível base que define uma variável grandparentValue e uma função setGrandparentValue para modificá-la. Ele também possui um construtor que inicializa grandparentValue.

• Parent: Este contrato herda de Grandparent. Adiciona sua própria variável parentValue e uma função setParentValue para modificá-la. Seu construtor chama o construtor de Grandparent para inicializar grandparentValue, e também inicializa parentValue.

• Child: Este é o contrato de nível mais baixo que herda de Parent (e, portanto, indiretamente de Grandparent). Ele adiciona uma variável childValue e uma função setChildValue. Seu construtor inicializa as variáveis de todos os níveis da hierarquia chamando o construtor de Parent, que por sua vez chama o construtor de Grandparent.

Este exemplo mostra como criar e utilizar relações hierárquicas em Solidity por meio da herança multinível, permitindo que os contratos filhos acessem e sobrescrevam propriedades e funções de seus ancestrais, promovendo a reutilização e modularidade do código.

Herança Hierárquica

A herança hierárquica em Solidity refere-se a um padrão onde múltiplos contratos filhos herdam de um único contrato pai, criando uma estrutura hierárquica em "forma de árvore" com um nó raiz comum. Esse padrão permite compartilhar lógica e propriedades comuns entre vários contratos derivados, mantendo ao mesmo tempo diferenças específicas em cada um deles.

Aquí te mostro un exemplo de herança hierárquica em Solidity:

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

// Contrato pai comum
contract Vehicle {
    string public brand;
    string public model;

    constructor(string memory _brand, string memory _model) {
        brand = _brand;
        model = _model;
    }

    function getVehicleInfo() public view returns (string memory, string memory) {
        return (brand, model);
    }
}

// Primeiro contrato filho que herda do Veículo
contract Car is Vehicle {
    uint public carMaxSpeed;

    constructor(string memory _brand, string memory _model, uint _maxSpeed)
        Vehicle(_brand, _model) {
        carMaxSpeed = _maxSpeed;
    }

    function getMaxSpeed() public view returns (uint) {
        return carMaxSpeed;
    }
}

// Segundo contrato filho que herda do Veículo
contract Truck is Vehicle {
    uint public truckLoadCapacity;

    constructor(string memory _brand, string memory _model, uint _loadCapacity)
        Vehicle(_brand, _model) {
        truckLoadCapacity = _loadCapacity;
    }

    function getLoadCapacity() public view returns (uint) {
        return truckLoadCapacity;
    }
}

Explicação do Código:

• Vehicle: Este é o contrato base ou "pai" que define propriedades comuns (brand e model) e uma função (getVehicleInfo) aplicável a qualquer tipo de veículo. Ele funciona como o nó raiz comum na herança hierárquica.

• Car e **Truck**: Esses são contratos "filhos" que herdam do contrato Vehicle. Cada um deles estende a funcionalidade base incluindo propriedades específicas (carMaxSpeed para Car e truckLoadCapacity para Truck) e funções adicionais para interagir com essas propriedades (getMaxSpeed e getLoadCapacity, respectivamente). Embora compartilhem algumas características comuns definidas em Vehicle, Car e Truck se especializam em diferentes aspectos dos veículos que representam.

Características da Herança Hierárquica:

• Especialização: Permite que os contratos filhos se especializem adicionando ou modificando funcionalidades específicas.

• Organização Clara: Facilita uma estrutura clara e lógica para os contratos, refletindo relações do mundo real e facilitando a compreensão e manutenção do código.

Esse padrão de herança é especialmente útil em situações onde diferentes entidades compartilham características comuns, mas também precisam de suas próprias implementações e características específicas.

Herança Múltipla

A herança múltipla permite que um contrato herde comportamentos e características de múltiplos contratos pais.

A herança múltipla pode ser muito poderosa, mas também pode introduzir complexidade e ambiguidades. É importante projetar cuidadosamente a arquitetura dos contratos para evitar problemas comuns, como colisão de nomes ou dependência circular entre contratos.

Exemplo:

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

contract A {
    function foo() public pure returns(string memory) {
        return "A";
    }
}

contract B {
    function bar() public pure returns(string memory) {
        return "B";
    }
}

contract C is A, B {
    function fooBar() public pure returns(string memory) {
        return string(abi.encodePacked(foo(), bar()));
    }
}

Neste exemplo, o contrato C herda de ambos, A e B, e tem acesso às suas funções foo e bar, respectivamente. O contrato C introduz uma nova função fooBar que combina as saídas das funções herdadas.