PHP OOP面向对象总结
3250阅读
0评论
0点赞
我的名字叫:'.$this->name; //$this->say();
}
}
$man = new leyangjun(); //实例化对象(对象都是互相独立，对象名保存在栈内存中，数据保存在堆内存中)
$man2 = new leyangjun();
$man2->name = 'GG'.'
'; $man->name = 'leyangjun'.'
'; echo $man->name; echo $man2->name; $man->say(); $man->runMethods(); /** *构造方法与析构方法 *描述：当创建一个对象时，它将自动调用构造函数，也就是使用new这个关键字来实例化的时候自动调用构造方法 *在一个类中只能申明一个构造方法 **/ class NewPerson{ var $name; var $sex; var $age; //定义一个构造方法（这是PHP5中的变化，以前的版本中，构造函数的名称必须与类名相同） function __construct($name,$sex,$age){ //通过构造方法传来的$name给成员属性$this->name赋初始值 $this->name = $name; $this->sex = $sex; $this->age = $age; } function say(){ echo "
名字：".$this->name.'---性别：'.$this->sex.'---年龄：'.$this->age; } /** *析构函数：在销毁一个类之前执行的一些操作或完成一些功能，如：关闭文件、释放结果集等 *析构函数不能带有任何参数 **/ function __destruct(){ echo "
再见".$this->name; } } $NewMan = new NewPerson("菠萝蜜","男",25); $NewMan->say(); //类的封装 class Encapsulation{ private $name; //认得名字被private封装上了 function __construct($name){ $this->name=$name; } public function say(){//前面不写默认是public echo "
名字：".$this->name; } public function getName(){ return("
获取私有属性：".$this->name); } function __destruct(){ echo "
林苏：".$this->name; } } $p1 = new Encapsulation("长林军"); $name = $p1->getName(); $p1->say(); echo $name; /** *__SET __GET() __isset() __unset()方法 * 一般来说，总是把类的属性定义为private，这更符合现实的逻辑。但是，对属性的读取和赋值操作是非常频繁的， *因此在PHP5中，预定义了两个函数”__get()”和”__set()”来获取和赋值其属性,以及检查属性的”__isset()”和删除属性的方法”__unset()”。 */ class Person3{ private $name; private $sex; private $addess; private $myData=3; //__set()方法来设置私有属性 function __set($property_name,$property_value){ echo "
在这直接设置私有属性值的时候，自动调用这个__set()方法为私有属性设置值
"; $this->$property_name = $property_value; } //__get()方法用来获取私有属性 function __get($property_name){ //echo "在直接获取私有属性值的时候，自动调用了这个__get()方法
"; if(isset($this->$property_name)) { return($this->$property_name); }else{ return ('没有你要的值！'); } } //__isset判断私有成员是否存在 public function __isset($p){ //echo "当在类外部使用isset()函数测定 私有成员 $p时，自动调用
"; return isset($this->$p); } //__unset 删除私有成员 public function __unset($privateAttribute){ //echo "当在类外部使用unset()函数来删除私有成员时自动调用的
"; unset($this->$privateAttribute); } } $p3 = new Person3(); $p3->name='leyangjun'; var_dump($p3->age); echo '姓名：'.$p3->name.'
'; if(isset($p3->addess)) { echo $p3->addess.'
'; }else{ echo '不存在
'; } unset($p3->myData); echo $p3->myData.'
'; //继承 class titalMan{} class Student extends titalMan{ } /** *方法重载 *PHP里面没有方法重载。不能重载也就是在你的项目中不能定义相同方法名的方法 *我们这里所指的重载新的方法所指的是什么呢？其实我们所说的重载新的方法就是子类覆盖父类的已有的方法， **/ /** *子类调用父类的方法：一种是使用父类的 "类名::" 来调用父类的方法 className::testFunction(); * 一种是使用 "parent::"的方式来调用父类中的方法 parent::say(); **/ /** *访问类型 *public(公有的、默认的):公有修饰符，类中的成员将没有访问限制，所有的外部成员都可以访问（读和写） *private(私有的):私有修改符,被定义为private的成员,对同一类里的所有成员是可见的，没有访问限制；但类的外部是不允许改变和操作，对于该类的子类，也不能访问。 *protected(受保护的)：保护成员修饰符,被修饰为protected的成员不能被该类的外部代码访问。但是对于该类的子类有访问权限，可以进行属性、方法的读及写操作,该子类的外部代码包括其的子类都不具有访问其属性和方法的权限。 **/ /** *final关键字的应用 *这个关键字用来定义类和定义方法,不能使用final定义成员属性，因为final是常亮的意思，在php定义常亮的是define()函数 *使用final关键标记的类不能被继承 **/ final class leyangjunA{} //class leyangjunB extends leyangjunA{} 不能被继承 //使用final关键标记的方法不能被子类覆盖，是最终版本； class leyangjunC{ final function say(){} } class leyangjunD extends leyangjunC{ //function say(){} 不能重写父类的方法 } /** *static 和 const关键字的使用 *static关键字是描述成员属性和成员方法是静态的； *类的静态变量，非常类似全局变量，能够被所有类的实例共享，类的静态方法也是一样的，类似于全局函数 * *声明类成员或方法为static，就可以不实例化类而直接访问。不能通过一个对象来访问其中的静态成员（静态方法除外） *在做项目的时候就是使用类名去访问 * *const:是一个定义常量的关键字，在php中定义常量使用的是define(),但是在类里面定义常量使用 “const休息成员属性的访问方式” *和static修饰的成员访问的方式差不多，也是用“类名”，在方法里面使用self关键字。不能使用"$"符号，也不能使用对象来访问。 */ class StaticPerson{ public static $myCountry='中国'; public static $myStatic='foo'; const constant = '
constont value';//定义一个常量 public function staticValue(){ //内部调用静态属性 return '
我的'.self::$myStatic; } public static function myNeiBu(){ //内部调用静态属性 return '内部静态方法:'; } public static function say(){ echo self::myNeiBu(); echo '我是中国人'; } public function showConstant(){ echo self::constant; //使用self::访问常量 } } $foo = new StaticPerson(); $foo->showConstant(); //echo $foo::constant; 是不允许的 echo $foo->staticValue().'
'; echo StaticPerson::$myCountry; //输出静态属性 StaticPerson::say(); //类名访问静态方法 StaticPerson::$myCountry="
美国"; echo StaticPerson::$myCountry.'
'; /** *__toString() *在直接输出对象引用时自动调用执行的方法。 * */ class TestClass{ public $foo; public function __construct($foo){ $this->foo = $foo; } public function __toString(){ return '__toString方法:'.$this->foo; } } $class = new TestClass('hello world!'); //直接输出$class是会报错的，如果里面加了__toString()方法，直接输出对象的时候，就不会产生错误，而直接调用__toSring()方法（一定要有个return语句） echo $class.'
'; /** *克隆对象 --clone 或 __clone *根据一个对象完全克隆一个一模一样的对象，互不干挠 */ class PersonOne{ //成员属性 var $name; var $sex; var $age; function __construct($name="",$sex="",$age=""){ $this->name=$name; $this->sex=$sex; $this->age=$age; } function say(){ echo "我的名字：".$this->name.'性别：'.$this->sex.'年龄：'.$this->age.'
'; } } $pOne = new PersonOne('leyangjun','男','25'); //使用clone 克隆新对象$pTwo,和$pOne对象具有相同的属性和方法 $pTwo = clone $pOne; $pOne->say(); $pTwo->say(); class PersonThree{ //成员属性 var $name; var $sex; var $age; function __construct($name="",$sex="",$age=""){ $this->name=$name; $this->sex=$sex; $this->age=$age; } function say(){ echo "我的名字：".$this->name.'性别：'.$this->sex.'年龄：'.$this->age.'
'; } //对象克隆是自动调用的方法，如果想在克隆后改变对象内容，需要在__clone中重写原本的属性和方法 function __clone(){ //$this指的复本 $this->name = '我是假的'.$this->name; $this->age = 30; } } $Three1 = new PersonThree('乐杨俊','男',28); $Three2 = clone $Three1; $Three1->say(); $Three2->say(); /** *__call 处理调用报错 *调用内部方法不存在程序就报错停止，使用__call可以提示调用的方法及使用参数不存在，但程序继续执行。 */ class ErrorClass{ function __call($functionName,$args){ echo "
你所调用的函数：$functionName 参数："; print_r($args); echo '不存在
'; } } $ErrorClass = new ErrorClass(); $ErrorClass->demoTest("one","two","three"); echo '程序调用不出安在的不会退出可以执行到这里
'; /** *抽象类和抽象方法 *抽象方法：没有定义方法实体，在方法申明的时候没有大括号以及其中的内容，直接加分号结束，前面加一个关键字“abstract” --->abstract function fun1(); *抽象类：里面可以有不是抽象方法和成员属性，但是要有一个抽象的方法，这个类就必须申明为抽象类 使用“abstract”来修饰 --->abstract calss Demo{} */ abstract class chouxiang{ abstract function talk(); abstract function talk2(); public function talk3(){ echo '父类非抽象方法talk3
'; } } //$CX = new chouxiang(); //抽象类不能实例化，只能继承（子类必须把父类中的抽象方法全部都实现） class TestCx extends chouxiang{ //子类必须把父类中的抽象方法全部都实现 function talk(){ echo '重写父类talk方法
'; } function talk2(){ echo '重写父类talk2方法
'; } } $TestCx = new TestCx();//子类实现了父类的抽象方法，所以可以实例化 $TestCx->talk(); $TestCx->talk3(); /** *php接口技术（关键字：interface） *描述：php语言与大多数编程语言一样不支持多重继承，也就是每个类只能继承一个父类 *解析：接口是一种特殊的抽象类，抽象类又是一种特殊的类，所以接口是一种特殊的类。（接口里面所有的方法必须都是申明为抽象方法，另外接口 * 里面不能申明变量，而且接口里面所有的成员都是public权限的。所以子类实现的时候也一定要使用public权限。） **/ //定义一个接口One interface One{ //定义一个常量（接口里面不能定义变量成员） const constant = 'constant value'; //定义一个抽象方法fun1 --- 接口里面的所有方法都要是public（默认的） public function fun1(); public function fun2(); } //注：因为接口是一种特殊的抽象类，里面所有的方法都是抽象方法，所以接口也不能产生实例对象，它也做为一种规范，所有抽象方法需要子类去实现 //使用 extends 关键字让一个接口继承另一个接口 interface Two extends One{ function fun3(); function fun4(); } //注：定义一个接口的子类去实现接口中的全部抽象方法使用关键字“implements”而不是extends class JK implements One{ public function fun1(){ echo '
接口方法fun1'; } public function fun2(){ echo '
接口方法fun2
'; } } $jk = new JK(); $jk->fun1(); $jk->fun2(); /** *注：前面说过，PHP是单继承，一个类只有一个父类，但是一个类可以实现多个接口，遵循多个规范。 *class JK2 implements 接口一,接口二,......{ //必须把所有接口中的方法都要实现才可以实例化对象。 } PHP中不仅可以实现多个接口，也可以继承一个类的同时实现多个接口，一定要先继承类再去实现接口； class JK3 extends 类名一 implements 接口一,接口二,.......{ //所有接口中的方法都要实现才可以实例化对象 //........ } **/ /** *多态应用 *解析：所谓多态是指一段程序能后处理多种类型对象的能力，比如：公司不同员工不同职位发放工资，多以同一个发放工资的方法就出现了多种形态。 *对程序来说，多态就是把子类对象赋值给父类引用，能后调用父类的方法，去执行子类覆盖父类的那个方法，但在php里是弱类型的，对象引用都是一样的不分类引用，还是子类引用。 **/ //定义一个形状的接口，里面有两个抽象方法让子类去实现 interface Shape{ function area(); function perimeter(); } //定义了一个矩形子类实现了形状接口中的周长和面积 class Rect implements Shape{ private $width; private $height; function __construct($width,$height){ $this->width = $width; $this->height = $height; } function area(){ return '矩形面积是：'.($this->width*$this->height); } function perimeter(){ return '矩形周长是：'.(2*($this->width+$this->height)); } } //定义一个圆形子类实现了形状接口中的周长和面积 class Circular implements Shape{ private $radius; function __construct($radius){ $this->radius = $radius; } function area(){ return '圆形面积是：'.(3.14*$this->radius*$this->radius); } function perimeter(){ return '圆形面积是：'.(2*3.14*$this->radius); } } //把子类矩形对象赋给形状的一个引用 ECHO '
'; $shape = new Rect(5,10); echo $shape->area().'
'; echo $shape->perimeter().'
'; //把子类圆形对象赋给形状的一个引用 $shape = new Circular(10); echo $shape->area().'
'; echo $shape->perimeter().'
'; //通过上例我们看到,把 矩形对象 和 圆形对象 分别赋给了变量$shape,调用$shape引用中的面积和周长的方法，出现了不同的结果，这就是一种多态的应用， //其实在我们PHP这种弱类形的面向对象的语言里面，多态的特性并不是特别的明显，其实就是对象类型变量的变项应用 /** *把对象串行化（序列化：serialize(),反序列化：unserialize() ） *描述：有时候需要把一个对象在网络上传输，为了方面传输，可以把整个对象转化为二进制串，等到达另一端时，在还原为原来的对象，这个过程叫串行化。 *例子：想把一辆汽车通过轮船运到美国去，因为汽车的体积较大，我们可以把汽车拆成小的部件，然后我们把这些部件通过轮船运到美国去，到美国在重新组装回汽车。 *两种情况必须进行对象穿行化： * 一：把一个对象在网络中传输的时候要将对象串行化 * 二：把对象写入文件或是数据库的时候用到串行化 *serialize(): 串行化/序列化 一个对象 *unserialize(): 反串化/反序列化 把对象转化的二进制字符串在转化为对象 */ class PersonMans{ var $name; function __construct($name=""){ $this->name=$name; } function say(){ echo '
我的名字：'.$this->name; } } $PersonMans = new PersonMans('leyangjun wa haha'); $p1_string = serialize($PersonMans);//把对象串行化，返回一个字符串 echo '
'.$p1_string.'
'; $p2_string = unserialize($p1_string); $p2_string->say(); /** *魔术方法__sleep()和__wakeup() *描述：在对象串行化的时候，会调用一个__sleep()方法来完成一些睡前的事情；而在重新醒来，即由二进制串重新组成一个对象的时候，则会自动调用PHP的另一个函数__wakeup(),做一些对象醒来就要做的动作。 *注：__sleep()函数不接受任何参数 */ class PersonTwo{ var $name; function __construct($name="",$age=""){ $this->name=$name; $this->age=$age; } function say(){ echo '
我的名字：'.$this->name.' 年龄：'.$this->age; } //指定串行化把返回的数组中$name 串行化，忽略没在数组中的属性$age function __sleep(){ $arr = array("name","age"); return $arr; } //重新生成对象是，并重新赋值$age为40 function __wakeup(){ $this->age = 36; } } $pThree = new PersonTwo("乐杨俊",20); //把对象序列化，返一个字符串，调用了__sleep()方法，忽略没在数组中的属性$age $pThree_string = serialize($pThree); echo '
'.$pThree_string; $pThree_string2 = unserialize($pThree_string); //反序列化形成对象$pThree_string2 重新赋值$age=40 $pThree_string2->say(); /** *类的自动加载 */ function __autoload($className){ require_once $className.'.php'; } //MyClass1类不存在自动调用__autoload()函数，传入参数“MyClass1” $objs = new MyClass1(); ?>
'; $man->name = 'leyangjun'.'
'; echo $man->name; echo $man2->name; $man->say(); $man->runMethods(); /** *构造方法与析构方法 *描述：当创建一个对象时，它将自动调用构造函数，也就是使用new这个关键字来实例化的时候自动调用构造方法 *在一个类中只能申明一个构造方法 **/ class NewPerson{ var $name; var $sex; var $age; //定义一个构造方法（这是PHP5中的变化，以前的版本中，构造函数的名称必须与类名相同） function __construct($name,$sex,$age){ //通过构造方法传来的$name给成员属性$this->name赋初始值 $this->name = $name; $this->sex = $sex; $this->age = $age; } function say(){ echo "
名字：".$this->name.'---性别：'.$this->sex.'---年龄：'.$this->age; } /** *析构函数：在销毁一个类之前执行的一些操作或完成一些功能，如：关闭文件、释放结果集等 *析构函数不能带有任何参数 **/ function __destruct(){ echo "
再见".$this->name; } } $NewMan = new NewPerson("菠萝蜜","男",25); $NewMan->say(); //类的封装 class Encapsulation{ private $name; //认得名字被private封装上了 function __construct($name){ $this->name=$name; } public function say(){//前面不写默认是public echo "
名字：".$this->name; } public function getName(){ return("
获取私有属性：".$this->name); } function __destruct(){ echo "
林苏：".$this->name; } } $p1 = new Encapsulation("长林军"); $name = $p1->getName(); $p1->say(); echo $name; /** *__SET __GET() __isset() __unset()方法 * 一般来说，总是把类的属性定义为private，这更符合现实的逻辑。但是，对属性的读取和赋值操作是非常频繁的， *因此在PHP5中，预定义了两个函数”__get()”和”__set()”来获取和赋值其属性,以及检查属性的”__isset()”和删除属性的方法”__unset()”。 */ class Person3{ private $name; private $sex; private $addess; private $myData=3; //__set()方法来设置私有属性 function __set($property_name,$property_value){ echo "
在这直接设置私有属性值的时候，自动调用这个__set()方法为私有属性设置值
"; $this->$property_name = $property_value; } //__get()方法用来获取私有属性 function __get($property_name){ //echo "在直接获取私有属性值的时候，自动调用了这个__get()方法
"; if(isset($this->$property_name)) { return($this->$property_name); }else{ return ('没有你要的值！'); } } //__isset判断私有成员是否存在 public function __isset($p){ //echo "当在类外部使用isset()函数测定 私有成员 $p时，自动调用
"; return isset($this->$p); } //__unset 删除私有成员 public function __unset($privateAttribute){ //echo "当在类外部使用unset()函数来删除私有成员时自动调用的
"; unset($this->$privateAttribute); } } $p3 = new Person3(); $p3->name='leyangjun'; var_dump($p3->age); echo '姓名：'.$p3->name.'
'; if(isset($p3->addess)) { echo $p3->addess.'
'; }else{ echo '不存在
'; } unset($p3->myData); echo $p3->myData.'
'; //继承 class titalMan{} class Student extends titalMan{ } /** *方法重载 *PHP里面没有方法重载。不能重载也就是在你的项目中不能定义相同方法名的方法 *我们这里所指的重载新的方法所指的是什么呢？其实我们所说的重载新的方法就是子类覆盖父类的已有的方法， **/ /** *子类调用父类的方法：一种是使用父类的 "类名::" 来调用父类的方法 className::testFunction(); * 一种是使用 "parent::"的方式来调用父类中的方法 parent::say(); **/ /** *访问类型 *public(公有的、默认的):公有修饰符，类中的成员将没有访问限制，所有的外部成员都可以访问（读和写） *private(私有的):私有修改符,被定义为private的成员,对同一类里的所有成员是可见的，没有访问限制；但类的外部是不允许改变和操作，对于该类的子类，也不能访问。 *protected(受保护的)：保护成员修饰符,被修饰为protected的成员不能被该类的外部代码访问。但是对于该类的子类有访问权限，可以进行属性、方法的读及写操作,该子类的外部代码包括其的子类都不具有访问其属性和方法的权限。 **/ /** *final关键字的应用 *这个关键字用来定义类和定义方法,不能使用final定义成员属性，因为final是常亮的意思，在php定义常亮的是define()函数 *使用final关键标记的类不能被继承 **/ final class leyangjunA{} //class leyangjunB extends leyangjunA{} 不能被继承 //使用final关键标记的方法不能被子类覆盖，是最终版本； class leyangjunC{ final function say(){} } class leyangjunD extends leyangjunC{ //function say(){} 不能重写父类的方法 } /** *static 和 const关键字的使用 *static关键字是描述成员属性和成员方法是静态的； *类的静态变量，非常类似全局变量，能够被所有类的实例共享，类的静态方法也是一样的，类似于全局函数 * *声明类成员或方法为static，就可以不实例化类而直接访问。不能通过一个对象来访问其中的静态成员（静态方法除外） *在做项目的时候就是使用类名去访问 * *const:是一个定义常量的关键字，在php中定义常量使用的是define(),但是在类里面定义常量使用 “const休息成员属性的访问方式” *和static修饰的成员访问的方式差不多，也是用“类名”，在方法里面使用self关键字。不能使用"$"符号，也不能使用对象来访问。 */ class StaticPerson{ public static $myCountry='中国'; public static $myStatic='foo'; const constant = '
constont value';//定义一个常量 public function staticValue(){ //内部调用静态属性 return '
我的'.self::$myStatic; } public static function myNeiBu(){ //内部调用静态属性 return '内部静态方法:'; } public static function say(){ echo self::myNeiBu(); echo '我是中国人'; } public function showConstant(){ echo self::constant; //使用self::访问常量 } } $foo = new StaticPerson(); $foo->showConstant(); //echo $foo::constant; 是不允许的 echo $foo->staticValue().'
'; echo StaticPerson::$myCountry; //输出静态属性 StaticPerson::say(); //类名访问静态方法 StaticPerson::$myCountry="
美国"; echo StaticPerson::$myCountry.'
'; /** *__toString() *在直接输出对象引用时自动调用执行的方法。 * */ class TestClass{ public $foo; public function __construct($foo){ $this->foo = $foo; } public function __toString(){ return '__toString方法:'.$this->foo; } } $class = new TestClass('hello world!'); //直接输出$class是会报错的，如果里面加了__toString()方法，直接输出对象的时候，就不会产生错误，而直接调用__toSring()方法（一定要有个return语句） echo $class.'
'; /** *克隆对象 --clone 或 __clone *根据一个对象完全克隆一个一模一样的对象，互不干挠 */ class PersonOne{ //成员属性 var $name; var $sex; var $age; function __construct($name="",$sex="",$age=""){ $this->name=$name; $this->sex=$sex; $this->age=$age; } function say(){ echo "我的名字：".$this->name.'性别：'.$this->sex.'年龄：'.$this->age.'
'; } } $pOne = new PersonOne('leyangjun','男','25'); //使用clone 克隆新对象$pTwo,和$pOne对象具有相同的属性和方法 $pTwo = clone $pOne; $pOne->say(); $pTwo->say(); class PersonThree{ //成员属性 var $name; var $sex; var $age; function __construct($name="",$sex="",$age=""){ $this->name=$name; $this->sex=$sex; $this->age=$age; } function say(){ echo "我的名字：".$this->name.'性别：'.$this->sex.'年龄：'.$this->age.'
'; } //对象克隆是自动调用的方法，如果想在克隆后改变对象内容，需要在__clone中重写原本的属性和方法 function __clone(){ //$this指的复本 $this->name = '我是假的'.$this->name; $this->age = 30; } } $Three1 = new PersonThree('乐杨俊','男',28); $Three2 = clone $Three1; $Three1->say(); $Three2->say(); /** *__call 处理调用报错 *调用内部方法不存在程序就报错停止，使用__call可以提示调用的方法及使用参数不存在，但程序继续执行。 */ class ErrorClass{ function __call($functionName,$args){ echo "
你所调用的函数：$functionName 参数："; print_r($args); echo '不存在
'; } } $ErrorClass = new ErrorClass(); $ErrorClass->demoTest("one","two","three"); echo '程序调用不出安在的不会退出可以执行到这里
'; /** *抽象类和抽象方法 *抽象方法：没有定义方法实体，在方法申明的时候没有大括号以及其中的内容，直接加分号结束，前面加一个关键字“abstract” --->abstract function fun1(); *抽象类：里面可以有不是抽象方法和成员属性，但是要有一个抽象的方法，这个类就必须申明为抽象类 使用“abstract”来修饰 --->abstract calss Demo{} */ abstract class chouxiang{ abstract function talk(); abstract function talk2(); public function talk3(){ echo '父类非抽象方法talk3
'; } } //$CX = new chouxiang(); //抽象类不能实例化，只能继承（子类必须把父类中的抽象方法全部都实现） class TestCx extends chouxiang{ //子类必须把父类中的抽象方法全部都实现 function talk(){ echo '重写父类talk方法
'; } function talk2(){ echo '重写父类talk2方法
'; } } $TestCx = new TestCx();//子类实现了父类的抽象方法，所以可以实例化 $TestCx->talk(); $TestCx->talk3(); /** *php接口技术（关键字：interface） *描述：php语言与大多数编程语言一样不支持多重继承，也就是每个类只能继承一个父类 *解析：接口是一种特殊的抽象类，抽象类又是一种特殊的类，所以接口是一种特殊的类。（接口里面所有的方法必须都是申明为抽象方法，另外接口 * 里面不能申明变量，而且接口里面所有的成员都是public权限的。所以子类实现的时候也一定要使用public权限。） **/ //定义一个接口One interface One{ //定义一个常量（接口里面不能定义变量成员） const constant = 'constant value'; //定义一个抽象方法fun1 --- 接口里面的所有方法都要是public（默认的） public function fun1(); public function fun2(); } //注：因为接口是一种特殊的抽象类，里面所有的方法都是抽象方法，所以接口也不能产生实例对象，它也做为一种规范，所有抽象方法需要子类去实现 //使用 extends 关键字让一个接口继承另一个接口 interface Two extends One{ function fun3(); function fun4(); } //注：定义一个接口的子类去实现接口中的全部抽象方法使用关键字“implements”而不是extends class JK implements One{ public function fun1(){ echo '
接口方法fun1'; } public function fun2(){ echo '
接口方法fun2
'; } } $jk = new JK(); $jk->fun1(); $jk->fun2(); /** *注：前面说过，PHP是单继承，一个类只有一个父类，但是一个类可以实现多个接口，遵循多个规范。 *class JK2 implements 接口一,接口二,......{ //必须把所有接口中的方法都要实现才可以实例化对象。 } PHP中不仅可以实现多个接口，也可以继承一个类的同时实现多个接口，一定要先继承类再去实现接口； class JK3 extends 类名一 implements 接口一,接口二,.......{ //所有接口中的方法都要实现才可以实例化对象 //........ } **/ /** *多态应用 *解析：所谓多态是指一段程序能后处理多种类型对象的能力，比如：公司不同员工不同职位发放工资，多以同一个发放工资的方法就出现了多种形态。 *对程序来说，多态就是把子类对象赋值给父类引用，能后调用父类的方法，去执行子类覆盖父类的那个方法，但在php里是弱类型的，对象引用都是一样的不分类引用，还是子类引用。 **/ //定义一个形状的接口，里面有两个抽象方法让子类去实现 interface Shape{ function area(); function perimeter(); } //定义了一个矩形子类实现了形状接口中的周长和面积 class Rect implements Shape{ private $width; private $height; function __construct($width,$height){ $this->width = $width; $this->height = $height; } function area(){ return '矩形面积是：'.($this->width*$this->height); } function perimeter(){ return '矩形周长是：'.(2*($this->width+$this->height)); } } //定义一个圆形子类实现了形状接口中的周长和面积 class Circular implements Shape{ private $radius; function __construct($radius){ $this->radius = $radius; } function area(){ return '圆形面积是：'.(3.14*$this->radius*$this->radius); } function perimeter(){ return '圆形面积是：'.(2*3.14*$this->radius); } } //把子类矩形对象赋给形状的一个引用 ECHO '
'; $shape = new Rect(5,10); echo $shape->area().'
'; echo $shape->perimeter().'
'; //把子类圆形对象赋给形状的一个引用 $shape = new Circular(10); echo $shape->area().'
'; echo $shape->perimeter().'
'; //通过上例我们看到,把 矩形对象 和 圆形对象 分别赋给了变量$shape,调用$shape引用中的面积和周长的方法，出现了不同的结果，这就是一种多态的应用， //其实在我们PHP这种弱类形的面向对象的语言里面，多态的特性并不是特别的明显，其实就是对象类型变量的变项应用 /** *把对象串行化（序列化：serialize(),反序列化：unserialize() ） *描述：有时候需要把一个对象在网络上传输，为了方面传输，可以把整个对象转化为二进制串，等到达另一端时，在还原为原来的对象，这个过程叫串行化。 *例子：想把一辆汽车通过轮船运到美国去，因为汽车的体积较大，我们可以把汽车拆成小的部件，然后我们把这些部件通过轮船运到美国去，到美国在重新组装回汽车。 *两种情况必须进行对象穿行化： * 一：把一个对象在网络中传输的时候要将对象串行化 * 二：把对象写入文件或是数据库的时候用到串行化 *serialize(): 串行化/序列化 一个对象 *unserialize(): 反串化/反序列化 把对象转化的二进制字符串在转化为对象 */ class PersonMans{ var $name; function __construct($name=""){ $this->name=$name; } function say(){ echo '
我的名字：'.$this->name; } } $PersonMans = new PersonMans('leyangjun wa haha'); $p1_string = serialize($PersonMans);//把对象串行化，返回一个字符串 echo '
'.$p1_string.'
'; $p2_string = unserialize($p1_string); $p2_string->say(); /** *魔术方法__sleep()和__wakeup() *描述：在对象串行化的时候，会调用一个__sleep()方法来完成一些睡前的事情；而在重新醒来，即由二进制串重新组成一个对象的时候，则会自动调用PHP的另一个函数__wakeup(),做一些对象醒来就要做的动作。 *注：__sleep()函数不接受任何参数 */ class PersonTwo{ var $name; function __construct($name="",$age=""){ $this->name=$name; $this->age=$age; } function say(){ echo '
我的名字：'.$this->name.' 年龄：'.$this->age; } //指定串行化把返回的数组中$name 串行化，忽略没在数组中的属性$age function __sleep(){ $arr = array("name","age"); return $arr; } //重新生成对象是，并重新赋值$age为40 function __wakeup(){ $this->age = 36; } } $pThree = new PersonTwo("乐杨俊",20); //把对象序列化，返一个字符串，调用了__sleep()方法，忽略没在数组中的属性$age $pThree_string = serialize($pThree); echo '
'.$pThree_string; $pThree_string2 = unserialize($pThree_string); //反序列化形成对象$pThree_string2 重新赋值$age=40 $pThree_string2->say(); /** *类的自动加载 */ function __autoload($className){ require_once $className.'.php'; } //MyClass1类不存在自动调用__autoload()函数，传入参数“MyClass1” $objs = new MyClass1(); ?>
评论（0）
暂无评论
