self（不是$self）指的是类的类型，而$this指的是该类的当前实例。self用于静态成员函数，允许您访问静态成员变量$这用于非静态成员函数，是对调用成员函数的类实例的引用。

因为这是一个对象，所以可以像这样使用它：$this->member

因为self不是一个对象，所以它基本上是一个自动引用当前类的类型。您可以像：self:：member一样使用它

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

简短回答

使用$this表示当前对象使用self指代当前类别。换句话说，使用$this->非静态成员的成员，对静态成员使用self:：$member。

完整答案

以下是非静态和静态成员变量$this和self的正确用法示例：

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo $this->non_static_member . ' '
           . self::$static_member;
    }
}

new X();
?>

以下是非静态和静态成员变量不正确使用$this和self的示例：

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo self::$non_static_member . ' '
           . $this->static_member;
    }
}

new X();
?>

下面是一个成员函数使用$this的多态性示例：

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        $this->foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

下面是通过对成员函数使用self来抑制多态行为的示例：

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        self::foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

其思想是$this->foo（）调用当前对象的任何类型的foo（（）成员函数。如果对象是X类型，那么它将调用X:：foo（）。如果对象类型为Y，则调用Y:：foo（）。但是对于self:：foo（），总是调用X:：foo（）。

从…起http://www.phpbuilder.com/board/showthread.php?t=10354489:

通过http://board.phpbuilder.com/member.php?145249-激光灯

在类定义中，$this引用当前对象，而self引用当前类。

必须使用self引用类元素，并使用$this引用对象元素。

self::STAT // refer to a constant value
self::$stat // static variable
$this->stat // refer to an object variable  

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

这里有一个小的基准（第7.2.24节）：

            Speed (in seconds)  Percentage
$this->     0.91760206222534    100
self::      1.0047659873962     109.49909865716
static::    0.98066782951355    106.87288857386

4000 000次运行的结果。结论：没关系。这是我使用的代码：

<?php

class Foo
{
  public function calling_this() { $this->called(); }
  public function calling_self() { self::called(); }
  public function calling_static() { static::called(); }
  public static function called() {}
}

$foo = new Foo();
$n = 4000000;
$times = [];

// warmup
for ($i = 0; $i < $n; $i++) { $foo->calling_this(); }
for ($i = 0; $i < $n; $i++) { $foo->calling_self(); }
for ($i = 0; $i < $n; $i++) { $foo->calling_static(); }

$start = microtime(true);
for ($i = 0; $i < $n; $i++) { $foo->calling_this(); }
$times["this"] = microtime(true)-$start;

$start = microtime(true);
for ($i = 0; $i < $n; $i++) { $foo->calling_self(); }
$times["self"] = microtime(true)-$start;

$start = microtime(true);
for ($i = 0; $i < $n; $i++) { $foo->calling_static(); }
$times["static"] = microtime(true)-$start;

$min = min($times);
echo $times["this"] . "\t" . ($times["this"] / $min)*100 . "\n";
echo $times["self"] . "\t" . ($times["self"] / $min)*100 . "\n";
echo $times["static"] . "\t" . ($times["static"] / $min)*100 . "\n";