php类与对象易错笔记分享
本文主要和大家分享的是php类与对象易错笔记,信息量很大,但是对于学php的人来说很有帮助,希望能帮助到大家。
new:如果在 new 之后跟着的是一个包含有类名的字符串,则该类的一个实例被创建。如果该类属于一个名字空间,则必须使用其完整名称。
Example #3 创建一个实例
<?php$instance = new stdClass();// 也可以这样做:$className = 'stdClass';$instance = new $className(); // Foo()?>
在类定义内部,可以用new self
和new parent
创建新对象。
PHP 5.3.0 引进了两个新方法来创建一个对象的实例:
<?phpclass Test{ static public function getNew()//单例模式可以使用此方法 { return new static; }} class Child extends Test {}$obj1 = new Test();$obj2 = new $obj1;var_dump($obj1 !== $obj2);//bool(true)$obj3 = Test::getNew();var_dump($obj3 instanceof Test);//bool(true)$obj4 = Child::getNew();var_dump($obj4 instanceof Child);//bool(true)?>
自 PHP 5.5 起,关键词 class
也可用于类名的解析:ClassName::class
当把一个对象已经创建的实例赋给一个新变量时,新变量会访问同一个实例,就和用该对象赋值一样。此行为和给函数传递入实例时一样。可以用克隆给一个已创建的对象建立一个新实例。
<?php Class Object{ public $foo="bar";};$objectVar = new Object();$reference =& $objectVar;$assignment = $objectVar;$cloneObj = clone $objectVar;$objectVar->foo = "qux";var_dump( $objectVar );var_dump( $reference );var_dump( $assignment );var_dump( $cloneObj );echo '--------------------', PHP_EOL;$objectVar = null;var_dump($objectVar);var_dump($reference);var_dump($assignment);var_dump($cloneObj);/*Result:object(Object)#1 (1) { ["foo"]=> string(3) "qux"}object(Object)#1 (1) { ["foo"]=> string(3) "qux"}object(Object)#1 (1) { ["foo"]=> string(3) "qux"}object(Object)#2 (1) { ["foo"]=> string(3) "bar"}--------------------NULLNULLobject(Object)#1 (1) { ["foo"]=> string(3) "qux"}object(Object)#2 (1) { ["foo"]=> string(3) "bar"}*/
类的自动加载
spl_autoload_register()
函数可以注册任意数量的自动加载器,当使用尚未被定义的类(class)和接口(interface)时自动去加载。通过注册自动加载器,脚本引擎在 PHP 出错失败前有了最后一个机会加载所需的类。
尽管__autoload()
函数也能自动加载类和接口,但更建议使用spl_autoload_register()
函数。spl_autoload_register()
提供了一种更加灵活的方式来实现类的自动加载(同一个应用中,可以支持任意数量的加载器,比如第三方库中的)。因此,不再建议使用 __autoload() 函数,在以后的版本中它可能被弃用。
Example #1 自动加载示例
本例尝试分别从 MyClass1.php 和 MyClass2.php 文件中加载 MyClass1 和 MyClass2 类。
<?phpspl_autoload_register(function ($class_name) { require_once $class_name . '.php';});$obj = new MyClass1();$obj2 = new MyClass2();?>
构造函数和析构函数
Note: 如果子类中定义了构造函数则不会隐式调用其父类的构造函数。要执行父类的构造函数,需要在子类的构造函数中调用parent::__construct()
。如果子类没有定义构造函数则会如同一个普通的类方法一样从父类继承(假如没有被定义为 private 的话)。和构造函数一样,父类的析构函数不会被引擎暗中调用。要执行父类的析构函数,必须在子类的析构函数体中显式调用
parent::__destruct()
。此外也和构造函数一样,子类如果自己没有定义析构函数则会继承父类的。析构函数即使在使用 exit() 终止脚本运行时也会被调用。在析构函数中调用 exit() 将会中止其余关闭操作的运行。
访问控制(可见性)
类属性必须定义为公有
,受保护
,私有
之一。如果用 var 定义,则被视为公有。
类中的方法可以被定义为公有
,私有
或受保护
。如果没有设置这些关键字,则该方法默认为公有。
同一个类的对象即使不是同一个实例也可以互相访问对方的私有与受保护成员。这是由于在这些对象的内部具体实现的细节都是已知的。
Example #3 访问同一个对象类型的私有成员
<?phpclass Test{ private $foo; public function __construct($foo) { $this->foo = $foo; } private function bar() { echo 'Accessed the private method.'; } public function baz(Test $other) { // We can change the private property: $other->foo = 'hello'; var_dump($other->foo); // We can also call the private method: $other->bar(); }}$test = new Test('test');$test->baz(new Test('other'));//string(5) "hello"//Accessed the private method.?>
继承和访问控制:
<?php abstract class base { public function inherited() { $this->overridden(); } private function overridden() { echo 'base'; } } class child extends base { private function overridden() { echo 'child'; } } $test = new child(); $test->inherited(); ?> Output will be "base". If you want the inherited methods to use overridden functionality in extended classes but public sounds too loose, use protected. That's what it is for:) A sample that works as intended: <?php abstract class base { public function inherited() { $this->overridden(); } protected function overridden() { echo 'base'; } } class child extends base { protected function overridden() { echo 'child'; } } $test = new child(); $test->inherited(); ?> Output will be "child".
范围解析操作符 (::)
范围解析操作符
(也可称作 Paamayim Nekudotayim)或者更简单地说是一对冒号,可以用于访问静态成员
,类常量
,还可以用于覆盖类中的属性和方法
。
访问静态变量,静态方法,常量:
<?php class A { public static $B = '1'; # Static class variable. const B = '2'; # Class constant. public static function B() { # Static class function. return '3'; } }echo A::$B . A::B . A::B(); # Outputs: 123
Example #3 调用父类的方法
<?phpclass 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();?>
Static(静态)关键字
用 static 关键字来定义静态方法
和属性
。static 也可用于定义静态变量
以及后期静态绑定
。
声明类属性或方法为静态,就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问(但静态方法可以)。
抽象类
继承一个抽象类的时候:
1.子类必须定义父类中的所有抽象方法;
2.这些方法的访问控制必须和父类中一样(或者更为宽松)。例如某个抽象方法被声明为受保护的,那么子类中实现的方法就应该声明为受保护的或者公有的,而不能定义为私有的;
3.方法的调用方式必须匹配,即类型和所需参数数量必须一致。例如,子类定义了一个可选参数,而父类抽象方法的声明里没有,则两者的声明并无冲突
。 这也适用于 PHP 5.4 起的构造函数。在 PHP 5.4 之前的构造函数声明可以不一样的;
对象接口
接口中定义的所有方法都必须是公有,这是接口的特性。
实现类必须实现接口中定义的所有方法
类可以实现多个接口,用逗号来分隔多个接口的名称。
实现多个接口时,接口中的方法不能有重名。
类要实现接口,必须使用和接口中所定义的方法完全一致的方式。
接口中也可以定义常量。接口常量和类常量的使用完全相同,但是不能被子类或子接口所覆盖。
Trait
自 PHP 5.4.0 起,PHP 实现了一种代码复用的方法,称为 trait
。
Trait 是为类似 PHP 的单继承语言而准备的一种代码复用机制。Trait 为了减少单继承语言的限制,使开发人员能够自由地在不同层次结构内独立的类中复用 method。Trait 和 Class 组合的语义定义了一种减少复杂性的方式,避免传统多继承和 Mixin 类相关典型问题。
Trait 和 Class 相似,但仅仅旨在用细粒度和一致的方式来组合功能。 无法通过 trait 自身来实例化。它为传统继承增加了水平特性的组合;也就是说,应用的几个 Class 之间不需要继承。
优先级:从基类继承的成员会被 trait 插入的成员所覆盖。优先顺序是来自当前类的成员覆盖了 trait 的方法,而 trait 则覆盖了被继承的方法。
<?phpclass Base { public function sayHello() { echo 'Hello '; }}trait SayWorld { public function sayHello() { parent::sayHello(); echo 'World!'; }}class MyHelloWorld extends Base { use SayWorld;}$o = new MyHelloWorld();$o->sayHello();//Hello World!?>
多个 trait:通过逗号分隔,在 use
声明列出多个 trait,可以都插入到一个类中。
冲突的解决:为了解决多个 trait 在同一个类中的命名冲突,需要使用 insteadof
操作符来明确指定使用冲突方法中的哪一个。
<?phptrait A { public function smallTalk() { echo 'a'; } public function bigTalk() { echo 'A'; }}trait B { public function smallTalk() { echo 'b'; } public function bigTalk() { echo 'B'; }}class Talker { use A, B { B::smallTalk insteadof A; A::bigTalk insteadof B; }}class Aliased_Talker { use A, B { B::smallTalk insteadof A; A::bigTalk insteadof B; B::bigTalk as talk; }}?>
修改方法的访问控制
:使用 as
语法还可以用来调整方法的访问控制。
<?phptrait HelloWorld { public function sayHello() { echo 'Hello World!'; }}// 修改 sayHello 的访问控制class MyClass1 { use HelloWorld { sayHello as protected; }}// 给方法一个改变了访问控制的别名// 原版 sayHello 的访问控制则没有发生变化class MyClass2 { use HelloWorld { sayHello as private myPrivateHello; }}?>
从 trait
来组成 trait
:在 trait 定义时通过使用一个或多个 trait,能够组合其它 trait 中的部分或全部成员。
<?phptrait Hello { public function sayHello() { echo 'Hello '; }}trait World { public function sayWorld() { echo 'World!'; }}trait HelloWorld { use Hello, World;}class MyHelloWorld { use HelloWorld;}$o = new MyHelloWorld();$o->sayHello();$o->sayWorld();?>
Trait 的抽象成员
:为了对使用的类施加强制要求,trait 支持抽象方法的使用。
<?phptrait Hello { public function sayHelloWorld() { echo 'Hello'.$this->getWorld(); } abstract public function getWorld();}class MyHelloWorld { private $world; use Hello; public function getWorld() { return $this->world; } public function setWorld($val) { $this->world = $val; }}?>
Trait 的静态成员
:Traits 可以被静态成员静态方法定义。
<?phpclass TestClass { public static $_bar;}class Foo1 extends TestClass { }class Foo2 extends TestClass { }Foo1::$_bar = 'Hello';Foo2::$_bar = 'World';echo Foo1::$_bar . ' ' . Foo2::$_bar; // Prints: World World?>Example using trait:<?phptrait TestTrait { public static $_bar;}class Foo1 { use TestTrait;}class Foo2 { use TestTrait;}Foo1::$_bar = 'Hello';Foo2::$_bar = 'World';echo Foo1::$_bar . ' ' . Foo2::$_bar; // Prints: Hello World?>
属性
:Trait 同样可以定义属性。
Trait 定义了一个属性后,类就不能定义同样名称的属性,否则会产生 fatal error。 有种情况例外:属性是兼容的(同样的访问可见度、初始默认值)。 在 PHP 7.0 之前,属性是兼容的,则会有 E_STRICT 的提醒。
Example #12 解决冲突
<?phptrait PropertiesTrait { public $same = true; public $different = false;}class PropertiesExample { use PropertiesTrait; public $same = true; // PHP 7.0.0 后没问题,之前版本是 E_STRICT 提醒 public $different = true; // 致命错误}?>
重载(术语滥用)
PHP所提供的"重载
"(overloading)是指动态地"创建"类属性和方法。我们是通过魔术方法(magic methods)来实现的。
当调用当前环境下未定义或不可见的类属性或方法时,重载方法会被调用。本节后面将使用"不可访问属性
(inaccessible properties)"和"不可访问方法
(inaccessible methods)"来称呼这些未定义或不可见的类属性或方法。
This is a misuse of the term overloading. This article should call this technique "interpreter hooks".
参加魔术方法php超全局变量,魔术常量,魔术方法
Note:
因为 PHP 处理赋值运算的方式,__set()
的返回值将被忽略。类似的, 在下面这样的链式赋值中,__get()
不会被调用:$a = $obj->b = 8;
Note:
在除isset()
外的其它语言结构中无法使用重载的属性,这意味着当对一个重载的属性使用empty()
时,重载魔术方法将不会被调用。
为避开此限制,必须将重载属性赋值到本地变量再使用empty()
。
遍历对象
1.用 foreach
语句。默认情况下,所有可见属性都将被用于遍历。
<?phpforeach(new class(10) { public $public = []; protected $protected = [3, 4, 5]; private $private = [6, 7, 8]; function __construct($value = 1) { for ($i=0; $i < $value; $i++) { $this->public[] = $i; } } function __destruct() { foreach ($this as $key => list($a, $b, $c)) { print "$key => [$a, $b, $c]\n"; } }} as $key => list($a, $b, $c)) { print "$key => [$a, $b, $c]\n";}echo "\n";//Result:/*public => [0, 1, 2]public => [0, 1, 2]protected => [3, 4, 5]private => [6, 7, 8] */
2.实现 Iterator
接口。可以让对象自行决定如何遍历以及每次遍历时那些值可用。
<?phpclass MyIterator implements Iterator{ private $var = array(); public function __construct($array) { if (is_array($array)) { $this->var = $array; } } public function rewind() { echo "rewinding\n"; reset($this->var); } public function current() { $var = current($this->var); echo "current: $var\n"; return $var; } public function key() { $var = key($this->var); echo "key: $var\n"; return $var; } public function next() { $var = next($this->var); echo "next: $var\n"; return $var; } public function valid() { $var = $this->current() !== false; echo "valid: {$var}\n"; return $var; }}$values = array(1,2,3);$it = new MyIterator($values);foreach ($it as $a => $b) { print "$a: $b\n";}?>
可以用 IteratorAggregate
接口以替代实现所有的 Iterator
方法。IteratorAggregate
只需要实现一个方法 IteratorAggregate::getIterator()
,其应返回一个实现了 Iterator
的类的实例。
Example #3 通过实现 IteratorAggregate 来遍历对象
<?phpclass MyCollection implements IteratorAggregate{ private $items = array(); private $count = 0; // Required definition of interface IteratorAggregate public function getIterator() { return new MyIterator($this->items); } public function add($value) { $this->items[$this->count++] = $value; }}$coll = new MyCollection();$coll->add('value 1');$coll->add('value 2');$coll->add('value 3');foreach ($coll as $key => $val) { echo "key/value: [$key -> $val]\n\n";}?>
PHP 5.5 及以后版本的用户也可参考生成器,其提供了另一方法来定义 Iterators。
魔术方法
参见php超全局变量,魔术常量,魔术方法。
final
如果父类中的方法被声明为 final
,则子类无法覆盖
该方法。如果一个类被声明为 final,则不能被继承
。
属性
不能被定义为final
,只有类和方法才能被定义为final
。可以使用const
定义为常量来代替。
对象复制(clone)
对象复制可以通过 clone
关键字来完成(如果可能,这将调用对象的 __clone()
方法)。对象中的 __clone() 方法不能被直接调用。
当对象被复制后,PHP 5 会对对象的所有属性执行一个浅复制
(shallow copy
)。所有的引用属性
仍然会是一个指向原来的变量的引用。
对象比较
==
:如果两个对象的属性和属性值都相等,而且两个对象是同一个类的实例,那么这两个对象变量相等。===
:这两个对象变量一定要指向某个类的同一个实例(即同一个对象,但不需要引用赋值)。
<?phpfunction compareObjects(&$o1, &$o2){ echo 'o1 == o2 : ' , var_export($o1 == $o2) . "\r\n"; echo 'o1 === o2 : ' , var_export($o1 === $o2) . "\r\n";}class Flag{ public $flag; function __construct($flag = true) { $this->flag = $flag; }}class OtherFlag{ public $flag; function __construct($flag = true) { $this->flag = $flag; }}$o = new Flag;$p = new Flag;$q = $o;$r = new OtherFlag;$s = new Flag(false);echo "Two instances of the same class\r\n";compareObjects($o, $p);echo "\r\nTwo references to the same instance\r\n";compareObjects($o, $q);echo "\r\nInstances of two different classes\r\n";compareObjects($o, $r);echo "Two instances of the same class\r\n";compareObjects($o, $s);//Result:/*Two instances of the same classo1 == o2 : trueo1 === o2 : falseTwo references to the same instanceo1 == o2 : trueo1 === o2 : trueInstances of two different classeso1 == o2 : falseo1 === o2 : falseTwo instances of the same classo1 == o2 : falseo1 === o2 : false */?>
后期静态绑定
后期静态绑定
,static::
不再被解析为定义当前方法所在的类,而是在实际运行时计算的。也可以称之为“静态绑定
”,因为它可以用于(但不限于)静态方法的调用。
Example #2 static:: 简单用法
<?phpclass A { public static function who() { echo __CLASS__; } public static function test() { self::who(); static::who(); // 后期静态绑定从这里开始 }}class B extends A { public static function who() { echo __CLASS__; }}B::test();//AB?>
Finally we can implement some ActiveRecord methods:
<?php class Model { public static function find() { echo static::$name; } } class Product extends Model { protected static $name = 'Product'; } Product::find(); ?> Output: 'Product'
对象和引用
Notes on reference:A reference is not a pointer. However, an object handle IS a pointer. Example:<?phpclass Foo { private static $used; private $id; public function __construct() { $id = $used++; } public function __clone() { $id = $used++; }}$a = new Foo; // $a is a pointer pointing to Foo object 0$b = $a; // $b is a pointer pointing to Foo object 0, however, $b is a copy of $a$c = &$a; // $c and $a are now references of a pointer pointing to Foo object 0$a = new Foo; // $a and $c are now references of a pointer pointing to Foo object 1, $b is still a pointer pointing to Foo object 0unset($a); // A reference with reference count 1 is automatically converted back to a value. Now $c is a pointer to Foo object 1$a = &$b; // $a and $b are now references of a pointer pointing to Foo object 0$a = NULL; // $a and $b now become a reference to NULL. Foo object 0 can be garbage collected nowunset($b); // $b no longer exists and $a is now NULL$a = clone $c; // $a is now a pointer to Foo object 2, $c remains a pointer to Foo object 1unset($c); // Foo object 1 can be garbage collected now.$c = $a; // $c and $a are pointers pointing to Foo object 2unset($a); // Foo object 2 is still pointed by $c$a = &$c; // Foo object 2 has 1 pointers pointing to it only, that pointer has 2 references: $a and $c;const ABC = TRUE;if(ABC) { $a = NULL; // Foo object 2 can be garbage collected now because $a and $c are now a reference to the same NULL value} else { unset($a); // Foo object 2 is still pointed to $c}
命名空间
定义命名空间
虽然任意合法的PHP代码都可以包含在命名空间中,但只有以下类型的代码受命名空间的影响,它们是:类
(包括抽象类
和traits
)、接口
、函数
和常量
。
命名空间通过关键字 namespace
来声明。如果一个文件中包含命名空间,它必须在其它所有代码之前声明命名空间,除了一个以外:declare
关键字。
define()
will define constants exactly as specified:
Regarding constants defined with define() inside namespaces...define() will define constants exactly as specified. So, if you want to define a constant in a namespace, you will need to specify the namespace in your call to define(), even if you're calling define() from within a namespace. The following examples will make it clear.The following code will define the constant "MESSAGE" in the global namespace (i.e. "\MESSAGE").<?phpnamespace test;define('MESSAGE', 'Hello world!');?>The following code will define two constants in the "test" namespace.<?phpnamespace test;define('test\HELLO', 'Hello world!');define(__NAMESPACE__ . '\GOODBYE', 'Goodbye cruel world!');echo \test\HELLO, PHP_EOL;//Hello world!echo namespace\HELLO, PHP_EOL;//Hello world!echo constant('\\'. __NAMESPACE__ . '\HELLO') , PHP_EOL;//Hello world!echo constant(__NAMESPACE__ . '\HELLO') , PHP_EOL;//Hello world!echo HELLO, PHP_EOL;//Hello world!echo __NAMESPACE__, PHP_EOL;//test?>
在同一个文件中定义多个命名空间(不建议)
也可以在同一个文件中定义多个命名空间。在同一个文件中定义多个命名空间有两种语法形式:简单组合语法
和大括号语法
。
Example #4 定义多个命名空间和不包含在命名空间中的代码
<?phpdeclare(encoding='UTF-8');namespace MyProject {const CONNECT_OK = 1;class Connection { /* ... */ }function connect() { /* ... */ }}namespace { // 全局代码session_start();$a = MyProject\connect();echo MyProject\Connection::start();}?>
使用命名空间:基础
(PHP 5 >= 5.3.0, PHP 7)
在讨论如何使用命名空间之前,必须了解 PHP 是如何知道要使用哪一个命名空间中的元素的。可以将 PHP 命名空间与文件系统作一个简单的类比。在文件系统中访问一个文件有三种方式:
相对文件名形式
如foo.txt
。它会被解析为currentdirectory/foo.txt
,其中currentdirectory
表示当前目录。因此如果当前目录是/home/foo
,则该文件名被解析为/home/foo/foo.txt
。相对路径名形式
如subdirectory/foo.txt
。它会被解析为currentdirectory/subdirectory/foo.txt
。绝对路径名形式
如/main/foo.txt
。它会被解析为/main/foo.txt
。
PHP 命名空间中的元素使用同样的原理。例如,类名可以通过三种方式引用:
非限定名称
,或不包含前缀的类名称,例如$a=new foo()
; 或foo::staticmethod()
;。如果当前命名空间是currentnamespace
,foo
将被解析为currentnamespace\foo
。如果使用foo
的代码是全局的,不包含在任何命名空间中的代码,则foo
会被解析为foo
。 警告:如果命名空间中的函数或常量未定义,则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。详情参见 使用命名空间:后备全局函数名称/常量名称。限定名称
,或包含前缀的名称,例如$a = new subnamespace\foo()
; 或subnamespace\foo::staticmethod()
;。如果当前的命名空间是currentnamespace
,则foo
会被解析为currentnamespace\subnamespace\foo
。如果使用foo
的代码是全局的,不包含在任何命名空间中的代码,foo
会被解析为subnamespace\foo
。完全限定名称
,或包含了全局前缀操作符的名称,例如,$a = new \currentnamespace\foo()
; 或\currentnamespace\foo::staticmethod()
;。在这种情况下,foo
总是被解析为代码中的文字名(literal name)currentnamespace\foo
。
下面是一个使用这三种方式的实例:
file