Solidity – Inheritance

Inheritance pada solidity mirip dengan bahasa programming Python.

Inheritance menggunakan keyword is.

contract Base {}
contract Derived is Base {}

Berikut beberapa point penting tentang inheritance:

• Contract turunan (derivative) akan memiliki State, Functions dan Events dari Base Contract.
• Contract turunan akan dideploy sebagai satu contract. Code dari base contract akan dicopykan ke contract turunan.
• Contract dapat inherit dari multiple contract. (lihat contoh code dibawah)
• Fungsi dari base contract dapat di override dengan syarat nama fungsi, input dan output harus sama.
• Untuk memanggil fungsi base contract yang di override, harus ditambahkan nama contract secara explicit. (lihat contoh code dibawah).
• JIka constructor memerlukan argument, tambahkan dalam function header. (lihat code dibawah).
• Urutan inheritance harus diperhatikan. (Lihat contoh code dibawah.)

Contoh code multiple inheritance dan penggunan explicit base function.

pragma solidity ^0.4.16;

contract Owned {
   //code goes here
}

contract Mortal is Owned {
   function kill() {
       //code goes here
   }
}

contract Named is Owned, Mortal {
   function named(bytes32 name){
       //code goes here
   }

   function kill() public {
      //code goes here
      //explicit base function call
      Mortal.kill();
   }
}

Contoh code constructor yang memerlukan argument.

contract Base {
   function Base (uint _x) public {}
}

contract Derived is Base(7){
   function Derived(uint _y) Base(_y * _y) public{
       //code goes here
   }
}

Contoh code urutan inheritance.

contract X {}
contract A is X {}

// akan error
contract C is A, X {}

// no error
contract D is X, A {}

Abstract Contract

Abstract contract adalah contract tanpa implementasi fungsi. Tujuannya digunakan sebagai base contract untuk diturunkan.

Abstract contract tidak akan dicompile.

Contoh abstract contract, Feline adalah abstract contract, yang diturunkan menjadi contract Cat.

pragma solidity ^0.4.0

contract Feline {
  function utterance() public returns (bytes32);
}

contract Cat is Feline{
  function utterance() public returns (bytes32){ return "miaow";}
}

Interface Contract

Interfaces contract mirip dengan abstract contracts. Dibuat menggunakan keyword interface. Berikut beberapa aturan dari interface contract:

• Interface tidak dapat memiliki implementasi function.
• Type function harus type external.
• Tidak dapat memiliki constructor dan state variables.
• Dapat menggunakan enum, structs yang dapat diakses melalui interface name dot notation.

Berikut contoh penggunakan interface contract.

pragma solidity ^0.5.0;

interface Calculator {
   function getResult() external view returns(uint);
}
contract Test is Calculator {
   constructor() public {}
   function getResult() external view returns(uint){
      uint a = 1; 
      uint b = 2;
      uint result = a + b;
      return result;
   }
}