访问控制
属性和方法的访问控制（可见标识）：
public 任何地方private 类自身protected 类自身，自子类及自父类 this
this 可以理解为这个类的一个实例
self
self 代表类本身
__construct
实例化时就会自动执行
public function __construct() {} __destruct
当对象对销毁时自动执行
public function __destruct(){} 类常量
定义合不可改变
const ONE = 1
const TWO = self::ONE + 1; 可以在类外部调用
Class::Two parent
parent代表父类
public function __construct(){ parent::__construct();} final
final class Dad(){} 加到类定义前面表示Dad类不想被继承
class Dad(){ final public function run(){} // 加到方法声明前面，表示方法不想被子类重写} namespace
namespace必须放在代码文件的第一行
namespace关键字指定命名空间时，当前脚本是存在于全局命名空间的。用\表示。\Class1类全在指定的命名空间去查找，没找到则抛出错误。函数与常量，在指定命名空间查找，没找到则到全局命名空间查找，还没打到则抛错。 函数
ns1\ns2\fn()
常量
define定义的常量是全局的，不受命名空间影响。
const定义的常量受命名空间影响。 namespace ns1\ns2;const ONE = 1;echo ns1\ns2\ONE;
use
导入类
用use导入命名空间下的类
use ns1\ns2\class1; 用as重命名导入的类
use ns1\ns2\class1 as class2; 导入函数
use function ns1\ns2\fn as fn1;
导入常量
use const ns1\ns2\ONE;
自动加载
__autoload
function __autoload($className){ require $className . '.php';} spl_autoload_register
传匿名函数
spl_autoload_register(function($className){ require $className . '.php'; }); 传函数名
function test($className){ require $className . '.php'; }spl_autoload_register('test'); 传类
class Momo{ function autoload($className) { require $className . '.php'; }}spl_autoload_register([new Momo, 'autoload']); static
声明静态属性和静态方法，不经过实例化，通过类名即可调用。
class Person(){ public static $hand = '手'; public static function run() { echo 'running...'; }}echo Person::$hand;Person::run(); 类内部调用静态属性和静态方法用self关键字
echo self::$hand; self::run();
调用父类的静态属性和静态方法用parent关键字
echo parent::$hand; parent::run();
后期静态绑定
class A{ public static function who() { echo 'A类的who方法'; } public static function test1() { self::who(); } public static function test2() { static::who(); }}class B extends A{ public static function who() { echo 'B类的who方法'; }}B::test1(); // test1内部用的self，调用的是自身（A类）的静态方法B::test2(); // 后期绑定。内部用static，根据后期的调用环境确定，调用的是B类的静态方法 魔术方法
__set
class Test{ private $name = ''; public function __set($var, $val) { // 对$val进行数据处理 $this->$var = $val; }}$test = new Test();$test->name = 'tom'; // 赋值tom __get
class Test{ private $name = 'jack'; public function __get($var) { return $this->$var; }}$test = new Test();echo $test->name; // jack __isset
用于检测私有属性是否存在
class Test{ private $name = 'mary'; public function __isset($var) { return isset($this->$var); }}$test = new Test();var_dump($test->name); // 如果不设置__isset，返回false,设置后返回true __unset
用于删除私有属性
class Test{ private $name = 'Levi'; public function __unset($var) { unset() }}$test = new Test;unset($test->name); // 会触发__unset __call
避免调用一个不存在的方法时产生错误，当调用的方法不存在时，__call方法会自动调用
class Test{ public function __call($fn_name, $fn_arguments) { echo $fn_name; print_r($fn_arguments); }}$test = new Test();$test->go(1, 'ok'); // 自动调用`__call`方法，打印出函数名和参数数组 __callStatic
同__call类似
class Test{ public static function __callStatic($fn_name, $fn_arguments) { echo $fn_name; print_r($fn_arguments); }}// `__callStatic` 必须声明为静态方法Test::go(1, 'ok'); __invoke
当对象以函数的形式调用的时候，自动调用__invoke方法
class Test{ public function __invoke($args) { return $args; }}$test = new Test();$test('go.....'); // 运行__invoke __toString
当打印对象是会调用__toString方法
class Test{ public function __toString() { return 'Hello world!'; }}$test = new Test;echo $test; // 输出 Hello world! 对象复制
浅拷贝
比较省内存，对象的拷贝默认是浅拷贝。
$a = new Test();$b = $a; // 浅拷贝。传址。改变$b。$a也会改变。
对象的复制是浅拷贝的。传址。
普通变量的拷贝是深拷贝的。传值。深拷贝
$a = new Test();$b = clone $a; // 深拷贝。改变$b，不会改变$a。
__clone
当使用clone关键字时，自动调用__clone方法
class Test{ public $obj = null; public function __clone() { $this->obj = clone $this->obj; }}class Person{ public $sex = 0;}$a = new Test;$a->obj = new Person;$b = clone $a; // 触发`__clone` 对obj进行深拷贝$b->obj->sex = 1; // $b中的obj对象改变了。而$a中的obj对象没变。 类型约束
class A{ public function go() { echo 'go .....'; }}function test(A $a) { $a->go();}test(new A()); Trait
单继承语言PHP的代码复用机制。
Trait Bt{ public function atest() { echo 'Hello '; } public function btest() { echo 'world'; } public function ab() { $this->atest(); $this->btest(); }}class Test{ use Bt; // 使用Bt Trait，便拥有了Bt所有的方法}$test = new Test;$test->ab(); 继承多个Trait
Trait A{ public $name = 'tom'; public function a() { echo 'Hello '; }}Trait B{ public function b() { echo 'world '; }}class Test{ use A,B; public function c() { echo $this->name; }}$test = new Test;$test->a();$test->b();$test->c(); // Hello world tom Trait 支持嵌套
Trait A{}Trait B{}Trait C{ use A,B;}Class Test{ use C;} interface
接口是类的模板。在接口中只定义需要实现的空方法，这些方法在接口中不做具体实现。
接口是不能被实例化的。Interface Person{ public function eat(); public function sleep();}class man implements Person{ public function eat() { echo 'eating...'; } public function sleep() { echo 'sleeping...'; }}class L{ public static function factory(Person $user) // 用接口作类型约束 { return $user; }}$user = L::factory(new Man());$user->eat();$user->sleep(); 接口可以继承接口。
接口可以继承多个接口。接口可以使用常量，叫接口常量，和类的常量使用方法相同Interface Ia{ const ONE = 1; public function eat();}Interface Ib{ public function sleep();}Interface AB extends Ia,Ib{}// class Test implements Ia,Ib 类可以同时继承多个接口class Test implements AB{ public function eat() { echo 'eating...'; } public function sleep() { echo 'sleeping...'; }}$test = new Test;$test->eat();$test->sleep();echo Ia::ONE; // 使用接口常量 abstract
抽象类不能被实例化。
如果至少有一个方法被声明为抽象的，那么这个类必须被声明为抽象的。抽象方法只能声明，不能有具体功能实现。抽象类可以有被实现的的方法。继承抽象类，子类必须实现父类中所有的抽象方法。
这些方法的访问控制必须和父类一样，或者更宽松，不能比父类更严格。方法的调用方式也必须匹配。类型和参数数量必须一致，但子类可以定义父类中不存在的可选参数。abstract AB{ public function run() { echo 'running...'; } abstract public function eat(); abstract public function sleep();}class Test extends AB{ public function eat() { echo 'eating...'; } public function sleep($time = '21:00 PM') // 可以定义父类方法中不存在的可选参数 { echo 'sleep @ ' . $time; }} 单例模式
只能被实例化一次，节省内存空间
class Test{ private static $instance = null; private function __constrct() {} private function __clone() {} public static function getInstance() { if (!(self::instance instanceof self)) { self::instance = new self(); } return self::instance; }}$test = Test::getInstance(); // 多次调用也只是实例化一次 工厂模式
Interface CacheI{ public function set($key, $value); public function get($key); public function delete($key);}class Memcache implements CacheI{ public function set($key, $value){} public function get($key){} public function delete($ke){}}class Redis implements CacheI{ public function set($key, $value){} public function get($key){} public function delete($ke){}}class Cache{ public static function factory() { return new Memcache(); // 这里可以是继承了CacheI接口的任何类，比如Redis }}$cache = Cache::factory();$cache->set('name', 'tom');$cache->get('name');$cache->delete('name');