【一】目标
1.类声明语法------试声明student类，有score属性和study方法
2.权限封装---------知道public、protected、private各自的可见范围
3.继承---------------写A类，再写B类继承自A类，且要重写A类中的某个方法
4.静态属性与静态方法-----知道static静态方法需要用类名..方法名0调用
5.魔术方法--------了解常用魔术方法分别在什么时间被调用
6.写一个抽象类，并用2个子类分别继承实现分析这2个子类有什么共同特点?
7.写一个接口，并用2个类分别继承实现分析这2个类有什么共同点?
基本语法：声明，权限，继承，静态属性和方法，魔术方法，抽象类，接口
【二】基础
<?php //对象的声明，将函数放到对象里 class oneclass{
//方法 function one(){ echo "666"; } } //实例化对象 $class = new oneclass(); // 函数调用 $class -> one(); ?>
（1）属性和方法
将变量赋值放到类中，便成为了属性；将函数放到类里，便成了方法
属性和方法的调用：
<?php //放到对象里 class oneclass{ public $name = '我是属性'; function one(){echo "我是方法";} } //实例化对象 $class = new oneclass(); // 方法调用 $class -> one(); //属性调用 echo $class->name;//调用属性时可以不加$ ?>
注意：方法和属性加到类里时前面要加入权限声明，否则默认public
（2）类的声明
语法：class 类名{...}
注意：类名不区分大小写，但是Linux下区分，所以要保持一致。且命名采用驼峰法，一般首字母大写
<?php //类的声明 class person{ //属性声明 public $name = 'wang'; //方法声明 public function man(){ echo "1111"; } } //调用类的话，要先new一个对象,且实例化时不区分大小写，但在Linux下严格区分大小写，所以要避免不一致的情况。命名时用驼峰法 $person = new PERSON(); $person -> man(); echo $person->name; ?>
（3）属性赋值的变化
属性不能赋值表达式？
5.6版本开始支持表达式，例如public $rand = 1+1；
（4）类与对象关系
类是同类事物共同特点的抽象描述；而对象是以类作为模板，形成的具体实例
所以当new + 类名时，便成为new一个对象，即实例化对象
<?php //类的声明 class person{ //属性声明 public $name = 'tony'; //方法声明 public function man(){ echo "1111"; } } //实例化一个对象，赋值给变量 //new类名时，内存便会产生一个对象,开辟新空间存放属性和方法名 $person = new PERSON(); $person1 = new PERSON(); echo $person->name; $person1 ->name = 'tony1'; echo $person1->name; ?>
注意：
①这里改变的属性值不是类里的属性值，而是开辟出的新空间的值；
②开辟的新空间只存放属性和属性值，至于方法只存放方法名，不存放函数
（5）$this本对象、self本类、parent父类
①$this是伪变量，谁实例化对象就是谁。简单理解谁调用就是谁
<?php class Person{ public $name = 'tony'; public $goods = 'dogs'; public function buy(){ echo "拍电影吧".$this->name; } } $person = new Person();
//调用new出来的对象中的方法，所以this指的是new出来的对象。而不是类本身 $person -> buy(); ?>
②self本类，即class类
类名随意改，函数内部用self替换类名，代表调用本类
③parent父类
作用：实现某些情况下子类和父类的兼容，即在继承的子类里做的修改不会影响父类。二者可以同时共存，不会覆盖重写
先举个普通例子：
<?php class Single{ public $value = 1; } class Test extends Single{ public $value = 2;//子类继承后对变量进行覆盖重写 } $test = new Test(); echo($test->value); ?>
parent父类案例：
<?php class Single{ public function __construct(){ echo rand(0,10); } } class Test extends Single{ public function __construct(){ parent::__construct(); echo 2; } } $test = new Test(); ?>
总结：self()调用本类方法属性；parent()调用父类方法属性
（6）封装MySQL类
注意：原生MySQL的api自5.0版本开始逐渐废弃，在将来预计会完全移除。虽然有向下兼容特效，但开发中还是推荐使用mysqli
用封装MySQL连接数据库
<meta charset="utf-8"> <?php class Mysql{ public $link; //连接数据库 public function coon(){ $cfg = array( 'host' => 'localhost', 'user' => 'root', 'password' => 'root', 'db' => 'user', 'charset' => 'utf8' ); //连接数据库(地址，用户，密码，选库) $this ->link = mysqli_connect($cfg['host'],$cfg['user'],$cfg['password'],$cfg['db']); if(!$this ->link){ die("连接失败:".mysqli_error()); }else{ echo "连接成功"; } } //发送查询 public function query($sql){ return mysqli_query($this->link,$sql); } //查询获取所有数据，返回数据 public function getAll($sql){ $array = array(); $res = $this ->query($sql); // mysqli_fetch_assoc($res);//数组 while ($row = mysqli_fetch_assoc($res)) {//遍历数组 $data[] = $row; } return $data; } } $sql = new Mysql(); $sql -> coon(); var_dump($sql->getAll('select* from user')); ?>
注意：每连接一次（刷新页面），便会增加一次连接数Connection id
（7）构造方法和析构方法----------（简单即为构造和销毁construct和destruct）
①构造方法（construct构造）
与面向对象调用方式不同，构造方法的类，一旦被实例化，就会被调用
②析构方法（destruct销毁）
同样也是实例化后便被调用
③构造方法传参：直接在调用时传入即可
注意：析构方法对象销毁时被调用
<?php class Human{ public function __construct(){ echo "构造方法"; }
public function __destruct(){
echo"析构方法";
} } new Human();//调用执行 ?>
构造函数与析构函数调换位置后输出顺序依然不变，因为实例化对象时会先执行构造函数
案例：
<?php class Human{ public function __destruct(){ echo "调用2<br>"; } public function one(){ echo "调用One函数<br>"; } public function __construct(){ echo "调用1<br>"; } } $a = new Human(); $a -> one(); ?>
输出顺序：1，one，2
③析构函数销毁时间：变量赋其他值；被人工销毁unset()；页面结束
④构造方法的旧式声明：一个和类名同名的方法，被理解为构造方法。老旧的PHP代码会遇到，遇到时认识即可(可以传参)
<?php class Human{ //方法名和类名一致时会被理解为构造方法 public function Human($a){ echo "调用"; } } $a = new Human('形参'); ?>
（8）类的封装性
封装性：类中的某些方法或属性不允许外部调用
可以通过开放部分接口来间接调用，写个简单例子
<?php class Human{ //方法名和类名一致时会被理解为构造方法 public function aa(){ echo "调用1"; } public function __construct(){//通过调用构造函数来间接调用方法aa() $this -> aa();//我是内部调用 } } $a = new Human();//我是外部调用 ?>
类似于ATM机，只能输入密码，而不能查询。因为这里只开放了输入对比的接口
不封装的缺点：可以在外部调用获取内部函数或变量，安全性差
<?php class Atm{ //返回数据库存储的密码 public function getPwd(){ return '123456'; } //对比密码 public function checkPwd($pwd){ return $this -> getPwd() == $pwd; } } $atm = new Atm(); //不封装时在外部会可以调用到内部函数，获取密码 echo '存储密码为'.$atm->getPwd()."<br>"; if($atm -> checkPwd('123456')){ echo "密码输入正确"; }else{ echo "密码输入错误"; } ?>
为了封装函数，保护重要数据。将返回数据库存储密码的行的权限改为protected（保护），则该函数便被封装了起来
通过调用公共接口即可间接调用方法
//返回数据库存储的密码 protected function getPwd(){ return '123456'; }
（9）类的继承
语法：extends继承、扩展
class ParClass{} class SubClass extends ParClass{}
接下来，首先看个问题
<?php include 'footer.php';//不存在会继续终止 require 'header.php';//不存在会终止执行 function check(){...} ?>
引入的文件里可能会有函数名与check相同，导致运行出现问题
详解：结合下面代码进行解析
继承的好处：
①子类可以继承父类的方法和属性，例如底下案例里通过实例化调用子类来调用继承自父类的函数method；
②允许覆盖和修改父类的方法属性或新增方法，例如check函数的覆盖重新；
案例：
<?php class one{ function check(){ echo "检查1"; } function method(){ echo "方法1"; } } //two相对于one 来说是子类，此时one类里的方法可用,比如通过子类two调用父类的method方法 class two extends one{ function check(){ echo "检查2"; } } $three = new two(); $three -> check();//这里会输出“检查2”，因为two对one进行了继承修改 $three -> method();//通过子类two调用父类的method方法 ?>
（11）final类和final方法
final类不能被继承，且final方法不能被子类重写
①类无法继承
<?php final class One{} class Two extends One{ public function a(){ echo "123"; } } $three = new Two();//检验后，会提示无法继承错误 ?>
②方法可以通过子类继承调用，但无法覆盖重写
<?php class One{ final public function check(){ echo('父级'); } } class Two extends One{ public function a(){ echo "子级1"; } public function check(){ echo "子级2"; } } $three = new Two(); $three -> check();//输出父级，所以可以继承 ?>
（12）三种权限的详解
类中的权限一共3中，三种权限包含public（公共的），protected（保护的），private（私有的）
①public
内外部均可调用，子类可以继承和重写
<?php class Human{ public $money = 3000; public function one(){ echo $this->money; } } class Stu extends Human{} $Stu = new Stu(); // 变量调用 echo $Stu->money; //方法调用 echo $Stu->one(); ?>
②protected
不能在外部直接调用，只能通过内部开放接口调用。但是可以被子类覆盖重写
<?php class Human{ public $money = 3000; protected $pwd = '123456'; public function one(){ echo $this->money; } } class Stu extends Human{ public function show(){ return $this->pwd; } } $Stu = new Stu(); // protected权限的变量，不能在函数外部调用。只能通过子类间接调用 echo $Stu->show(); ?>
③private（私有的）
外部不可以被调用，内部可被调用。不可以被继承
（13）静态属性和静态方法
①为什么实例化类？
为了得到类里的属性和方法，通过实例化出来的对象调用
②静态方法
类的方法和属性的调用，可以不通过实例化类来调用方法，这时我们可以通过静态方法来调用
③静态属性
<?php class Math{ //声明静态属性 static public $name = 'Tony'; //声明静态方法 static public function add($a,$b){ return $a+$b; } } $math = new Math(); echo Math::add(1,2); echo Math::$name; ?>
优势：略过实例化步骤，直接调用属性和方法
（14）类常量
先说下常量：常量类似变量，但是常量一旦被定义就无法更改或撤销定义。全局均可被调用
常量语法：define(常量名，常量值，是否对大小写敏感(默认不敏感true))
<meta charset="utf-8"> <?php define('name', 'Tony'); class Math{ public function test(){ echo name; } } $math = new Math(); $math->test(); ?>
因为常量是全局性的，可能有命名冲突的情况，造成运行问题。
为了避免这种情况的出现，可以把常量写到类里，用类常量来解决
类常量：
调用时类名::常量即可调用
<?php class Math{ const name = 'Tony'; public function test(){ echo Math::name; //类常量的调用为类名::常量名； } } $math = new Math(); $math->test(); ?>
（15）单例模式
简单理解：单例就是类只能被实例化一次，只能得到一个对象
购物商场用到单例模式
思路：按步骤分为
1. 创建普通类；2. 保护构造方法，封装起来(保护后不能调用)；3. 所以要在封装后在内部调用，从而实现对外开放一个接口；
4.设为静态，移除控制权，从而不实例化调用；5. 添加判断；6. final禁止继承
单个实例对象，即只能实例化一个对象
①普通类的实例
<?php class Single{ public $rand; public function __construct(){ $this->rand = mt_rand(10,300);//mt_rand()随机数 } } var_dump(new Single());//115 var_dump(new Single());//148 ?>
这里我实例化了类两次，得到两个对象，且两次数值不一样。由此总结出一个类可以实例化出多个对象。
②单例模式案例
实例化放到类里，加上条件判断
<?php class Single{ public $rand; static public $ob; protected function __construct(){ $this->rand = mt_rand(10,300);//随机数 } static public function out(){ if (Single::$ob === null) {//判断是否实例化 Single::$ob = new Single(); } return Single::$ob; } } var_dump(Single::out());//输出222 var_dump(Single::out());//输出222 ?>
两次输出一样
上例还未完成，因为继承后的子类里再次实例化时，还是会产生多个不同结果
<?php class Single{ public $rand; static public $ob; //final不允许被子类重写 protected function __construct(){ $this->rand = mt_rand(10,300);//随机数 } static public function out(){ if (Single::$ob === null) {//判断是否实例化 Single::$ob = new Single(); } return Single::$ob; } } class Test extends Single{ public function __construct(){ echo rand(20,300);//此处被子类重写 } } new Test(); new Test(); ?>
对此我们用final来禁止重写，因为final类不能被继承，且final方法不能被子类重写
（16）魔术方法
在某些场景下可以自动调用的方法，即为魔术方法
举例：__construct、__destruct、__set、__get、__isset、__unset、__call
详解：
__construct: 构造方法,new 实例时，自动调用
__destruct: 析构方法，对象销毁时自动调用
__get(属性名): 当读取对象的一个不可见属性时,自动调用，并返回值
不可见：未定义或无权访问时
__set(属性名,属性值):当对一个不可见的属性赋值时，自动调用
__isset(属性名):当用isset,或empty判断一个不可见属性时，自动调用
__unset(属性名): 当unset一个不可见属性时，自动调用
不可见属性：未定义，不能访问（受保护或者私有），即外部不能访问，protected和private.
简单理解就是：在外部没有访问权限的都是不可见属性
案例：
__get()：
<?php class Single{ public function __get($a){ echo $a; } } $single = new Single(); $single->tony;//这里调用了一个未定义的属性（不可见属性），所以自动触发了__get()，并返回值。获取不可见属性时触发，返回属性值 ?>
__set()：设置不可见属性时自动触发
<?php class Single{ public function __set($a,$b){ echo $a.$b; } } $single = new Single(); $single -> name='Tony'; ?>
_isset()：当用isset,或empty判断一个不可见属性时，自动调用
<?php class Single{ public function __isset($a){ echo $a; } } $single = new Single(); isset($single -> tony); ?>
__unset(属性名): 当unset一个不可见属性时，自动调用
<?php class Single{ public function __unset($a){ echo $a; } } $single = new Single(); unset($single -> tony); ?>
（17）魔术方法的意义
作用：防止对类的随意修改；运用__set()实现数据库数据添加
先来根据案例介绍
<?php class Single{ } //实例化一个对象，赋值给变量 //new类名时，内存便会产生一个对象,开辟新空间存放属性和方法名 $single = new Single(); $single -> name = 'tony'; echo $single ->name; ?>
①这里改变的属性值不是类里的属性值，而是开辟出的新空间的值；
②开辟的新空间只存放属性和属性值，至于方法只存放方法名，不存放函数
代码解析：
上面的代码里，Single类本身失去了对代码的控制权，因为继承的子类可以随意修改覆盖，这里便可以通过魔术方法来限制
<?php class Single{ public function __set($a,$b){ echo"禁止随意添加属性"; } } $single = new Single(); $single -> name = 'tony'; ?>
总结：通过魔术方法来限制对父类的添加覆盖和获取。
案例：thinkPHP里，可以通过触发魔术方法，直接将数据添加到数据库
//ORM方式，原理：设置了__set()魔术方式
<?php $this->name = 'tony'; $this->age = '23'; $this->add(); ?>
（18）自动加载
实例化某个类时，如MySQL，需要先require()。如果类比较多，目录也就比较多，require引入文件时将显得很麻烦。这时需要一个自动化的解决方案----自动加载。
<?php function myload($class){//这里$class为实例化的类名 echo $class."?"; } //注册一个函数为自动触发函数--调用/实例化一个不存在的类时便会自动触发 spl_autoload_register('myload'); new mySql(); ?>
解析：new mySql()会在本页面查找mysql类，不存在时便会触发sql_autoload_register()里注册的自动触发函数
被注册函数的形参，上例为$class，会接受实例化的类名。
<?php function myload($class){ include './'.$class.'.class.php';//这里便会引入（自动加载）mySql.class.php文件 } //注册一个函数为自动触发函数--调用/实例化一个不存在的类时便会自动触发 spl_autoload_register('myload'); new mySql(); ?>
mySql.class.php：
<?php class mySql{ public function __construct(){ echo "789"; } } ?>
总结：简单理解所谓的自动加载并不是真的自动加载，而是利用spl_autoload_register()注册自动触发函数，利用函数里面设定的include内容来加载想要加载的文件。并且new里面的一个类名。thinkPHP里经常遇到类名与文件名一致，这便用到了自动加载功能。
（19）抽象类和抽象方法
问题由来：项目组A组负责底层数据库，B组负责调用接口，实现业务逻辑。为了分开两组进度，避免相互影响，从而产生了抽象类和抽象方法模板
抽象类和抽象方法实现模板的功能，实现数据与逻辑分离。其原理类似于螺母和扳手，都采用国标进行生产。而这里的抽象类和抽象方法，功能类似于国标。为数据和逻辑规定了模板。
语法：abstract + 类名，则为抽象类；abstract + 方法名，则为抽象方法。
注意：
①抽象方法没有方法体，即代码块；
②抽象类里的方法都是抽象方法？
NO！抽象类里可以有已经实现的方法，是完整的方法，即有代码块。例如下例中的check()，但之前不能加abstract
③抽象类里只要有一个抽象方法，则类仍然是抽象的。抽象类不能被实例化。否则会报错
Fatal error: Cannot instantiate abstract class Test in C:PHPTutorialdemo1.php on line 30
翻译为抽象类不能被实例化
<?php abstract class Test{ /* *参数:sql语句 *返回值类型：array */ abstract public function getAll($sql); /* *参数:sql语句 *返回值类型：array */ abstract public function getRow($sql); //已完成方法 public check(){ echo "我是已完成方法"; } } //逻辑方法方面，只需知道getAll()方法；而数据库方面照着以上模板写sql执行。从而实现逻辑和数据分离 //接下来数据库方面想写数据，通过继承来实现上面模板的继承。继承时必须对每个方法都进行一一实现，少一个也不行 class Mysql extends Test{ public function getAll($sql){ }; public function getAll($sql){ }; } ?>
（20）接口的概念
抽象类可以理解为”类的模板”，接口则是”方法模板”。
接口粒度更小，用于描述通用的方法。
<?php interface fly1{ public function fly($oil,$height); } interface run1{ public function run($speed,$width); } interface water1{ public function water($depth); } //声明一个类，实现其接口 class Super implements fly1,run1,water1{ //与抽象类和抽象方法相同，对于声明类里所带的接口，必须对每个接口都进行一一实现，少一个也不行 public function fly($oil,$height){ echo "飞"; } public function run($speed,$width){ echo "跑"; } public function water($depth){ echo "游泳"; } } $super = new Super(); $super -> fly(1,2);//这里因为上面接口规定了必须传参，所以不管用不用都得传入，否则会报错 ?>
（21）接口的语法
①接口本身就是抽象的，方法前不用加abstract；
②接口里的方法，只能是public；
③类可以同时实现多个接口。例如下例的fly1，run1，water1
//声明一个类，实现其接口 class Super implements fly1,run1,water1{ //与抽象类和抽象方法相同，对于声明类里所带的接口，必须对每个接口都进行一一实现，少一个也不行 public function fly($oil,$height){ echo "飞"; } public function run($speed,$width){ echo "跑"; } public function water($depth){ echo "游泳"; } }
总结：抽象类相当于一类事物的规范；接口：组成事物的零件的规范
（22）异常处理
程序运行的每个环节都可能出错，要判断程序的运行逻辑，要靠返回不同的值
主要靠两部分：①抛出异常；②捕获异常
//抛出异常
//参数（异常信息，异常错误码），两个参数共同定位了错误的位置 throw new Exception("抛出异常，错误码为1", 1);
//捕获异常，$e为错误码
try{ var_dump(t1()); }catch(Exception $e){ var_dump($e);//输出验证即可分析出$e为对象类型 }
报错：
object(Exception)#1 (7) {
["message":protected]=>
string(8) "t1返回"
["string":"Exception":private]=>
string(0) ""
["code":protected]=>
int(1)
["file":protected]=>
string(24) "C:PHPTutorialdemo1.php"
["line":protected]=>
int(7)
["trace":"Exception":private]=>
array(1) {
[0]=>
array(4) {
["file"]=>
string(24) "C:PHPTutorialdemo1.php"
["line"]=>
int(21)
["function"]=>
string(2) "t1"
["args"]=>
array(0) {
}
}
}
["previous":"Exception":private]=>
NULL
}
作用：利用报错机制，定位到相关错误行，打印出具体信息
<?php function t1(){ if(rand(1,10)>5){ //参数（异常信息，异常错误码） //两个参数共同定位了错误的位置 throw new Exception("t1返回", 1); }else{ t2(); } } function t2(){ if(rand(1,10)>5){ throw new Exception("t2返回", 2); }else{ return true; } } try{ var_dump(t1()); }catch(Exception $e){ // var_dump($e);//输出验证即可分析出$e为对象类型 echo '文件位置为：'.$e->getFile()."<br>"; echo "行号".$e->getLine(); } ?>
结合PHP手册查阅可以知道：getFile()错误获取文件位置、getLine()获取错误所在行等错误信息。而Expection为所有异常的基类
适用场景？
不该出错的重要地方，却有可能出错，就用异常。比如连接数据库，尤其是连接远程数据库时（断网）；查询用户是否存在，可能返回true/false，此时就用return；上传文件时（上传过程断网）。出错时要写到错误日志里
（23）命名空间
多个人开发项目，函数名很容易重复。用了类之后，类之间的方法名被类分开，重名也没关系。
但是当项目更大时，类名也有可能重复。此时就要用到命名空间，来避免重名。
注意：①命名空间语句必须顶行，且之前不可以有任何输出
案例：
<?php namespace name;//命名空间---相当于创建了一个文件夹 include 'two.php'; class Test1{ public function __construct(){ echo "666"; } } new Test1(); ?>
two.php：
<?php namespace name1; class Test1{ public function __construct(){ echo "333"; } } ?>
最终会输出666，也就是调用了one.php里的函数。
如果去掉命名空间语句，再次测试会发现报错提示：Fatal error: Cannot redeclare class Test1。无法重新声明Test1
这里如果想调用two.php里的同名函数怎么办呢？
①原理类似于Linux下的文件查询操作cd......；②之前说过，命名空间相当于创建了一个文件夹，现在我们要通过cd来查看内部文件；③定向调用
//two.php里命名空间为name1，所以相当于在name1文件夹下查看文件
new
ame1Test();
所以，上例可以改为
<?php namespace name;//命名空间---相当于创建了一个文件夹 include 'mySql.class.php'; class Test{ public function __construct(){ echo "666"; } } new ame1Test();//这时便会输出333 ?>
有了命名空间可以明确指出运用的类
上例继续修改
one.php：
use ame1Test1; new Test1();
two.php：
<?php namespace name1; class Test1{//改名为Test1 public function __construct(){ echo "333"; } } ?>
但是这种写法需要修改文件，有时没有相应权限。所以这里我们可以用别名as
use ame1Test as newName; new newName();//直接new()别名
这样便可以访问
注意：命名空间可以创建多层，调用时按照cd原理逐层读取即可。例如
one.php：
use ame1one wo hreeTest as newName; new newName();
two.php：
<?php
namespace name1one wo hree;
?>
注意：
①命名空间声明位置必须位于首行；②声明后，其后的函数、类都将被封锁在命名空间里；
③引入其他页面后，自身空间不受干扰；④如果想明确使用某空间下的类，可以从根目录下逐层寻找读取，原理类似Linux的cd；
⑤若频繁使用某个空间下的类，可以先用use声明，然后as别名，避免冲突；⑥自动加载函数的参数，包含“空间路径类名”
（24）延迟绑定
先来看个例子：
<?php class One{ public function demo1(){ echo "父类"; } public function demo2(){ $this->demo1(); } } class Two extends One{ public function demo1(){//继承重写 echo "子类"; } } $test = new Two(); $test->demo2();//输出结果为"子类" ?>
以上输出结果为"子类"，虽然demo2是调用demo1实现的，但是这里还是打印出子类改写的结果，为什么呢？
因为这里用$this当前对象调用，而$this伪元素是谁调用就指向谁，所以会输出“子类”
对上面代码进行修改，改为$self本类
<?php class One{ public static function demo1(){ echo "父类"; } public static function demo2(){ self::demo1(); } } class Two extends One{ public static function demo1(){//继承重写 echo "子类"; } } Two::demo2();//这里会输出父类“” ?>
上面会输出父类，再做些修改
static::demo1();//输出“子类”
此时输出“子类”，这便是延迟绑定
简单理解：所谓延迟绑定就是在定义时未做出绑定，知道后面调用时才决定出绑定哪个。完整代码
<?php class One{ public static function demo1(){ echo "父类"; } public static function demo2(){ static::demo1(); } } class Two extends One{ public static function demo1(){//继承重写 echo "子类"; } } One::demo2();//调用时才决定出绑定哪个类 Two::demo2(); ?>
（25）超载的static
静态变量static在函数执行完毕后不会被重写
static用法场景：延迟绑定，静态属性和静态方法
用在变量前构成静态变量，用在类里的属性前则构成静态属性，类里的方法前则构成静态方法，用在静态方法里调用则构成延迟绑定
（26）多态
面向对象的3大特征：封装、继承、多态
PHP数据类型：4种标量类型（整型，浮点型，字符串，布尔值），2种复合类型（array()，object()），2种特殊类型（null，resource）
①首先要了解，PHP是弱类型语言，即对变量类型的控制不严格。不做参数的类型检测，变量的数据类型通常不是由程序员设定的，准确的说，是PHP根据该变量使用的上下文在运
行时决定的，简单的说就是，我们不需要设定变量的数据类型，PHP会自动识别。所以这便容易产生一些数据类型上的BUG
②在强类型语言里（JAVA、C++等），会检测参数的类型，即声明变量时，前面必须加上变量的数据类型。
③在声明时，声明参数的父类类型为数字，具体实参可以是数字或数字的子类，这种现象便是多态
<?php class Par{//作为父类存在 } class Son1 extends Par{ public function run(){ echo "123"; } } class Son2 extends Par{ public function run(){ echo "456"; } } function test($par){//强类型语言里参数必须声明数据类型 $par->run(); } test(new Son1()); ?>
PHP是弱类型语言，不会检测数据类型，所以严格上说没有多态