根据静态关键字，没有任何$self。只有$this用于引用类（对象）的当前实例，self用于引用类的静态成员。对象实例和类之间的区别在这里发挥作用。

对象指针$this指向当前对象。类值static引用当前对象。类值self引用了它在中定义的确切类。类值父级是指它在中定义的确切类的父级。

请参见以下显示过载的示例。

<?php

class A {

    public static function newStaticClass()
    {
        return new static;
    }

    public static function newSelfClass()
    {
        return new self;
    }

    public function newThisClass()
    {
        return new $this;
    }
}

class B extends A
{
    public function newParentClass()
    {
        return new parent;
    }
}


$b = new B;

var_dump($b::newStaticClass()); // B
var_dump($b::newSelfClass()); // A because self belongs to "A"
var_dump($b->newThisClass()); // B
var_dump($b->newParentClass()); // A


class C extends B
{
    public static function newSelfClass()
    {
        return new self;
    }
}


$c = new C;

var_dump($c::newStaticClass()); // C
var_dump($c::newSelfClass()); // C because self now points to "C" class
var_dump($c->newThisClass()); // C
var_dump($b->newParentClass()); // A because parent was defined *way back* in class "B"

大多数时候，您希望引用当前类，这就是为什么使用static或$this。然而，有时你需要自我，因为你想要原始类，而不管是什么扩展它

在PHP中，使用self关键字访问静态财产和方法。

问题是，无论method（）是否声明为静态，都可以在任何地方用self:：method（。那么你应该使用哪一种？

考虑以下代码：

class ParentClass {
    function test() {
        self::who();    // will output 'parent'
        $this->who();   // will output 'child'
    }

    function who() {
        echo 'parent';
    }
}

class ChildClass extends ParentClass {
    function who() {
        echo 'child';
    }
}

$obj = new ChildClass();
$obj->test();

在本例中，self:：who（）将始终输出“parent”，而$this->who（（）将取决于对象的类。

现在我们可以看到self是指调用它的类，而$this是指当前对象的类。

因此，只有当$this不可用时，或者当您不想让后代类覆盖当前方法时，才应该使用self。

不要使用self:：。使用静态：：*

自我还有另一个方面：值得一提。令人讨厌的是，self:：是指定义时的范围，而不是执行时的范围。考虑这个具有两个方法的简单类：

class Person
{

    public static function status()
    {
        self::getStatus();
    }

    protected static function getStatus()
    {
           echo "Person is alive";
    }

}

如果我们调用Person:：status（），我们将看到“Person还活着”。现在考虑当我们创建一个继承自此的类时会发生什么：

class Deceased extends Person
{

    protected static function getStatus()
    {
           echo "Person is deceased";
    }

}

调用死者：：status（），我们会看到“Person is dead”。然而，我们看到“Person is alive”，因为在定义对self:：getStatus（）的调用时，作用域包含原始方法定义。

PHP 5.3有一个解决方案。static:：resolution运算符实现“后期静态绑定”，这是一种奇特的方式，表示它绑定到所调用类的范围。将status（）中的行更改为static:：getStatus（），结果就是您所期望的。在旧版本的PHP中，您必须找到一个笨拙的方法来实现这一点。

请参阅PHP文档

所以，要回答这个问题，而不是问。。。

$this->引用当前对象（类的实例），而static:：引用类。

当self与：：运算符一起使用时，它引用当前类，这可以在静态和非静态上下文中完成$这是指对象本身。此外，使用$this调用静态方法（但不引用字段）是完全合法的。

我认为问题不在于是否可以通过调用ClassName:：staticMember来调用类的静态成员。问题是使用self:：classmember和$this->classmember之间有什么区别。

例如，无论您使用self:：还是$this->，以下两个示例都可以正常工作，没有任何错误

class Person{
    private $name;
    private $address;

    public function __construct($new_name,$new_address){
        $this->name = $new_name;
        $this->address = $new_address;
    }
}

class Person{
    private $name;
    private $address;
    public function __construct($new_name,$new_address){
        self::$name = $new_name;
        self::$address = $new_address;
    }
}