【PHP】魔术方法 __constuct: 构建对象的时被调用；__destruct: 明确销毁对象或脚本结束时被调用；__set: 当给不可访问或不存在属性赋值时被调用__get: 读取不可访问或不存在属性时被调用__isset: 对不可访问或不存在的属性调用isset()或empty()时被调用__unset: 对不可访问或不存在的属性进行unset时被调用__call: 调用不可访问或不存在的方法时被调用__callStatic: 调用不可访问或不存在的静态方法时被调用__sleep: 当使用serialize时被调用，当你不需要保存大对象的所有数据时很有用__wakeup: 当使用unserialize时被调用，可用于做些对象的初始化操作__clone: 进行对象clone时被调用，用来调整对象的克隆行为__toString: 当一个类被转换成字符串时被调用__invoke: 当以函数方式调用对象时被调用__set_state: 当调用var_export()导出类时，此静态方法被调用。用__set_state的返回值做为var_export的返回值。__debuginfo: 当调用var_dump()打印对象时被调用（当你不想打印所有属性）适用于PHP5.6版本 <?php class Magic { public $var = 'test'; //构造函数,在创建对象的时候调用 public function __construct() { echo '__construct called'.PHP_EOL; } //某个对象的引用都被删除、对象被销毁、调用exit()后、脚本关闭时被调用 public function __destruct() { echo '__destruct called'.PHP_EOL; } //当给不可访问或不存在属性赋值时被调用 public function __set($name, $value) { echo $name.'-'.$value; echo '__set called'.PHP_EOL; } //读取不可访问或不存在属性时被调用 public function __get($name) { echo $name; echo '__get called'.PHP_EOL; } //调用不可访问或不存在的方法时被调用 public function __call($name, $arguments) { echo $name . '-' . implode(',', $arguments); echo '__call called'.PHP_EOL; } //调用不可访问或不存在的静态方法时被调用 public static function __callStatic($name, $arguments) { echo $name . '-' . implode(',', $arguments); echo '__callStatic called'.PHP_EOL; } //对不可访问或不存在的属性调用isset()或empty()时被调用 public function __isset($name) { echo $name; echo '__isset called'.PHP_EOL; return true; } //对不可访问或不存在的属性进行unset时被调用 public function __unset($name) { echo $name; echo '__unset called'.PHP_EOL; } //serialize时被调用，当你不需要保存大对象的所有数据时很有用 public function __sleep() { echo '__sleep called'.PHP_EOL; return array('var1111111111'); } //unserialize时被调用，可用于做些对象的初始化操作 public function __wakeup() { echo '__wakeup called'.PHP_EOL; $this->var = 'test after wakeup'; } //当一个类被转换成字符串时被调用 public function __toString() { return '__toString called'.PHP_EOL; } //进行对象clone时被调用，用来调整对象的克隆行为 public function __clone() { echo '__clone called'.PHP_EOL; } //当以函数方式调用对象时被调用 public function __invoke() { echo '__invoke called'.PHP_EOL; } //当调用var_export()导出类时，此静态方法被调用。用__set_state的返回值做为var_export的返回值。 public static function __set_state($arr) { return '__set_state called'.PHP_EOL; } //当调用var_dump()打印对象时被调用（当你不想打印所有属性）适用于PHP5.6版本 public function __debuginfo($arr) { echo '__debuginfo called'.PHP_EOL; return array( 'var' => 'test fro __debuginfo' ); } } $m = new Magic(); //__construct()被调用 $m->not_exist_property = test; //__set()被调用 echo $m->not_exist_property;//__get()被调用 $m->abc(1,2,3); //__call()被调用 echo isset($m->not_exist_property); //__isset()被调用，返回bool值 unset($m->not_exist_property); //__unset()被调用 echo $tmp = serialize($m); //__sleep()被调用 unserialize($tmp); //__wakeup()被调用 $m1 = clone $m; //__clone()被调用，对象默认是引用传递，使用clone关键词则可实现对象复制 $m(); //__invoke() eval( '$m2 = ' . var_export ( $m , true ) . ';' );var_dump($m2); var_dump($m); //最后__destruct()被调用 /* 结果： __construct called not_exist_property-test__set called not_exist_property__get called abc-1,2,3__call called not_exist_property__isset called 1not_exist_property__unset called __sleep called O:5:"Magic":1:{s:13:"var1111111111";N;}__wakeup called __destruct called __clone called __invoke called string(20) "__set_state called " class Magic#1 (1) { public $var => string(4) "test" } __destruct called __destruct called */

【PHP】面向对象 - 魔术方法（集合） 构造函数和析构函数构造函数：PHP5可以在类中使用__construct()定义一个构造函数，具有构造函数的类，会在每次对象创建的时候调用该函数，因此常用来在对象创建的时候进行一些初始化工作。构造函数可以接受参数，能够在创建对象时赋值给对象属性构造函数可以调用类方法或其他函数构造函数可以调用其他类的构造函数PHP中的子类的构造函数不会主动调用父类的构造函数，要显示的使用parent::__construct()调用：也可以使用类名直接调用构造函数 private $name; public function __construct($name){ $this->setName($name); parent::__construct($name);//调用父类构造函数 Animal::__construct($name); // 调用Animal构造函数 }析构函数析构函数指的是当某个对象的所有引用被删除，或者对象被显式的销毁时会执行的函数。析构函数是在销毁对象时自动调用，不能显示的调用析构函数不能带参数要执行父类的析构函数，必须在子类的析构函数中显示调用parent::__destruct()以下几种情况可能会调用析构函数：页面加载完毕、unset()、变量引用指向别的对象或值时 <?php class test{ function __destruct(){ echo "当对象销毁时会调用！！！"; } } $a = $b = $c = new test(); unset($b); ?>私有属性的设置获取实际应用中，经常会把类的属性设置为私有（private），那么需要对属性进行访问时，就会变得麻烦。虽然可以将对属性的访问写成一个方法来实现，但 PHP 提供了一些特殊方法来方便此类操作。_set() 方法用于设置私有属性值；在类里面使用了 __set() 方法后，当使用 $p1->name = "张三"; 这样的方式去设置对象私有属性的值时，就会自动调用 __set() 方法来设置私有属性的值。function __set($property_name, $value){ $this->$property_name = $value; }_get() 方法用于获取私有属性值function __get($property_name, $value){ return isset($this->$property_name) ? $this->$property_name : null; }_isset() 方法用于检测私有属性是否被设置；如果对象里面成员是公有的，可以直接使用 isset() 函数。如果是私有的成员属性，那就需要在类里面加上一个 __isset() 方法： private function __isset($property_name){ return isset($this->$property_name); }_unset() 方法用于删除私有属性；同 isset() 函数一样，unset() 函数只能删除对象的公有成员属性，当要删除对象内部的私有成员属性时，需要使用__unset() 方法： private function __unset($property_name){ unset($this->$property_name); }__toString()方法__toString() 是快速获取对象的字符串信息的魔术方法，它在直接输出对象引用时自动调用。__toString() 的作用：当我们调试程序时，需要知道是否得出正确的数据，比如打印一个对象时，看看这个对象都有哪些属性，其值是什么。如果定义了toString方法，在打印对象体时，就会自动调用该方法，格式化输出这个对象所包含的数据。 <?php class Person{ private $name = ""; function __construct($name = ""){ // 定义构造函数 $this->name = $name; } public function say(){ // 定义公共方法 echo "hello,".$this->name."!"; } function __toString(){ // 定义获取字符串的魔术方法 return "__toString:".$this->name.'!'; } } $blog = new Person('blog'); $blog->say(); // 输出：hello,blog! echo $blog; // 输出：__toString:blog! ?>如果没有定义__toString() 方法，则执行echo语句时，会报错。Catchable fatal error: Object of class Person could not be converted to string in /usercode/file.php on line 16__clone()方法clone关键字用于克隆一个完全一样的对象，克隆之后两个对象互不干扰。适用场景：在编码过程中，有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。 // 使用clone关键字之前的复制效果实例 // // 定义一个类，类中定义一个公共成员变量 class TestClass{ public $value; } $obj = new TestClass(); // 实例化TestClass类的对象 $obj->value = 'qq'; // 给成员变量赋值 var_dump($obj); // object(TestClass)#228 (1) { ["value"]=> string(2) "qq" } $obj2 = $obj; // 将$obj赋值给$obj2变量，等同于复制一个$obj $obj2->value = 'zz'; // 更改$value的值 var_dump($obj); // object(TestClass)#228 (1) { ["value"]=> string(2) "zz" } var_dump($obj2); // object(TestClass)#228 (1) { ["value"]=> string(2) "zz" }从以上的例子可以看出来当实例化对象赋值给其他变量时，改变实例化对象和改变赋值对象,另一方都会随之改变。这是因为普象的赋值，仅仅是把新对象指向对象存储的地址（即 $obj给了$obj2它的地址，就和引用一样，$obj2指向了$obj，所以导致两者所执行的操作将会收到影响）。 // 使用clone关键字之后的复制效果实例 // // 定义一个类，类中定义一个公共成员变量 class TestClass { public $value; } $obj = new TestClass(); // 实例化TestClass类的对象 $obj->value = 'qq'; // 给成员变量赋值 var_dump($obj); // object(TestClass)#228 (1) { ["value"]=> string(2) "qq" } $obj2 = clone $obj; // 使用clone关键字克隆$obj $obj2->value = 'zz'; // 更改$value的值 var_dump($obj); // object(TestClass)#228 (1) { ["value"]=> string(2) "qq" } var_dump($obj2); // object(TestClass)#228 (1) { ["value"]=> string(2) "zz" }可以看出，使用clone关键字之后，更改$obj2的成员变量值并不会对$obj的成员变量产生影响，克隆之后的两个对象$obj和$obj2是互不影响，互相独立的。__clone方法用于重写原本的属性和方法；__clone() 方法只会在对象被克隆的时候自动调用。__clone()方法对一个对象实例进行的浅复制，对象内的基本数值类型进行的是传值复制，而对象内的对象型成员变量,如果不重写__clone方法，显式的clone这个对象成员变量的话，这个成员变量就是传引用复制,而不是生成一个新的对象。 // 定义age类 class Age{ public $balance; public function __construct($balance){ $this->balance = $balance; } } // // 定义第二个类，类中包括两个公共成员以及构造函数、克隆方法 class IndexService{ public $age; // 对象属性成员变量 public $name; // 非对象属性成员变量 public function __construct($name, Age $age){ $this->name = $name; $this->age = $age; } // 使用clone的时候触发 public function __clone() { $this->name = 'name:'.$this->name; $this->age = clone $this->age; // 这个对象会被强制复制，这样就不会指向原来的对象。 } } // 运行 $obj = new IndexService('peter',new Age(20)); $obj2 = clone $obj; $obj2->age->balance = 10; var_dump($obj); var_dump($obj2); // age对象中的balance值更改为10，name值也被更改。注意： __clone()方法中的clone操作只能用于对象，如果用于非对象属性，将会报错：# 致命错误: __clone method called on non-object。例子中的age就是一个对象。以上例子中，$age对象被强制复制，不会指向原来的对象，所以修改其中的值之后，并不会对原来对象有影响；如果不加上$this->age = clone $this->age;这行代码，运行结果则变成这样：两个对象的age对象的balance值都改成了10。__call()方法__call() 方法用于监视错误的方法调用。该方法在调用的方法不存在时会自动调用，程序会继续执行下去。该方法有两个参数，第一个参数会自动接收不存在的方法名，第二个参数则以数组的方式接收不存在方法的多个参数。 <?php class Test { function __call($function_name, $args) { echo "你所调用的函数：$function_name(参数：<br />"; var_dump($args); echo ")不存在！"; } } // 调用不存在的方法 $p1=new Test(); $p1->test(2,"test"); //你所调用的函数：test(参数：array(2) {[0]=> int(2) [1]=>string(4) "test"})不存在！ 类的自动加载php实现类文件自动载入有两种办法：魔术方法：__autoload();SPL标准库提供的spl_autoload_register();__autoload()__autoload()是php中的一个魔术方法，在代码中当调用不存在的类的时候会自动调用。在开发过程中可以使用include或者require函数来引入需要调用的类文件，但是如果需要调用的类很多的时候，对应的include或者require也会很多，会造成代码冗余，而且每次执行都要加载这些文件，会白白占用内存，其次当删除了某个类文件时，也要对应的修改include或者require语句。使用__autoload()魔术方法来代替include或者require语句，则可以避免大量的代码冗余，也可以提高执行效率。在 Test.php文件中我们调用 类Test1 和 类Test2，由于我们没有显式的引用类文件，那么系统就会自动调用 __autoload() 方法。 //Test.php文件 function __autoload($class){ if(file_exists($class.".php")){ require_once($class.".php"); }else{ die("文件不存在！"); } } Test1::test(); Test2::test();__autoload()的缺点:一个文件中只允许有一个__autoload()，当引入的项目中有其他__autoload()时，则会发生冲突。当项目中的类根据不同的用处放在不同的文件夹中，此时要分别调用对应的类，会十分困难。spl_autoload_register()该函数可以注册任意数量的自动加载器，当使用未被定义的类和接口时自动去加载。code here... //Test.php文件 function my_autoload1($class){ if(file_exists("classes/".$class.".php")){ require_once("classes/".$class.".php"); }else{ die("文件不存在！"); } } function my_autoload2($class){ if(file_exists("core/".$class.".php")){ require_once("core/".$class.".php"); }else{ die("文件不存在！"); } } //将加载函数注册到PHP中 spl_autoload_register("my_autoload1"); spl_autoload_register("my_autoload2"); Test1::test(); Test2::test();鸣谢：看云chunyu

【PHP】面向对象 - instanceof关键字 instanceof是PHP5引入的新关键字。使用这个关键字可以判断一个对象是类的实例、类的子类，还是实现了某个特定接口。用法一： // 判断对象是否是某个类的实例 <?php $obj = new Demo(); if ($obj instanceof Demo) { echo '$obj 是Demo类的一个实例。'; } 用法二： // 判断一个对象是否实现了某个接口 <?php interface ExampleInterface{ public function interfaceMethod(); } class ExampleClass implements ExampleInterface{ public function interfaceMethod(){ return 'Hello World!'; } } $exampleInstance = new ExampleClass(); if($exampleInstance instanceof ExampleInterface){ echo '$exampleInstance 对象实现了ExampleInterface接口'; }用法三： // 判断子类是否继承自某个基类 <?php class Demo{} class DemoSub extends Demo{} $obj = new DemoSub(); if($obj instanceof Demo){ echo 'DemoSub类继承自Demo类'; }

【PHP】面向对象 - trait关键字 PHP是单继承语言，因此一个类不能同时继承多个类。 Trait的出现主要是为了解决单继承语言的局限性问题，是PHP多重继承的一种解决方法。trait不是类,所以不能有静态成员、类常量，当然也不可能被实例化。创建新文件来声明Trait： trait first_trait { function first_method() { /* Code Here */ } }在类中使用 use + trait名进行引用即可，引用之后就可以使用trait中声明的方法。 class test { use first_trait; private $method; public function __construct() { $this->method = $this->first_method(); } }

【PHP】面向对象 - 接口(interface) PHP是单继承语言，因此一个类不能同时继承多个类。当一个类需要多个类的功能时，除了使用trait关键字，还可以使用接口技术。如果一个抽象类里面的所有方法都是抽象方法，且没有声明变量，而且接口里面所有成员都是public权限的，那么这种特殊的抽象类就是接口。应用场景：保持规范、统一性多个类需要实现同样的方法，只是实现方式不一样接口使用规范：接口不能实例化接口属性必须是常量接口方法必须是public，且不能有函数体类必须实现接口的所有方法一个类可以同时实现多个接口，用逗号隔开接口可以继承接口，使用extends关键字。接口使用关键字interface来定义，使用implements关键字来实现类要实现接口，必须使用和接口中所定义的方法完全一致的方式。否则会导致致命错误.实现多个接口时，接口中的方法不能有重名。 <?php //定义接口 interface User{ function getDiscount(); function getUserType(); } //VIP用户 接口实现 class VipUser implements User{ // VIP 用户折扣系数 private $discount = 0.8; function getDiscount() { return $this->discount; } function getUserType() { return "VIP用户"; } } class Goods{ var $price = 100; var $vc; //定义 User 接口类型参数，这时并不知道是什么用户 function run(User $vc){ $this->vc = $vc; $discount = $this->vc->getDiscount(); $usertype = $this->vc->getUserType(); echo $usertype."商品价格：".$this->price*$discount; } } $display = new Goods(); $display ->run(new VipUser); // VIP用户商品价格：80 元 ?>

【PHP】面向对象 - self、$this、parent::关键字 $this$this是指向对象实例的一个指针（在实例化的时候来确定指向）,不指向任何其他对象或类使用形式：$this->实例属性或实例方法()selfself是指向类本身，也就是self是不指向任何已经实例化的对象，一般self使用来指向类中的静态变量。假如我们使用类里面静态（一般用关键字static）的成员，我们也必须使用self来调用。self调用静态变量必须使用:: (域运算符号)，使用形式：self :: 静态属性或静态方法();parent::parent是指向父类的指针parent::可以用于调用父类中定义的方法。 class Count{ //建立了一个名为count的基类 private $lastCount; //定义属性，私有 private static $firstCount = 0; //定义构造函数，用于初始化赋值 function __construct( ) { parent::__construct(); //调用父类构造函数 $this->lastCount=$lastCount; //这里已经使用了this指针 $this->lastCount=++self::$firstCount; //使用self来调用静态变量 } }

【PHP】面向对象 - abstract关键字 abstract用于定义抽象方法和抽象类。抽象方法：抽象方法指没有方法体的方法，在方法声明事没有{}括弧以及其中的内容，而是直接在声明了方法后加上分号结束。abstract function function_name();抽象类：只要一个类中有一个方法是抽象方法，那么这个类就要定义为抽象类，抽象类同样用abstract关键字来定义。抽象类不能产生实例对象，通常是将抽象方法作为子类方法重载的模板使用，且要把继承的抽象类里的方法都实现。抽象类是方便继承而引入的。 <? abstract class Demo{ var $test; abstract function fun1(); abstract function fun2(); function fun3() { ... } } $demo=new Demo(); //抽象类不能产生实例对象，所以这样做是错的，实例化对象交给子类 class Test extends Demo{ function fun1() { ... } function fun2() { ... } } $test = new Test(); //子类可以实例化对象，因为实现了父类中所有抽象方法 ?>

【PHP】面向对象 - final关键字 final关键字final关键字用于修饰类和方法。如果父类中的方法声明了final，则子类无法对其覆盖；如果父类声明了final，则不能被继承。 //父类： final class BaseClass { public function test() { echo "use test\n"; } final public function moreTesting() { echo "use moreTesting\n"; } } //子类继承父类： class ChildClass extends BaseClass { public function moreTesting() { echo "use moreTesting1111111\n"; } } //运行结果报错 PHP Fatal error: Cannot override final method BaseClass::moreTesting()

【PHP】面向对象 - const关键字 constconst是一个定义常量的关键字用“const”修饰的成员属性的访问方式和“static”修饰的成员访问的方式差不多，也是使用“类名”，在方法里面使用“self”关键字。但是不用使用“$”符号，也不能使用对象来访问。 <?php class MyClass{ //定义一个常量CONSTANT const CONSTANT = 'constant value'; function showConstant() { echo self::CONSTANT ; // 使用self访问，不要加“$” } } echo MyClass::constant ; //使用类名来访问，也不加“$” $class = new MyClass(); $class->showConstant(); // echo $class::constant; 是不允许的 ?>

【PHP】面向对象 - 静态方法与普通方法 静态方法：静态和公共、受保护、私有这3种属性格式没有关系， 他们并不是并列的静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用在同一个类中可通过self::关键字来调用静态方法；不同类中，可以通过类的实例化对象来调用静态方法或者通过 类名::静态方法名的方式调用。类里面的静态方法只能访问类的静态属性，不能访问类的非静态成员。从程序运行开始就实例生成内存 ，会高很多，但静态内存是有限制的，实例太多会占用大量内存，且.静态内存会常驻适用于多次频繁调用普通方法：实例方法开始生成内存，执行效率相对于静态方法会慢很多普通方法不会常驻内存可以通过$this,self关键字来调用，即普通方法需要对象去调用，而静态方法不需要

【PHP】面向对象 - 静态变量与普通变量 在变量的前面加上static 就构成了静态变量（static 变量）。静态变量：静态变量属于静态存储方式，其存储空间为内存中的静态数据区（在静态存储区内分配存储单元），该区域中的数据在整个程序的运行期间一直占用这些存储空间（在程序整个运行期间都不释放），也可以认为是其内存地址不变，直到整个程序运行结束。（在函数执行完后不会被销毁，保留上次值）静态变量虽在程序的整个执行过程中始终存在，但是在它作 用域之外不能使用。属于静态存储方式的变量不一定就是静态变量。 例如：外部变量(在PHP中指全局变量)虽属于静态存储方式，但不一定是静态变量，必须由 static加以定义后才能成为静态外部变量，或称静态全局变量。静态局部变量：static类型的内部变量是一种只能在某个特定函数中使用，只会被初始化一次。当在某函数里定义一个静态变量后，这个变量不会即使函数退出了，在下次调用这个函数时，它会使用前次被调用后留下的值。作用域为该函数内部，外部函数不能使用。局部静态变量定义时没有赋初值，系统会自动赋初值0（对数值型变量）或空字符（对字符变量）。局部静态变量占用内存时间较长，并且可读性差全局局部变量：全局变量(外部变量)的声明之前加上static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。普通变量：非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。动态变量，属于动态存储类别，占动态存储空间，函数调用结束后即释放，不会保留上次函数运行的值。 // 静态局部变量：函数每次执行都会保留上次值 function static_test() { static $test = 0; $test++; echo $test; } static_test();// 第一次执行 输出 1 static_test();// 第二次执行 输出 2 // 普通局部变量：函数每次执行完都释放 function test() { $test = 0; $test++; echo $test; } test();// 第一次执行 输出 1 test();// 第二次执行 输出 1把局部变量改变为静态变量后是改变了它的存储方式，即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。

【PHP】面向对象 - static关键字 staticstatic关键字是在类中描述成员属性和方法是静态的。static成员能够限制外部的访问，因为static成员是属于类的，不属于任何对象实例，是在类第一次被加载的时候分配的空间，其他类无法访问，只能对垒的实例共享，能对类的成员形成保护静态成员是在类第一次加载的时候就创建的，所以在类的外部不需要对象而使用类名就可以访问的到静态的成员。类里面的静态方法只能访问类的静态属性，不能访问类的非静态成员。在静态方法中可以通过使用 self::成员属性的方法进行访问。静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。 <? class Person{ //下面是人的静态成员属性 public static $myCountry = "中国"; //这是人的静态成员方法 public static function say() { echo "我是中国人"; } } //输出静态属性 echo Person::$myCountry; //访问静态方法 Person::say(); (new Person())->say(); //重新给静态属性赋值 Person::$myCountry = "美国"; echo Person::$myCountry; ?>

【PHP】面向对象 - 访问权限 public: 公有类型 在子类中可以通过self::var调用public方法或属性,parent::method调用父类方法在实例中可以能过$obj->var 来调用　public类型的方法或属性protected: 受保护类型在子类中可以通过self::var调用protected方法或属性,parent::method调用父类方法在实例中不能通过$obj->var 来调用 protected类型的方法或属性private: 私有类型该类型的属性或方法只能在该类中使用在该类的实例、子类中、子类的实例中都不能调用私有类型的属性和方法 <?php //父类 class father{ public function a(){ echo "public function a".PHP_EOL; } private function b(){ echo "private function b".PHP_EOL; } protected function c(){ echo "protected function c".PHP_EOL; } } //子类 class child extends father{ function d(){ parent::a();//调用父类的a方法 } function e(){ parent::c(); //调用父类的c方法 } function f(){ parent::b(); //调用父类的b方法 } } $father=new father(); $father->a(); //输出 public function a $father->b(); //显示错误 外部无法调用私有的方法 $father->c(); //显示错误 外部无法调用受保护的方法 $chlid=new child(); $chlid->d();//输出 public function a $chlid->e(); ////输出 protected function c $chlid->f();//显示错误 无法调用父类private的方法 Uncaught Error: Call to private method father::b() from context 'child'

【PHP】面向对象 - 三大基本特征和五大基本原则 面向对象基本特征：封装隔离性：被封装后的对象，其外部对象是无法直接访问对象的内部实现细节，内部实现细节的的改动不会影响到外部对象的访问原则（即：对象内部修改后，在公开暴露指定的访问路径不变的情况下，外部访问它的对象是无需修改的），这是隔离性的体现，同时也是实现高内聚，低耦合的最根本的思想之一；可复用性：被封装后的对象可以被外部多个对象访问，而无需为每个外部对象去指定不同的服务对象；减少代码的冗余。可读性：合理设置被封装的对象名称，可增强代码的可读性，通过方法名或者类名即可了解其作用。继承PHP中主要通过extends关键字来实现继承： class Student extends Person{}PHP只能单继承，不支持一个类继承多个类。但是一个类可以进行多层继承（即A继承于B，而C又继承于A，C通过A间接继承了B）子类继承父类非私有的属性和方法，可以通过$this关键字进行访问覆盖：子类中声明与父类相同名称的属性和方法，则该属性和方法会覆盖父类中的属性和方法，属性被覆盖后，无法访问父类中的属性，方法被覆盖后，可以通过parent::方法名()进行访问多态同一方法作用于不同对象时，产生不同的执行结果多态存在的三个必要条件：继承、重写（子类继承父类后对父类方法进行重新定义）、父类引用指向子类对象示例如下： abstract class Person{ // 父类使用abstract关键字修饰 abstract function say(); } class Chinese extends Person{ // 子类重写父类方法 function say(){ echo "我是中国人<br>"; } } class English extends Person{ // 子类重写父类方法 function say(){ echo "我是英国人"; } } $zhangsan = new Chinese(); $zhangsan->say(); $z = new English(); $z->say(); Person $p = new Chinese(); // 父类引用指向子类对象上述代码中，两个子类都是继承自同一父类，但因为都重写了父类的方法,表现出了不同的形态 基本原则：1、单一职责原则（SRP）单一职责有两个含义：一个是避免相同的职责分散到不同的类中，另一个是避免一个类承担太多职责2、开放封闭原则（OCP）一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的3、里氏替换原则（LSP）子类型必须能够替换掉它们的父类型，并出现在父类能够出现的任何地方。4、依赖倒置原则（DIP）依赖倒置简单地讲就是将依赖关系倒置为依赖接口，具体概念如下：上层模块不应该依赖于下层模块，它们共同依赖于一个抽象（父类不能依赖子类，它们都要依赖抽象类）。抽象不能依赖于具体，具体应该依赖于抽象。5、接口隔离原则（ISP）不同的模块要通过抽象接口隔离开，而不是通过具体的类强耦合。