Capacitando seus contratos Ethereum com Solidity Inheritance

Nosso objetivo neste artigo é explorar a herança do Solidity e como ela pode ser utilizada para fazer contratos inteligentes eficazes e eficientes .

O Solidity permite que os contratos inteligentes herdem uns dos outros, permitindo que vários contratos se tornem um.

Nos termos do contrato, o contrato cujas características outros contratos herdam é chamado de contrato base, enquanto o contrato que herda as características é chamado de contrato derivado.

Índice-

O que é Solidity Herança?

Herança é um conceito de programação que permite que uma nova classe, chamada classe filha, herde propriedades e métodos de uma classe existente, chamada classe pai.

No Solidity, os contratos podem ser usados ​​como classes, e a herança permite que novos contratos herdem propriedades e métodos dos contratos pai.

Os contratos derivativos podem acessar todos os membros não privados, incluindo variáveis ​​de estado e métodos internos. No entanto, não é permitido usá-lo.

É permitido substituir funções desde que suas assinaturas permaneçam as mesmas. A compilação falhará se os parâmetros de saída forem diferentes.

A função de um super contrato pode ser chamada com uma palavra-chave super ou com o nome de um super contrato.

Quando várias heranças estão presentes, as chamadas de função que usam a palavra-chave super invocam a maioria das funções no contrato derivado.

Tipos de herança de solidez

Solidity fornece diferentes tipos de herança. Seguem seus tipos:

tipos Visão geral
Herança única Um contrato herda de apenas um contrato pai.
Herança múltipla Um contrato é herdado de vários contratos pai.
Herança hierárquica Um contrato pode ser tanto um contrato filho quanto um contrato pai, criando uma estrutura de herança hierárquica.
Herança linear Um tipo de herança múltipla em que o gráfico de herança é uma cadeia linear, com cada contrato herdando apenas de um contrato pai.
Herança híbrida Uma combinação de herança linear e hierárquica, em que os contratos herdam de vários contratos pai, mas também formam uma hierarquia.

Herança Única

A herança única do Solidity é um processo de herdar um contrato derivado de um contrato pai para ter acesso às suas variáveis ​​e métodos de estado.

O exemplo abaixo mostra o fenômeno funcional da herança única:

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
pragma solidity ^0.8.0;
// This is the Parent Method //
contract SolidityTest {
string public mrx_ample="Mr.Examples";
uint public solidity_developer_age=21;
function get_Name(string memory mrx) public pure returns(string memory){
return mrx;
}
function get_Average(uint mrx1,uint mrx2,uint mrx3,uint mrx4,uint mrx5) public pure returns(uint){
uint sum=(mrx1+mrx2+mrx3+mrx4+mrx5)/5;
return sum;
}
function get_Product(uint mrx,uint ample) public pure returns(uint){
return mrx*ample;
}
}
// This is the inherited contract with have access to the variables and functions of the parent contract //
contract SolidityTest1 is SolidityTest{
function inherited_Name() public pure returns(string memory){
return get_Name("Mr.Examples");
}
function inherited_Average() public pure returns(uint){
return get_Average(1,2,3,4,5);
}
function inherited_Product() public pure returns(uint){
return get_Product(3,5);
}
function inherit_value_from_Parent() public view returns(string memory){
return mrx_ample;
}
function inherite_developer_age() public view returns(uint){
return solidity_developer_age;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Herança Múltipla

Um tipo de herança em que uma classe filha pode ter mais de um pai é conhecido como herança múltipla.

Isso permite que a classe filha acesse os atributos e funções de ambos os pais, tornando o código reutilizável e curto.

Por exemplo, considere o seguinte código:

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
63
64
65
66
67
68
69
pragma solidity ^0.8.0;
// This is the Parent Method //
contract SolidityTest {
uint public sum=10+20;
uint public difference=20-10;
uint public product=10*20;
uint public divide=20/10;
}
contract SolidityTest1{
string public mrx1="Mr";
string public mrx2=".";
string public mrx3="Examples";
}
contract SolidityTest2 is SolidityTest,SolidityTest1{
// Here we obtain the values from parent number 1 that is SolidityTest
function get_Sum() public view returns(uint){
return sum;
}
function get_Difference() public view returns(uint){
return difference;
}
function get_Product() public view returns(uint){
return product;
}
function get_Divide() public view returns(uint){
return divide;
}
// Here we obtain the values from parent number 2 that is SolidityTest1
function get_String1() public view returns(string memory){
return mrx1;
}
function get_String2() public view returns(string memory){
return mrx2;
}
function get_String3() public view returns(string memory){
return mrx3;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Hierárquico - Herança Multinível

Isso é muito semelhante à herança única, exceto que existem níveis de relacionamento entre pai e filho.

Os contratos infantis derivados dos pais atuam como pais para os contratos derivados deles.

O código a seguir explicará o conceito de herança multinível:

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
pragma solidity ^0.8.0;
// This is the Parent Method //
contract SolidityTest {
string public mrx_ample="Mr.Examples";
uint public solidity_developer_age=21;
function get_Name(string memory mrx) public pure returns(string memory){
return mrx;
}
function get_Average(uint mrx1,uint mrx2,uint mrx3,uint mrx4,uint mrx5) public pure returns(uint){
uint sum=(mrx1+mrx2+mrx3+mrx4+mrx5)/5;
return sum;
}
function get_Product(uint mrx,uint ample) public pure returns(uint){
return mrx*ample;
}
}
// This is the inherited contract with have access to the variables and functions of the parent contract //
contract SolidityTest1 is SolidityTest{
function inherited_Name() public pure returns(string memory){
return get_Name("Mr.Examples");
}
function inherited_Average() public pure returns(uint){
return get_Average(1,2,3,4,5);
}
function inherited_Product() public pure returns(uint){
return get_Product(3,5);
}
function inherit_value_from_Parent() public view returns(string memory){
return mrx_ample;
}
function inherite_developer_age() public view returns(uint){
return solidity_developer_age;
}
}
// Here we initialize another class that extends from the already extended class SolidityTest1
contract SolidityTest2 is SolidityTest1{
function multilevel_Obtain_Name() public pure returns(string memory){
return get_Name("Examples");
}
function multilevel_Obtain_Average() public pure returns(uint){
return get_Average(6,3,5,6,8);
}
function multilevel_Obtain_Product() public pure returns(uint){
return get_Product(4,7);
}
function multilevel_value_from_Parent() public view returns(string memory){
return mrx_ample;
}
function multilevel_value_developer_age() public view returns(uint){
return solidity_developer_age;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Conclusão

A herança do Solidity permite que você reutilize o código e crie contratos inteligentes mais sofisticados e complexos.
Devido ao seu suporte para herança múltipla e contratos abstratos, você pode criar estruturas de herança complexas para atender às suas necessidades específicas.
A herança deve ser usada criteriosamente, no entanto, e as hierarquias de herança não devem ser excessivamente complexas ou difíceis de manter.
A herança do Solidity permite que você e outros desenvolvedores escrevam contratos inteligentes que são mais fáceis de ler, testar e manter devido à sua modularidade, reutilização e sintaxe limpa .
Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.