function getMoneyFunc() {
    $rmb = 1;
    $func = function() use ( &$rmb ) {
        echo $rmb.'<br>';
        //把$rmb的值加1
        $rmb++;
    };
    return $func;
}

$getMoney = getMoneyFunc(); //匿名函数返回给外界,保存了$rmb的变量
$getMoney();
$getMoney();
$getMoney();

//输出：
//1
//2
//3

从例子中理解“将匿名函数返回给外界，匿名函数会保存use所引用的变量，而外界则不能得到这些变量”，将匿名函数返回给外界后，$rmb这个引用变量就被保存了，提升成了全局变量(全局变量，类似静态变量)，而后面每次再调用匿名函数，传入的都是这个保存后的值

<?php
class A {
    public static function testA() {
        return function($i) { //返回匿名函数
            return $i+100;
        };
    }
}

function B(Closure $callback)
{
    return $callback(200);
}

$a = B(A::testA());
print_r($a);//输出 300

  class A{
      private $name = '王力宏';
      protected $age = '30';
      private static $weight = '70kg';
      public $address = '中国';
      public static $height = '180cm';
  }

  $obj = new A();
  //echo $obj->name;//报错 Cannot access private property A::$name
  //echo $obj->age;//报错 Cannot access protected property A::$age
  //echo A::$weight; //报错 Cannot access private property A::$weight
  echo $obj->address;//正常 输出 中国
  echo A::$height;//正常 输出 180cm
  $fun = function(){
      $obj = new A();
      return $obj->address;//实例对象可以获得公有属性,  $obj->name等私有属性肯定不行 上面例子已列出报错
  }
  echo $fun();//正常 输出 中国
  $fun2 = function(){
      return A::$height;//  类可以直接访问公有静态属性，但A::$weight肯定不行，因为weight为私有属性
  }
  echo $fun2();//正常 输出 180cm

$fun = function(){
    return $this->name;
}
或者
$fun = function(){
    return A::$height;
}
echo $fun();//会报错的

$fun = function(){
    //name是私有属性，需要第3个参数
    return $this->name;
} ;
$name = Closure::bind($fun,new A() ,'A');                                                                                                                                                           
echo $name();//输出 王力宏 
该函数返回一个全新的 Closure匿名的函数，和原来匿名函数$fun一模一样，只是其中$this被指向了A实例对象,这样就能访问address属性了。

Closure::bind($fun,new A() );
这个使用 你可以理解成对匿名函数做了如下过程:
$fun = function(){
   $this = new A();
    return $this->name;
} ;

$fun = function(){
    //address为公开，第3个参数可以不需要
    return $this->name;
} ;
$address = Closure::bind($fun,new A()); 
echo $address();

$fun = function() {
  //访问私有静态属性，访问静态属性，第2个参数可以为null，访问私有属性，需要第3个参数提高作用域

　　//return A::$weight;  这样写，会报错，提示不能通过类名访问私有静态变量
　　//weight 为类的私有属性，只可在类中访问
　　return self::$weight;

 }; //echo $fun(); 运行会报错 因为weight为私有属性 。 $weight = Closure::bind($fun,null,'A'); //通过bind函数作用，返回一个和$fun匿名函数一模一样的匿名函数，只是该匿名函数中A::$weight, weight属性由私有变成公有属性了。 echo $weight();

/**
* 一个基本的购物车，包括一些已经添加的商品和每种商品的数量
*
*/
class Cart {
  // 定义商品价格
  const PRICE_BUTTER = 10.00;
  const PRICE_MILK = 30.33;
  const PRICE_EGGS = 80.88;
  protected $products = array();

  /**
  * 添加商品和数量
  *
  * @access public
  * @param string 商品名称
  * @param string 商品数量
  */
  public function add($item, $quantity) {
      $this->products[$item] = $quantity;
  }

  /**
  * 获取单项商品数量
  *
  * @access public
  * @param string 商品名称
  */
  public function getQuantity($item) {
      return isset($this->products[$item]) ? $this->products[$item] : FALSE;
  }

  /**
  * 获取总价
  *
  * @access public
  * @param string 税率
  */
  public function getTotal($tax) {
      $total = 0.00;
      $callback = function ($quantity, $item) use ($tax, &$total) {
          $pricePerItem = constant(__CLASS__ . "::PRICE_" . strtoupper($item)); //调用以上对应的常量
          $total += ($pricePerItem * $quantity) * ($tax + 1.0);
      };

      array_walk($this->products, $callback);
      
      return round($total, 2);
  }
}

$my_cart = new Cart;
// 往购物车里添加商品及对应数量
$my_cart->add('butter', 10);
$my_cart->add('milk', 3);
$my_cart->add('eggs', 12);
// 打出出总价格，其中有 3% 的销售税.
echo $my_cart->getTotal(0.03);//输出 1196.4

class A {
    private $attr = array();
}

class B {
    public static function bind (A $a) {
        return \Closure::bind(function () use ($a) {
            //给私有属性赋值
            $a->attr = [
                'color' => 'red',
                'weight' => '1.0',
            ];
        }, null, A::class);
    }
}

//我们在对象外部给私有对象赋值时，需要通过\Closure::bind ,来提高闭包作用域进行赋值
$a = new A();
//不能对私有属性直接进行$a->attr = ['color' => 'red','weight' => '1.0'];
call_user_func(B::bind($a));
print_r($a);

/**
 * 给类动态添加新方法
 *
 * @author fantasy
 */
trait DynamicTrait {

    /**
     * 自动调用类中存在的方法
     */
    public function __call($name, $args) {
        if(is_callable($this->$name)){
            return call_user_func($this->$name, $args);
        }else{
            throw new \RuntimeException("Method {$name} does not exist");
        }
    }
    /**
     * 添加方法
     */
    public function __set($name, $value) {
        $this->$name = is_callable($value)?
            $value->bindTo($this, $this):
            $value;
    }
}

/**
 * 只带属性不带方法动物类
 *
 * @author fantasy
 */
class Animal {
    use DynamicTrait;
    private $dog = '汪汪队';
}

$animal = new Animal;

// 往动物类实例中添加一个方法获取实例的私有属性$dog
$animal->getdog = function() {
    return $this->dog;
};

echo $animal->getdog();//输出 汪汪队

class MyClass
{
    public $foo = 'a';
    protected $bar = 'b';
    private $baz = 'c';

    /**
     * @param bool $all 是否获取全部的属性
     *
     * @return array
     */
    public function toArray($all = false)
    {
        // Only public variables
        $callback = (function ($obj) {
            // get_object_vars — 返回由对象属性组成的关联数组 ,在类内调用时，会返回所有的属性(private,protect,public), 在类外使用只返回public
            return get_object_vars($obj);
        });

        //指定作用域 为 null 则会返回 public 属性； 指定作用域默认 ‘static’，则会返回所有属性
        if ($all) {
            $callback = $callback->bindTo(null);
        } else {
            //类内获取public属性
            $callback = $callback->bindTo(null, null);
        }
        return $callback($this);
    }
}

$obj = new MyClass;
$vars = get_object_vars($obj); // get_object_vars 类外使用，获取到的是 public 属性
$vars = $obj->toArray();