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