Solidity – 封装

封装是面向对象编程语言的基本概念，也是最重要的概念之一。它指的是对变量作用域的操纵机制，即限制变量在作用域外的访问。它允许对方法进行足够的约束访问以对其执行操作。对象的范围可以有四种访问方式：

1. 公共：这些对象可以在内部和外部以及通过消息进行访问。公共元素可以被外部方法继承。创建公共变量时会自动生成一个 getter函数。
2. 内部：顾名思义，内部对象可以通过内部方法或派生方法访问，但不能通过外部访问。只有基础合约和派生合约具有访问权限。
3. Private：私有对象只能从当前合约实例内部访问。它们也不能被派生方法访问。
4. 外部：这些对象可以在外部访问，但不能在内部访问，即当前合约实例无法访问它。它们不能被继承。

示例：在下面的示例中，合同父级由合同子级继承，以演示上述对象的不同范围。

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;
   }
     
}

输出：