对象的继承特性
一、对象的继承
1）什么是继承？
父类的内容可以拿到子类当中来使用
2）为什么要使用继承？
①更好地体现面向对象的可重用性
②避免代码的冗余
③可以在父类的基础上进行功能的扩展
④体现了面向对象的可扩展性
3）什么时候使用继承？
①在功能要进行扩展的时候进行继承
②在功能要进行修改的时候，子类的功能会覆盖父类的功能
4）PHP继承的特性：
①只支持单一继承，不支持多重继承
②一个子类只允许有一个父类
③一个父类可以有多个子类
5）PHP继承的关键字
①父类、基类、超类
②子类、扩展类、派生类
6）权限问题
①public：公有的成员在子类中可以被完全继承；子类中的成员如果与父类的公有成员的名称相同，则子类的成员功能将覆盖父类的成员功能；
②protected：受保护的成员在子类当中可以被完全继承；受保护的成员在子类中如果出现同名的成员，功能会被覆盖；
③private：父类中私有的成员在子类中不能直接拿来使用，不可被继承
④private < protected < public，子类中的同名的成员的权限一定要比父类的成员的权限宽松
7）方法的重载（覆盖）
parent::__construct();
parent::成员方法名();
class Person{
public $name;
public $sex;
public $age;
function __construct($name,$sex,$age){
$this->name=$name;
$this->sex=$sex;
$this->age=$age;
}
public function say(){
echo "my name is ".$this->name.", my sex is ".$this->sex.", my age is ".$this->age;
}
}
class Student extends Person{
//继承成员属性$name、$sex、$age
public $school;
//构造方法同样被继承，并被覆盖重写
function __construct($name,$sex,$age,$school){
//将父类的构造方法的方法体继承下来
parent::__construct($name,$sex,$age);
$this->school=$school;
}
//将父类的say方法覆盖重写
public function say(){
//将父类的say方法的方法体继承下来
parent::say();
echo ", my shcool is ".$this->school;
}
}
$p=new Student("autumn","男",25,"haha");
$p->say();
二、常用的关键字
1）final
①final修饰的成员方法不允许在子类当中被重写，为了防止已经写好的功能被修改
②final只能修饰方法和类，不能修饰成员属性
③final修饰的类不能再被其他类继承
2）static
①static修饰的成员属性，在类的方法体中要使用“self::$属性名称”访问
②static修饰的成员属性保存在内存中的初始化静态段中，而在类中使用“$this->属性”所调用的成员属性是保存在堆当中的，所以static修饰的成员属性不能使用“$this->属性名称”来访问
③静态成员属性在类的外部可通过“类名::$成员属性名称”调用，不可使用对象来调用
④静态成员属性效率较高，因为不需要实例化对象即可调用
⑤同一个类的多个实例化对象共享一个静态成员属性
⑥静态的成员方法中不允许使用$this调用成员属性
⑦静态的成员方法在类的内部可以使用$this调用，也可以使用“self::方法名()”调用
⑧静态的成员方法在类的外部可以使用实例化对象调用，也可以使用“类名::方法名()”调用
⑨成员方法当中如果没有包含任何$this，该方法默认为静态成员方法
class Person{
public $username;
public static $name;
public function info(){
//普通成员属性的调用
//echo $this->username;
//静态成员属性的调用
echo self::$name;
}
public static function say(){
echo self::$name." say 'hello world!'";
}
public function test(){
//可以使用$this调用静态成员方法
//$this->say();
//也可使用“self::方法名()”调用
self::say();
}
}
//静态成员属性不可以使用对象来调用
$p1=new Person;
Person::$name="autumn";
$p2=new Person;
Person::$name="HaHa";
//多个实例化对象共享一个静态成员属性
$p1->info();
$p2->info();
echo "<hr>";
//可以用实例化对象调用静态成员方法
//$p1->say();
//也可以使用“类名::方法名()”调用（推荐使用）
Person::say();
3）单态设计模式
①什么是单态（单例）（单对象）设计模式？
让类只能实例化一个对象
②为什么要使用单态？
为了节省空间、提高效率
③什么时候使用单态设计模式？
数据库的连接池操作、文件资源的操作、GD资源的操作
④如何使用单态设计模式？
1.构造方法私有化，外部无法自动实例化对象
2.声明一个方法，在该方法中实例化对象
3.将产生的对象存入至一个共享的静态成员属性中
4.在外部想要再次实例化对象时，将该静态成员属性中的对象传给它，即仍为首次实例化的那个对象
class Person{
public static $obj; //用于保存首次实例化的对象
public $name;
//构造方法私有化，外部无法自动实例化对象
private function __construct($name){
$this->name=$name;
}
public static function getObj($name){
//判断该类的对象是否存在
if(is_null(self::$obj)){
self::$obj=new self($name);
}
//除首次实例化对象外，其余直接将首次实例化后存在静态成员属性中的对象传递过去
return self::$obj;
}
public function info(){
echo $this->name;
}
}
$p1=Person::getObj("autumn");
var_dump($p1);
echo "<hr>";
$p2=Person::getObj("haha");
var_dump($p2);
object(Person)#1 (1) { ["name"]=> string(6) "autumn" }
object(Person)#1 (1) { ["name"]=> string(6) "autumn" }
4）const
①常量名一般情况下用大写
②常量值为标量数据类型
③常量不要加“$”
④常量在类的内部访问用“self::常量名”
⑤常量在类的外部访问用“类名::常量名”
5）instanceof
①判断一个对象是否为一个类实例化的
②判断一个对象是否为继承父类的某个子类实例化的
class Person{
//声明一个常量成员属性
const DB_HOST="localhost";
public function info(){
//类的内部调用常量成员属性
echo self::DB_HOST;
}
}
class Student extends Person{
public $school="hehe";
public function say(){
parent::info();
echo ", my school is ".$this->school;
}
}
//类的外部调用常量成员属性
echo Person::DB_HOST;
echo "<hr>";
$p=new Person;
$s=new Student;
//instanceof用于检测当前实例对象是否属于某一个类
var_dump($p instanceof Student); //false
var_dump($s instanceof Student); //true
var_dump($s instanceof Person); //true
三、常用的魔术方法
1）克隆对象
①什么是克隆？
将一个对象完整的复制一份，这个对象与原对象一模一样
②克隆的目的
当对一个已经产生的对象进行一系列的修改、赋值等操作后，需要使用多个经操作后的对象时，使用克隆
③方法：__clone()
参数：无
触发时机：在使用clone对象的一瞬间自动调用
作用：将克隆出的对象进行微调，源对象不会被影响
2）__toString()
参数：无
触发时机：当在类的外部直接echo对象时，自动调用
作用：为了更好地操作对象
注意：本方法一定要有返回值
3）__call()
参数：两个（第一个是调用方法的名称，第二个是实际参数的数组）
触发时机：当调用一个不存在的成员方法时自动调用，且将方法的名称传递给第一个参数，将方法的调用参数传递给第二个参数
作用：避免程序报错，影响后续代码执行
class Person{
private $name="autumn";
private $sex="男";
private $age=25;
public function info(){
echo "姓名：".$this->name."，性别：".$this->sex."，年龄：".$this->age;
}
//在使用clone对象的瞬间自动调用__clone()方法
function __clone(){
$this->name=$this->name."_clone001";
}
//在类的外部echo对象时自动调用__toString()方法
function __toString(){
return "在类的外部直接echo对象会输出该段文字";
}
//当调用一个不存在的成员方法时自动调用__call()方法
function __call($funcName,$args){
echo "对不起，您要找的方法".$funcName."(".join(',',$args).")不存在！";
}
}
$p1=new Person;
//将对象$p1完整克隆一份
$p2=clone $p1;
var_dump($p1);
echo "<hr>";
var_dump($p2);
echo "<hr>";
echo $p1;
echo "<hr>";
$p1->noFunc('参数1','参数2','参数3');
4）__sleep()
参数：无
触发时机：当对一个对象序列化的时候自动调用
作用：让用户可以自定义要序列化的成员属性
注意：该方法一定要返回一个数组类型的值，数组元素的值即为成员属性的名称
5）__wakeup()
参数：无
触发时机：当对对象进行反序列化的时候自动调用
作用：反序列化对象时使对象中的成员发生改变
6）对象串行化（序列化）
将对象转化成以固定形式存储的字符串
①为什么使用对象的串行化？
为了能够让保存对象的介质能够识别对象的格式
②何时使用对象的串行化？
要将对象存入到数据库或是文件中
对象在网络中传输的时候可串行化
③方法：
serialize($obj)：串行化（序列化）
unserialize($str)：反串行化（反序列化），将对象反串行化时必须有原型类同时在
class Person{
private $name="autumn";
private $sex="男";
private $age=25;
public function info(){
echo "姓名：".$this->name."，性别：".$this->sex."，年龄：".$this->age;
}
public function __sleep(){
//指定要序列化的成员属性
return array('name','sex');
}
}
$p=new Person;
echo $str=serialize($p);
file_put_contents("./obj.txt",$str);
class Person{
private $name="autumn";
private $sex="男";
private $age=25;
public function info(){
echo "姓名：".$this->name."，性别：".$this->sex."，年龄：".$this->age;
}
public function __sleep(){
//指定要序列化的成员属性
return array('name','sex');
}
public function __wakeup(){
$this->name="admin";
$this->sex="保密";
}
public function say(){
echo "haha";
}
}
$str=file_get_contents("./obj.txt");
//将对象反序列化时，必须要原对象类同时在
$obj=unserialize($str);
$obj->info();
7）__autoload()
参数：一个（类的名称）
触发时机：当要实例化或继承使用未经include引入的类文件中的类的时候会自动调用该函数，且会将类名作为参数传入该函数，此时在该函数内部可实现类文件的加载
作用：用于加载类文件，无需像使用include加载类文件那样考虑加载的先后顺序
注意：这是一个函数并非是类的成员方法，不是用于类的内部的，而是在需要引用类文件时使用的
function __autoload($className){
if($className=='class1'){
include "../".$className.".class.php";
}elseif($className=='class2'){
include "../".$className.".class.php";
}elseif($className=='class3'){
include "./".$className.".class.php";
}
}
$p=new Person;
四、类型约束
1）类型约束可以使用数组约束和类名约束
2）数组约束：只需要在方法或函数的参数前加入array关键字即可
3）类名约束：只需要在方法或函数的参数前加入类名，表示调用时必须传递该类的对象或该类的子类的对象
class Person1{
function say(array $info){ //数组约束
echo "P1:".join(',',$info);
}
}
class Person2{
function say(array $info){ //数组约束
echo "P2:".join(',',$info);
}
}
class Person{
function test(Person1 $obj){ //类名约束
$obj->say(array('abc','ABC'));
}
}
$p=new Person;
$p->test(new Person1);
