情况1：使用self可以用于类常量

 class classA { 
     const FIXED_NUMBER = 4; 
     self::POUNDS_TO_KILOGRAMS
}

如果要在类外部调用它，请使用classA:：POUNDS_to_KILOGAMS访问常量

情况2：对于静态财产

class classC {
     public function __construct() { 
     self::$_counter++; $this->num = self::$_counter;
   }
}

关键字self不仅仅指“当前类”，至少不会限制静态成员。在非静态成员的上下文中，self还提供了一种绕过当前对象的vtable（参见vtable上的wiki）的方法。正如您可以使用parent:：methodName（）调用函数的父版本一样，您也可以调用self:：methodName）调用方法的当前类实现。

class Person {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }

    public function getTitle() {
        return $this->getName()." the person";
    }

    public function sayHello() {
        echo "Hello, I'm ".$this->getTitle()."<br/>";
    }

    public function sayGoodbye() {
        echo "Goodbye from ".self::getTitle()."<br/>";
    }
}

class Geek extends Person {
    public function __construct($name) {
        parent::__construct($name);
    }

    public function getTitle() {
        return $this->getName()." the geek";
    }
}

$geekObj = new Geek("Ludwig");
$geekObj->sayHello();
$geekObj->sayGoodbye();

这将输出：

你好，我是极客路德维希路德维希再见了

sayHello（）使用$this指针，因此调用vtable调用Geek:：getTitle（）。sayGoodbye（）使用self:：getTitle（），因此不使用vtable，而是调用Person:：getTitle（）。在这两种情况下，我们都在处理实例化对象的方法，并且可以访问调用函数中的$this指针。

不要使用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:：引用类。

我认为问题不在于是否可以通过调用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;
    }
}

如果您想调用类的方法而不创建该类的对象/实例，则使用self，从而节省RAM（有时使用self）。换句话说，它实际上是在静态地调用一个方法。将其用于对象透视。

在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。