PHP类与对象

PHP 5 中的新特性包括访问控制，抽象类和 final 类与方法，附加的魔术方法，接口，对象复制和类型约束。

每个类的定义都以关键字 class 开头，后面跟着类名，后面跟着一对花括号，里面包含有类的属性与方法的定义。

类名可以是任何非 PHP 保留字的合法标签。一个合法类名以字母或下划线开头，后面跟着若干字母，数字或下划线。以正则表达式表示为：[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*。

一个类可以包含有属于自己的常量，变量（称为“属性”）以及函数（称为“方法”）。

---

简单的类定义

<?phpclass SimpleClass{    // property declaration    public $var = 'a default value';    // method declaration    public function displayVar() {        echo $this->var;    }}?>

伪变量 $this，代表当前对象，谁调用的就代表该对象。

new
要创建一个类的实例，必须使用 new 关键字

<?php$instance = new SimpleClass();// 也可以这样做：$className = 'Foo';$instance = new $className(); // Foo()?>

extends

一个类可以在声明中用 extends 关键字继承另一个类的方法和属性。PHP不支持多重继承，一个类只能继承一个基类。

::class

自 PHP 5.5 起，关键词 class 也可用于类名的解析。使用 ClassName::class 你可以获取一个字符串，包含了类 ClassName 的完全限定名称。这对使用了 命名空间 的类尤其有用。

<?phpnamespace NS {    class ClassName {    }    echo ClassName::class;}?>

以上例程会输出：
NS\ClassName

---

属性
类的变量成员叫做“属性”，或者叫“字段”、“特征”，在本文档统一称为“属性”。

属性声明是由关键字 public，protected 或者 private 开头，然后跟一个普通的变量声明来组成

方法调用：

在类的成员方法里面，可以用 ->（对象运算符）：$this->property（其中 property 是该属性名）这种方式来访问非静态属性。静态属性则是用 ::（双冒号）：self::$property 来访问。

类常量

常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用。

接口（interface）中也可以定义常量。

通过const来定义常量：
const constant = ‘constant value’;

自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字（如 self，parent 或 static）。

<?phpclass MyClass{    const constant = 'constant value';    function showConstant() {        echo  self::constant . "\n";    }}echo MyClass::constant . "\n";$classname = "MyClass";echo $classname::constant . "\n"; // 自 5.3.0 起$class = new MyClass();$class->showConstant();echo $class::constant."\n"; // 自 PHP 5.3.0 起?>

自动加载类

---

构造函数和析构函数

构造函数格式：

void __construct ([ mixed args[,… ]] )

<?phpclass BaseClass {   function __construct() {       print "In BaseClass constructor\n";   }}class SubClass extends BaseClass {   function __construct() {       parent::__construct();       print "In SubClass constructor\n";   }}class OtherSubClass extends BaseClass {    // inherits BaseClass's constructor}// In BaseClass constructor$obj = new BaseClass();// In BaseClass constructor// In SubClass constructor$obj = new SubClass();// In BaseClass constructor$obj = new OtherSubClass();?>

析构函数

PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言，如 C++。析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。

<?phpclass MyDestructableClass {   function __construct() {       print "In constructor\n";       $this->name = "MyDestructableClass";   }   function __destruct() {       print "Destroying " . $this->name . "\n";   }}$obj = new MyDestructableClass();?>

和构造函数一样，父类的析构函数不会被引擎暗中调用。要执行父类的析构函数，必须在子类的析构函数体中显式调用 parent::__destruct()。此外也和构造函数一样，子类如果自己没有定义析构函数则会继承父类的。

---

访问控制（可见性）
对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的

属性或者方法如果没有关键字修饰，默认都是公有的。

---

对象继承

当扩展一个类，子类就会继承父类所有公有的和受保护的方法。除非子类覆盖了父类的方法，被继承的方法都会保留其原有功能。

除非使用了自动加载，否则一个类必须在使用之前被定义。如果一个类扩展了另一个，则父类必须在子类之前被声明。此规则适用于类继承其它类与接口。

---

范围解析操作符 （::）

可以用于访问静态成员，类常量，还可以用于覆盖类中的属性和方法。

自 PHP 5.3.0 起，可以通过变量来引用类，该变量的值不能是关键字（如 self，parent 和 static）。

<?phpclass MyClass {    const CONST_VALUE = 'A constant value';}$classname = 'MyClass';echo $classname::CONST_VALUE; // 自 PHP 5.3.0 起echo MyClass::CONST_VALUE;?>

在类定义内部使用 ::

<?phpclass OtherClass extends MyClass{    public static $my_static = 'static var';    public static function doubleColon() {        echo parent::CONST_VALUE . "\n";        echo self::$my_static . "\n";    }}$classname = 'OtherClass';echo $classname::doubleColon(); // 自 PHP 5.3.0 起OtherClass::doubleColon();?>

Static（静态）关键字

声明类属性或方法为静态，就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。

抽象类

PHP 5 支持抽象类和抽象方法。定义为抽象的类不能被实例化。任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。

<?phpabstract class AbstractClass{ // 强制要求子类定义这些方法    abstract protected function getValue();    abstract protected function prefixValue($prefix);    // 普通方法（非抽象方法）    public function printOut() {        print $this->getValue() . "\n";    }}class ConcreteClass1 extends AbstractClass{    protected function getValue() {        return "ConcreteClass1";    }    public function prefixValue($prefix) {        return "{$prefix}ConcreteClass1";    }}class ConcreteClass2 extends AbstractClass{    public function getValue() {        return "ConcreteClass2";    }    public function prefixValue($prefix) {        return "{$prefix}ConcreteClass2";    }}$class1 = new ConcreteClass1;$class1->printOut();echo $class1->prefixValue('FOO_') ."\n";$class2 = new ConcreteClass2;$class2->printOut();echo $class2->prefixValue('FOO_') ."\n";?>

对象接口
接口和java中的接口类似

接口是通过 interface 关键字来定义的
接口中定义的所有方法都必须是公有，这是接口的特性。
要实现一个接口，使用 implements 操作符
实现多个接口时，接口中的方法不能有重名。
接口也可以继承，通过使用 extends 操作符。
类要实现接口，必须使用和接口中所定义的方法完全一致的方式。否则会导致致命错误。

<?php// 声明一个'iTemplate'接口interface iTemplate{    public function setVariable($name, $var);    public function getHtml($template);}// 实现接口// 下面的写法是正确的class Template implements iTemplate{    private $vars = array();    public function setVariable($name, $var)    {        $this->vars[$name] = $var;    }    public function getHtml($template)    {        foreach($this->vars as $name => $value) {            $template = str_replace('{' . $name . '}', $value, $template);        }        return $template;    }}// 下面的写法是错误的，会报错，因为没有实现 getHtml()：// Fatal error: Class BadTemplate contains 1 abstract methods// and must therefore be declared abstract (iTemplate::getHtml)class BadTemplate implements iTemplate{    private $vars = array();    public function setVariable($name, $var)    {        $this->vars[$name] = $var;    }}?>

Trait

匿名类
PHP 7 开始支持匿名类。 匿名类很有用，可以创建一次性的简单对象。

<?php// PHP 7 之前的代码class Logger{    public function log($msg)    {        echo $msg;    }}$util->setLogger(new Logger());// 使用了 PHP 7+ 后的代码$util->setLogger(new class {    public function log($msg)    {        echo $msg;    }});

重载
和其他语言中的重载不是一码事
PHP所提供的”重载”（overloading）是指动态地”创建”类属性和方法

当调用当前环境下未定义或不可见的类属性或方法时，重载方法会被调用。

所有的重载方法都必须被声明为 public。

属性重载：

public void __set ( string $name , mixed $value )public mixed __get ( string $name )public bool __isset ( string $name )public void __unset ( string $name )

在给不可访问属性赋值时，__set() 会被调用。

读取不可访问属性的值时，__get() 会被调用。

当对不可访问属性调用 isset() 或 empty() 时，__isset() 会被调用。

当对不可访问属性调用 unset() 时，__unset() 会被调用。

参数 $name 是指要操作的变量名称。__set() 方法的 $value 参数指定了 $name 变量的值。 

<?phpclass PropertyTest {     /**  被重载的数据保存在此  */    private $data = array();     /**  重载不能被用在已经定义的属性  */    public $declared = 1;     /**  只有从类外部访问这个属性时，重载才会发生 */    private $hidden = 2;    public function __set($name, $value)     {        echo "Setting '$name' to '$value'\n";        $this->data[$name] = $value;    }    public function __get($name)     {        echo "Getting '$name'\n";        if (array_key_exists($name, $this->data)) {            return $this->data[$name];        }        $trace = debug_backtrace();        trigger_error(            'Undefined property via __get(): ' . $name .            ' in ' . $trace[0]['file'] .            ' on line ' . $trace[0]['line'],            E_USER_NOTICE);        return null;    }    /**  PHP 5.1.0之后版本 */    public function __isset($name)     {        echo "Is '$name' set?\n";        return isset($this->data[$name]);    }    /**  PHP 5.1.0之后版本 */    public function __unset($name)     {        echo "Unsetting '$name'\n";        unset($this->data[$name]);    }    /**  非魔术方法  */    public function getHidden()     {        return $this->hidden;    }}echo "<pre>\n";$obj = new PropertyTest;$obj->a = 1;echo $obj->a . "\n\n";var_dump(isset($obj->a));unset($obj->a);var_dump(isset($obj->a));echo "\n";echo $obj->declared . "\n\n";echo "Let's experiment with the private property named 'hidden':\n";echo "Privates are visible inside the class, so __get() not used...\n";echo $obj->getHidden() . "\n";echo "Privates not visible outside of class, so __get() is used...\n";echo $obj->hidden . "\n";?>

输出：
Setting ‘a’ to ‘1’
Getting ‘a’
1

Is ‘a’ set?
bool(true)
Unsetting ‘a’
Is ‘a’ set?
bool(false)

1

Let’s experiment with the private property named ‘hidden’:
Privates are visible inside the class, so __get() not used…
2
Privates not visible outside of class, so __get() is used…
Getting ‘hidden’

方法重载

public mixed __call ( string $name , array $arguments )public static mixed __callStatic ( string $name , array $arguments )

在对象中调用一个不可访问方法时，__call() 会被调用。

在静态上下文中调用一个不可访问方法时，__callStatic() 会被调用。

$name 参数是要调用的方法名称。$arguments 参数是一个枚举数组，包含着要传递给方法 $name 的参数。 

使用 __call() 和 __callStatic() 对方法重载

<?phpclass MethodTest {    public function __call($name, $arguments)     {        // 注意: $name 的值区分大小写        echo "Calling object method '$name' "             . implode(', ', $arguments). "\n";    }    /**  PHP 5.3.0之后版本  */    public static function __callStatic($name, $arguments)     {        // 注意: $name 的值区分大小写        echo "Calling static method '$name' "             . implode(', ', $arguments). "\n";    }}$obj = new MethodTest;$obj->runTest('in object context');MethodTest::runTest('in static context');  // PHP 5.3.0之后版本?>

以上例程会输出

Calling object method ‘runTest’ in object context
Calling static method ‘runTest’ in static context

遍历对象
PHP 5 提供了一种定义对象的方法使其可以通过单元列表来遍历，例如用 foreach 语句。默认情况下，所有可见属性都将被用于遍历

简单的对象遍历

<?phpclass MyClass{    public $var1 = 'value 1';    public $var2 = 'value 2';    public $var3 = 'value 3';    protected $protected = 'protected var';    private   $private   = 'private var';    function iterateVisible() {       echo "MyClass::iterateVisible:\n";       foreach($this as $key => $value) {           print "$key => $value\n";       }    }}$class = new MyClass();foreach($class as $key => $value) {    print "$key => $value\n";}echo "\n";$class->iterateVisible();?>

更进一步，可以实现 Iterator 接口。可以让对象自行决定如何遍历以及每次遍历时那些值可用。

可以用 IteratorAggregate 接口以替代实现所有的 Iterator 方法。IteratorAggregate 只需要实现一个方法 IteratorAggregate::getIterator()，其应返回一个实现了 Iterator 的类的实例。

魔术方法

---

Final 关键字

PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

对象复制
对象复制可以通过 clone 关键字来完成。

$copy_of_object = clone $object;

当复制完成时，如果定义了 __clone() 方法，则新创建的对象（复制生成的对象）中的 __clone() 方法会被调用，可用于修改属性的值（如果有必要的话）。

<?phpclass SubObject{    static $instances = 0;    public $instance;    public function __construct() {        $this->instance = ++self::$instances;    }    public function __clone() {        $this->instance = ++self::$instances;    }}class MyCloneable{    public $object1;    public $object2;    function __clone()    {        // 强制复制一份this->object， 否则仍然指向同一个对象        $this->object1 = clone $this->object1;    }}$obj = new MyCloneable();$obj->object1 = new SubObject();$obj->object2 = new SubObject();$obj2 = clone $obj;print("Original Object:\n");print_r($obj);print("Cloned Object:\n");print_r($obj2);?>

对象比较

比较运算符（==）：比较的原则是：如果两个对象的属性和属性值 都相等，而且两个对象是同一个类的实例，那么这两个对象变量相等。

全等运算符（===）：这两个对象变量一定要指向某个类的同一个实例（即同一个对象）。

<?phpfunction bool2str($bool){    if ($bool === false) {        return 'FALSE';    } else {        return 'TRUE';    }}function compareObjects(&$o1, &$o2){    echo 'o1 == o2 : ' . bool2str($o1 == $o2) . "\n";    echo 'o1 != o2 : ' . bool2str($o1 != $o2) . "\n";    echo 'o1 === o2 : ' . bool2str($o1 === $o2) . "\n";    echo 'o1 !== o2 : ' . bool2str($o1 !== $o2) . "\n";}class Flag{    public $flag;    function Flag($flag = true) {        $this->flag = $flag;    }}class OtherFlag{    public $flag;    function OtherFlag($flag = true) {        $this->flag = $flag;    }}$o = new Flag();$p = new Flag();$q = $o;$r = new OtherFlag();echo "Two instances of the same class\n";compareObjects($o, $p);echo "\nTwo references to the same instance\n";compareObjects($o, $q);echo "\nInstances of two different classes\n";compareObjects($o, $r);?>

输出：
Two instances of the same class
o1 == o2 : TRUE
o1 != o2 : FALSE
o1 === o2 : FALSE
o1 !== o2 : TRUE

Two references to the same instance
o1 == o2 : TRUE
o1 != o2 : FALSE
o1 === o2 : TRUE
o1 !== o2 : FALSE

Instances of two different classes
o1 == o2 : FALSE
o1 != o2 : TRUE
o1 === o2 : FALSE
o1 !== o2 : TRUE

类型约束
方法中的参数变量加上了类型

public function test(OtherClass $otherclass) {        echo $otherclass->var;    } /**     * 另一个测试函数     * 第一个参数必须为数组      */    public function test_array(array $input_array)     {        print_r($input_array);    } /**     * 第一个参数必须为回调类型     */    public function test_callable(callable $callback, $data) {        call_user_func($callback, $data);    }

后期静态绑定

self:: 的限制
使用 self:: 或者 CLASS 对当前类的静态引用，取决于定义当前方法所在的类：

<?phpclass A {    public static function who() {        echo __CLASS__;    }    public static function test() {        self::who();    }}class B extends A {    public static function who() {        echo __CLASS__;    }}B::test();?>

输出 A

后期静态绑定的用法
后期静态绑定本想通过引入一个新的关键字表示运行时最初调用的类来绕过限制。简单地说，这个关键字能够让你在上述例子中调用 test() 时引用的类是 B 而不是 A。最终决定不引入新的关键字，而是使用已经预留的 static 关键字。

<?phpclass A {    public static function who() {        echo __CLASS__;    }    public static function test() {        static::who(); // 后期静态绑定从这里开始    }}class B extends A {    public static function who() {        echo __CLASS__;    }}B::test();?>

输出B

后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。另一方面，如果静态调用使用 parent:: 或者 self:: 将转发调用信息。

<?phpclass A {    public static function foo() {        static::who();    }    public static function who() {        echo __CLASS__."\n";    }}class B extends A {    public static function test() {        A::foo();        parent::foo();        self::foo();    }    public static function who() {        echo __CLASS__."\n";    }}class C extends B {    public static function who() {        echo __CLASS__."\n";    }}C::test();?>

以上例程会输出：

A
C
C

对象和引用

PHP 的引用是别名，就是两个不同的变量名字指向相同的内容。在 PHP 5，一个对象变量已经不再保存整个对象的值。只是保存一个标识符来访问真正的对象内容。 当对象作为参数传递，作为结果返回，或者赋值给另外一个变量，另外一个变量跟原来的不是引用的关系，只是他们都保存着同一个标识符的拷贝，这个标识符指向同一个对象的真正内容。

注意标识符的拷贝和引用的区别

<?phpclass A {    public $foo = 1;}  $a = new A;$b = $a;     // $a ,$b都是同一个标识符的拷贝             // ($a) = ($b) = <id>$b->foo = 2;echo $a->foo."\n";$c = new A;$d = &$c;    // $c ,$d是引用             // ($c,$d) = <id>$d->foo = 2;echo $c->foo."\n";$e = new A;function foo($obj) {    // ($obj) = ($e) = <id>    $obj->foo = 2;}foo($e);echo $e->foo."\n";?>

以上例程会输出：

2
2
2

对象序列化

所有php里面的值都可以使用函数serialize()来返回一个包含字节流的字符串来表示。unserialize()函数能够重新把字符串变回php原来的值。 序列化一个对象将会保存对象的所有变量，但是不会保存对象的方法，只会保存类的名字。

<?php// classa.inc:  class A {      public $one = 1;      public function show_one() {          echo $this->one;      }  }// page1.php:  include("classa.inc");  $a = new A;  $s = serialize($a);  // 把变量$s保存起来以便文件page2.php能够读到  file_put_contents('store', $s);// page2.php:  // 要正确了解序列化，必须包含下面一个文件  include("classa.inc");  $s = file_get_contents('store');  $a = unserialize($s);  // 现在可以使用对象$a里面的函数 show_one()  $a->show_one();?>

OOP 变更日志