La encapsulación es fundamental y uno de los conceptos más importantes de los lenguajes de programación orientados a objetos. Se refiere al mecanismo de manipulación del ámbito de las variables, es decir restringe el acceso de la variable fuera del ámbito. Permite suficiente acceso restringido a un método para tomar acción sobre él. El alcance de los objetos puede tener cuatro tipos de acceso:
- Público: se puede acceder a estos objetos interna y externamente, así como también a través de mensajes. Los elementos públicos pueden ser heredados por métodos externos. Una función getter se genera automáticamente cuando se crea una variable pública.
- Interno: como sugiere el nombre, se puede acceder a los objetos internos mediante métodos internos o métodos derivados, pero no se puede acceder a ellos desde el exterior. Solo tiene acceso un contrato base y un contrato derivado.
- Privado: solo se puede acceder internamente a los objetos privados desde las instancias de contrato actuales. Tampoco se puede acceder a ellos mediante métodos derivados.
- Externo: se puede acceder a estos objetos externamente pero no internamente, es decir, las instancias del contrato actual no pueden acceder a él. No se pueden heredar.
Ejemplo: En el siguiente ejemplo, el padre del contrato es heredado por el hijo del contrato para demostrar diferentes alcances del objeto discutido anteriormente.
Solidity
// Solidity program to
// demonstrate Encapsulation
pragma solidity ^0.5.0;
// Creating a contract
contract parent {
// Declaring public
// state variable
uint public num = 30;
// Declaring internal
// state variable
uint internal internal_num= 10;
// Defining external function to
// demonstrate access of
// internal state variable
function sqrt() external returns (
uint) {
internal_num = internal_num ** 2;
return internal_num;
}
}
// Defining calling contract
contract Caller {
// Creating a child
// contract object
child c = new child();
// Defining public function
// to demonstrate access
// to external function sqrt
function f() public returns (
uint) {
return c.sqrt();
}
// Defining function to
// demonstrate access to
// public functions increment()
// and add()
function f2() public returns(
uint, uint){
return (c.increment(), c.add());
}
}
// Defining child contract
// inheriting parent contract
contract child is parent {
// Defining public function
// to demonstrate access to
// public state variable num
function increment(
) public payable returns (uint) {
num = num + 20;
return num;
}
// Defining public function
// to demonstrate access
// to local variable a, b, and sum
function add() public view returns(
uint){
uint a = 10;
uint b = 20;
uint sum = a + b;
return sum;
}
}
Producción:
Publicación traducida automáticamente
Artículo escrito por jeeteshgavande30 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA