Contratos abstratos em solidez

Neste artigo, examinaremos os contratos abstratos no Solidity e exploraremos como eles podem ser utilizados para gerar modelos de contrato adaptáveis e modulares.

Índice-

Contratos abstratos em solidez:
- Contratos abstratos:
- Importância do Contrato Abstrato:

Contratos abstratos

O termo contrato abstrato refere-se a contratos com pelo menos uma função que não é implementada ou a contratos que não fornecem argumentos para todos os construtores de contrato base.

Podemos considerar os contratos abstratos se não pretendemos criá-los diretamente.

Uma instância abstrata não pode ser criada.

Um contrato abstrato serve como um contrato base do qual um contrato filho pode herdar e utilizar suas funções .

Um contrato derivado que herda do contrato abstrato deve implementar funções incompletas para fornecer uma estrutura para o contrato.

Se esse contrato derivado não implementar funções incompletas, ele também será rotulado como abstrato. Declarou através da palavra-chave abstract.

O exemplo a seguir fornece uma compreensão básica da utilização do contrato abstrato:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
pragma solidity ^0.8.0;
abstract contract SolidityTest{
  function get_String(string memory mrx) public view virtual returns(string memory);
}
contract SolidityTest1 is SolidityTest{
  function get_String (string memory mrx) public pure override returns(string memory){
    return mrx;
  }
}
contract SolidityTest2{
 SolidityTest obj;
 constructor(){
  obj=new SolidityTest1();
 
  }
  function show_String() public view returns(string memory){
    return obj.get_String("Mr.Examples");
  }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Os contratos de solidity abstract não podem ser implantados no blockchain, mas podem ser usados como um contrato base para outros contratos herdarem.

Quando um contrato herda de um contrato abstrato, ele deve implementar todas as funções abstratas definidas no contrato abstrato.

Se um contrato não implementa todas as funções abstratas, ele não pode ser implantado no blockchain.

Abaixo está um exemplo de contrato herdado de SolidityTest .

O exemplo abaixo ilustra o Funcionamento do contrato abstrato de forma mais clara para facilitar a compreensão do seu conceito:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
pragma solidity ^0.8.0;
abstract contract SolidityTest{
  function get_Name(string memory mrx) public view virtual returns(string memory);
  function set_Product(uint mrx,uint ample) public virtual;
  function get_Product() public virtual returns(uint);
 
}
contract SolidityTest1 is SolidityTest{
  uint private _mrx;
  uint private _ample;
  function get_Name(string memory mrx) public pure override returns(string memory){
 
  return mrx;  
  }
  function set_Product(uint mrx,uint ample) public override{
 
  _mrx=mrx;
  _ample=ample;
  }
function get_Product() public view override returns(uint){
return _mrx*_ample;
}
}
contract SolidityTest2{
  SolidityTest mrx_obj;
 
  constructor(){
  mrx_obj=new SolidityTest1();
}
function obtain_Values() public returns(string memory,uint){
  mrx_obj.set_Product(5,7);
  return(mrx_obj.get_Name("Mr.Examples"),mrx_obj.get_Product());
  }
} 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Nota : O exemplo acima ilustra o funcionamento dos contratos abstratos e não executará ou fornecerá uma saída, este exemplo é criado para fornecer ao aluno uma melhor compreensão.

Importância do Contrato Abstrato

Vários benefícios estão disponíveis para os desenvolvedores do Solidity por meio de contratos abstratos, incluindo:

Os contratos abstratos criam interfaces padrão que podem ser usadas por vários contratos porque definem funções e variáveis que devem ser implementadas por todos os contratos herdados. Como resultado, contratos complexos podem ser construídos com componentes intercambiáveis mais facilmente.
A modularidade dos contratos abstratos permite que os desenvolvedores dividam contratos complexos em partes menores e mais fáceis de gerenciar. Dessa forma, os contratos podem ser testados, mantidos e atualizados com mais facilidade.
Contratos abstratos podem ocultar detalhes de implementação de outros contratos. Como resultado, os contratos serão mais seguros e o código menos vulnerável a erros.
Os contratos abstratos são usados para definir variáveis e funções que devem ser implementadas por qualquer contrato derivado deles, mantendo-se flexíveis em outras áreas. Com isso, os desenvolvedores podem criar contratos flexíveis e personalizáveis que podem ser adaptados a diferentes casos de uso.

Conclusão

Abstract Contracts usa a linguagem de programação Solidity para construir contratos flexíveis e modulares na blockchain Ethereum .

Ele permite que contratos complexos com componentes intercambiáveis sejam construídos mais facilmente, fornecendo uma interface padrão para vários contratos. Além disso, eles permitem que os desenvolvedores dividam contratos complexos em partes menores e mais gerenciáveis, enquanto ocultam os detalhes da implementação e protegem os contratos.

Um desenvolvedor do Solidity que deseja criar contratos Ethereum de alta qualidade se beneficiará deste artigo.

Nós valorizamos o seu feedback.

Contratos abstratos em solidez

Contratos abstratos

Example:

Example:

Importância do Contrato Abstrato

Conclusão

Sentindo entediado?