参考文章：php 中self,this的区别和实地操作

1.self

①self可以访问本类中的静态属性和静态方法，可以访问父类中的静态属性和静态方法。用self时，可以不用实例化。

class parent_test {
    static $parent_test;
    public function __construct(){  
        self::$parent_test = 'parent_test';//静态属性只能通过self来访问  
    } 
    static public function pentium(){  
        echo 'pentium()';
        return self::$parent_test;//静态方法也可以继续访问静态变量，访问时需要加$  
    }  
    public function func(){  
        echo 'fucn()';
        return self::pentium();//访问静态方法pentium()  
    } 
}

class self_test extends parent_test {  
    static $instance;  
    public function __construct(){  
        parent::__construct();
        self::$instance = 'self_test';//静态属性只能通过self来访问  
    }  
    public function tank(){  
        echo self::$instance.'<br/>';//访问静态属性  
        echo self::$parent_test.'<br/>';
        echo self::pentium().'<br/>';
        echo self::func().'<br/>';
    }  
     
}  
$str = new self_test();  
$str->tank(); 

//输出：
//self_test
//parent_test
//pentium()parent_test
//fucn()pentium()parent_test

②self可以访问const定义的常量

class self_test {  
    const  NAME = 'tancy';  
    public function tank(){  
        return self::NAME;  
    }  
} 
$str = new self_test();  
echo $str->tank();

//输出:
//tancy

2.this

this可以调用本类中的方法和属性，也可以调用父类中的方法和属性（静态和const常量除外）

class parent_test {
    static $parent_test = 'parent_test';
    // public function __construct(){
    //     self::$parent_test = 'parent_test';//静态属性只能通过self来访问
    // }
    public static function pentium(){
        echo 'parent_pentium() <br/>';
        // return self::$parent_test;//静态方法也可以继续访问静态变量，访问时需要加$
    }
    public function parent_func(){
        echo 'parent_fucn() <br/>';
        // return self::pentium();//访问静态方法pentium()
    }
}

class self_test extends parent_test {
    public $public = 'public';
    private $private = 'private';
    static $static = 'static';
    static $instance = 'self_test';

    public function __construct(){
        echo self::$instance.'<br/>';//self_test
//          echo $this->public.'<br/>';//public
//          echo self::$public.'<br/>';//Fatal error: Access to undeclared static property: self_test::$public
//          echo $this->private.'<br/>';//private
//          echo self::$private.'<br/>';//Fatal error: Access to undeclared static property: self_test::$private
//          echo $this->static.'<br/>';//Strict Standards: Accessing static property self_test::$static as non static(原因见注③)
                                       //Notice: Undefined property: self_test::$static
//          echo self::$static.'<br/>';//static

        $this->tank('__construct_this');
        self::tank('__construct_self');
        $this->func('__construct_this');
        self::func('__construct_self');
    }

    public function tank($type){
            echo $type.'<br/>';
    }

    public function func($type){
//     public static function func($type){ //如果此处定义为静态方法，则$this->tank()会报错，原因见注②
            self::tank($type.'func_self');
            $this->tank($type.'func_this');
    }

    public function call_parent(){
        $this->pentium();
        self::pentium();
        $this->parent_func();
        self::parent_func();
    }
}
$str = new self_test();
// $str->tank();
// $str->call_parent();

注意：
参考：Static（静态）关键字
① 静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。
② 由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。
③ 静态属性不可以由对象通过 -> 操作符来访问。
④ 用静态方式调用一个非静态方法会导致一个 E_STRICT 级别的错误。
⑤ 静态属性只能被初始化为文字或常量，不能使用表达式。所以可以把静态属性初始化为整数或数组，但不能初始化为另一个变量或函数返回值，也不能指向一个对象。

总结：
self与$this的功能极其相似，但二者又不相同。
this是指向对象实例的一个指针，在实例化的时候来确定指向；self是对类本身的一个引用，一般用来指向类中的静态变量

3.范围解析操作符 （::）

范围解析操作符是一对冒号，可以用于访问静态成员和类常量，还可以用于覆盖类中的属性和方法。

①在类外部使用

class MyClass {
    const CONST_VALUE = 'A constant value';
}
echo MyClass::CONST_VALUE;

$classname = 'MyClass';
echo $classname::CONST_VALUE; // 自 PHP 5.3.0 起

//输出：
//A constant value 
//A constant value 

②在类内部使用

class OtherClass
{
    public static $my_static = 'static var';

    public static function doubleColon() {
        echo self::$my_static . "\n";
    }
}

$classname = 'OtherClass';
echo $classname::doubleColon(); // 自 PHP 5.3.0 起
OtherClass::doubleColon();
echo $classname::$my_static;

//输出：
//static var 
//static var 
//static var

③调用父类的方法

class MyClass
{
    protected function myFunc() {
        echo "MyClass::myFunc()\n";
    }
}

class OtherClass extends MyClass
{
    // 覆盖了父类的定义
    public function myFunc()
    {
        // 但还是可以调用父类中被覆盖的方法
        parent::myFunc();
        echo "OtherClass::myFunc()\n";
    }
}

$class = new OtherClass();
$class->myFunc();

//输出：
//MyClass::myFunc() 
//OtherClass::myFunc() 

4.对象运算符(->)

用于对象访问其属性或方法

class mytest 
{
    public $str = 'string';

    function __construct()
    {
        $this->test('__construct');
    }

    function test($para){
        echo $para.'<br/>';
    }
}

$mytest = new mytest();

echo $mytest->str.'<br/>';
$mytest->test('new test');

//输出：
//__construct
//string
//new test