PHP系列（四）PHP面向对象程序设计

yao000

php面向对象程序设计

　　面向对象的优势：可读性、可重用性、稳定性、维护性、可测试性
　　简单格式：
　　［修饰符］class 类名{
　　         [成员属性]
　　         [成员方法]
　　}
　　完整格式：
　　［修饰符］class 类名 [extends 父类]  [implements 接口 ] {
　　         [成员属性]
　　         [成员方法]
　　}
　　成员方法格式：
　　[修饰符] function 方法名(参数){
　　[方法体]
　　[return返回值]
　　}
　　修饰符：public  protected  private static  abstract  final
　　$对象名称=new 类名称();
　　$引用名=new 类名(构造函数)
　　$引用名->成员属性=赋值
　　$引用名->成员方法(参数)
　　class student{
　　public$name = "ssw";
　　public$age = "20";
　　publicfunction study($num,$yum){
　　return"学习成功";
　　}
　　}
　　$s = new student();
　　echo $s->name;
　　echo $s->age;
　　$s->study();
　　

　　1、特殊的对象引用 $this(代表对象的一个引用)
　　class Person{
　　         public $name;
　　         public $sex;
　　         public function say(){
　　                   echo "我的名子：".$this->name."性别：".$this->sex;
　　         }
　　}
　　$p = new Person();
　　$p -> name = ssw;
　　$p -> sex =male;
　　$p -> say();
　　显示为：我的名子：ssw性别：male
　　2、构造方法
　　（1）是对象创建完成以后、第一个自动调用的方法
　　（2）方法名比较特殊、可以和类名相同名的方法名、
　　（3）作用：给对象中的成员属性赋初值
　　class Person{
　　public$name;
　　public$sex;
　　public$age;
　　publicfunction Person($n,$s,$a="25"){
　　$this->name=$n;
　　$this->sex=$s;
　　$this->age=$a;
　　}
　　publicfunction say(){
　　echo"我的名子：".$this->name."性别：".$this->sex."年龄：".$this->age;
　　}
　　}
　　$p = new Person(ssw,male,22);
　　$p1 = new Person(ssw,male);
　　$p -> say();
　　显示为：我的名子：ssw性别：male年龄：22
　　
　　classPerson{
　　         public $name;
　　         public $sex;
　　         public $age;
　　/*
　　         public functionPerson($n,$s,$a="25"){
　　                   $this->name=$n;
　　                   $this->sex=$s;
　　                   $this->age=$a;
　　         
　　         }
　　*/
　　         public function__construct($n,$s,$a="25"){
　　                   $this->name=$n;
　　                   $this->sex=$s;
　　                   $this->age=$a;
　　         
　　         }
　　         public function say(){
　　                   echo "我的名子：".$this->name."性别：".$this->sex."年龄：".$this->age;
　　         }
　　}
　　$p= new Person(ssw,male,22);
　　$p1= new Person(ssw,male);
　　$p-> say();
　　显示为：我的名子：ssw性别：male年龄：22
　　
　　
　　3、析构函数
　　对象释放前调用、没有参数、__destruct
　　classPerson{
　　         public $name;
　　         public $sex;
　　         public $age;
　　         public function__construct($n,$s,$a="25"){
　　                   $this->name=$n;
　　                   $this->sex=$s;
　　                   $this->age=$a;
　　         }
　　         public function say(){
　　                   echo "我的名子：".$this->name."性别：".$this->sex."年龄：".$this->age;
　　         }
　　         function __destruct(){
　　                   echo "{$this->name}再见！";
　　         }
　　}
　　$p= new Person(ssw,male,22);
　　$p1= new Person(qzx,male);
　　显示为：（$p在内存中存储为栈。New Person()在内中存储为堆）
　　qzx再见！
ssw再见！
　　
　　封装继承多态
　　
　　4、类的封装性
　　方法的封装：
　　（1）、Public（）公共的：能在程序的任意地方引用！类内类外都可以引用！
　　（2）、Protected（）保护的：声明的类内能用，继承类能引用！
　　（3）、Private() 私有的：只能在本类内调用
　　
　　classPerson{
　　         private $name;
　　         private $age;
　　         private $sex;
　　         function__construct($name="", $age=0, $sex="男"){
　　                   $this->name=$name;
　　                   $this->age=$age;
　　                   $this->sex=$sex;
　　         }
　　         function getAge(){
　　                   if($this->age < 20){
　　                            return$this->age;
　　                   }else if($this->age age- 5;
　　                   }else{
　　                            return 29;
　　                   }
　　         }
　　
　　         function __destruct(){
　　                   echo "再见：".$this->name;
　　         }
　　}
　　$p1= new Person("ssw", 80, "女");
　　echo$p1->getAge();
　　显示为：29再见：ssw
　　
　　
　　5、魔术方法
　　__get  获取类中私有属性值的时候、自动调用的方法
　　自动调用、是在直接访问私有成员时、自动调用
　　classPerson{
　　         private $name;
　　         private $age;
　　         private $sex;
　　function__get($a){
　　         echo $a."get";
　　}
　　}
　　$p1= new Person("ssw", 80, "女");
　　$p1->name."";
　　$p1->age;
　　显示为：name####age####
　　
　　classPerson{
　　         private $name;
　　         private $age;
　　         private $sex;
　　function__construct($name="", $age=0, $sex="男"){
　　                            $this->name =$name;
　　                            $this->age =$age;
　　                            $this->sex =$sex;
　　                   }
　　function__get($a){
　　         echo $this->$a."##";
　　         }
　　}
　　$p1= new Person("ssw", 80, "女");
　　$p1->name;
　　$p1->age;
　　$p1->sex;
　　显示为：ssw##80##女##
　　
　　__set 为类中私有属性赋值的时候、自动调用的方法
　　自动调用、是在直接设置私有属性值时、二个参数
　　class Person{
　　         private $name;
　　         private $age;
　　         private $sex;
　　function__construct($name="", $age=0, $sex="男"){
　　                            $this->name = $name;
　　                            $this->age = $age;
　　                            $this->sex = $sex;
　　                   }
　　function __set($n,$v){
　　         echo $n."=".$v;
　　         echo "";
　　         echo $this->$n=$v;
}
　　}
　　$p1 = newPerson("ssw", 80, "女");
　　$p1->name="王子";
　　显示为：name=王子王子
　　class Person{
　　         private $name;
　　         private $age;
　　         private $sex;
　　
　　function__construct($name="", $age=0, $sex="男"){
　　                            $this->name = $name;
　　                            $this->age = $age;
　　                            $this->sex = $sex;
　　                   }
　　
　　function __set($n,$v){
　　         if($n=="age"){
　　                   if($v < 0 or $v > 100)
　　                            return;
　　                   }
　　         $this->$n = $v;
　　         }
　　
　　function __get($pre){
　　         return $this->$pre;
　　         }
　　
　　}
　　$p1 = newPerson("ssw", 80, "女");
　　$p1->name="王子";
　　$p1->age=109;
　　$p1->sex="女";
　　echo $p1->name;
　　echo $p1->sex;
　　echo $p1->age;//echo $p1->__get("age");__get不是私有的、外部可以通过对象来调用
　　显示为：王子女80
　　__isset()  判断类中私有属性是否存在时、自动调用的方法
　　 isset()在使用isset判断一个私有属性是否存在时、自动调用__isset()魔术方法、参数则是属性名称
　　class Person{
　　private$name;
　　private$age;
　　private$sex;
　　function__construct($name="",$age=0,$sex="男"){
　　$this->name=$name;
　　$this->age=$age;
　　$this->sex=$sex;
　　}
　　function__isset($Pro){
　　if($Pro=="age")
　　returnfalse;
　　returnisset($this->$Pro);
　　}
　　}
　　$p = new Person("ssw",29,"男");
　　if(isset($p->name)){
　　echo"这个对象中的name是存在的属性";
　　}else{
　　echo"对象p中不存在name值";
　　}
　　显示为：这个对象中的name是存在的属性
　　__unset  销毁类中私有成员时、自动调用的方法
　　class Person{
　　private$name;
　　private$age;
　　private$sex;
　　function__construct($name="",$age=0,$sex="男"){
　　$this->name=$name;
　　$this->age=$age;
　　$this->sex=$sex;
　　}
　　function__isset($Pro){
　　if($Pro=="age")
　　returnfalse;
　　returnisset($this->$Pro);
　　}
　　function__unset($Pro){
　　if($Pro!="age"){
　　unset($this->$Pro);
　　}
　　}
　　}
　　$p = new Person("ssw",29,"男");
　　unset($p->name);
　　if(isset($p->name)){
　　echo"这个对象中的name是存在的属性";
　　}else{
　　echo"对象p中不存在name值";
　　}
　　显示为：对象p中不存在name值
　　6、类的继承性
　　类的继承访问控制：
　　（1）、子类使用extends继承父类、子类可以将父类中所有的内容都继承过来
　　（2）、private 私有的权限、只能自已类里用、不能在别的类中用、包括自已的子类
　　（3）、protected 保护的权限、只能是自已类和自已子类中使用、不能在类外面使用
　　（4）、public 公有的权限、所有都可以、自已、子类、类外部都可以使用
　　class Person{
　　public$name;
　　protected$age;
　　private$sex;
　　function__construct($name, $age, $sex){
　　$this->name= $name;
　　$this->age= $age;
　　$this->sex= $sex;
　　}
　　publicfunction say(){
　　echo"我的性别:{$this->sex}";
　　}
　　publicfunction eat(){
　　}
　　}
　　class Student extends Person{
　　var$school;
　　functionstudy(){
　　}
　　}
　　class Teacher extends Student{
　　var$gz;
　　functionjiao(){
　　echo"我的年龄是：".$this->age;
　　}
　　}
　　$t = new Teacher("ssw",30,"男");
　　echo $t -> name;
　　$t -> jiao();
　　$t -> say();
　　显示为：ssw我的年龄是：30我的性别:男
　　继承中的重载（覆盖）--在子类中可以重写父类同名的方法（方法也可以拓展）
　　对象->成员
　　类::成员
　　Parent::成员  使用用parent::访问父类中被覆盖的方法
　　重要：只要是子类的构造方法、去覆盖父类中的构造方法、一定要在子类的最上面调用一下父类被覆盖的方法
　　权限问题：子类只能大于或等于父类的权限、不能小于
　　class Person{  //使用用parent::访问父类中被覆盖的方法
　　public$name;
　　protected$age;
　　protected$sex;
　　function__construct($name, $age, $sex){
　　$this->name= $name;
　　$this->age= $age;
　　$this->sex= $sex;
　　}
　　publicfunction say(){
　　echo"我的名子：{$this->name},我的年龄是：{$this->age},我的性别:{$this->sex} ";
　　}
　　}
　　class Student extends Person{
　　var$school="jtuniverty!";
　　functionsay(){
　　//      echo"我的名子：{$this->name},我的年龄是：{$this->age},我的性别:{$this->sex} ";
　　//      Person::say();
　　parent::say();//这三个是一样的！
　　echo"我的学校是：{$this->school}";
　　}
　　}
　　$p = new Student("ssw", 28,"男");
　　$p -> say();
　　显示为：我的名子：ssw,我的年龄是：28,我的性别:男我的学校是：jtuniverty!
　　class Person{  //子类的构造方法、去覆盖父类中的构造方法
　　public$name;
　　protected$age;
　　protected$sex;
　　function__construct($name, $age, $sex){
　　$this->name= $name;
　　$this->age= $age;
　　$this->sex= $sex;
　　}
　　publicfunction say(){
　　echo"我的名子：{$this->name},我的年龄是：{$this->age},我的性别:{$this->sex} ";
　　}
　　}
　　class Student extends Person{
　　var$school;
　　function__construct($name, $age, $sex, $school){
　　parent::__construct($name,$age, $sex);
　　$this->school= $school;
　　}
　　functionsay(){
　　parent::say();//这三个是一样的！
　　echo"我的学校是：{$this->school}";
　　}
　　}
　　$p = new Student("ssw", 28,"男", "上海交通大学");
　　$p -> say();
　　显示为：我的名子：ssw,我的年龄是：28,我的性别:男我的学校是：上海交通大学
　　7、Php常见的关键字
　　Instanceof 操作符用于检测当前对象实例是否属于某一个类的类型
　　If($p instanceof Person){
　　Echo“这个$p是Person类的对象”;
　　}else{
　　Echo“对象不属于这个类”;
　　}
　　Final 用于类方法名前、不能修饰成员属性
　　（1）final可以修饰类、这个类不能扩展、不能有子类、这个类是最终类
　　（2）final可以修饰方法、这个方法、就不能在子类中覆盖、不能让子类来改这个方法、或扩展这个方法、这个方法也是最终方法。
　　Static 可以修饰属性和方法、不能修饰类
　　（1）使用static修饰成员属性、存在内存的初始化表态段
　　（2）可以被所有同一个类的对象共用
　　（3）第一个用到类、类在加载到内存时、就已经将静态的成员加到了内存
　　对象->成员
　　类：：成员
　　（4）静态的成员一定要使用类来访问（静态成员不可以由对象通过->操作符来访问）
　　（5）self可以在类中的方法中、代表自已类的（$this）。子类用parent::静态名
　　（6）静态成员一但被加载、只有脚本结束才释放
　　（7）在静态的方法中、是不能访问非静态的成员的
　　（8）只要是能使用静态的环境下声明方法、就最好使用静态方法（效率）
　　class Foo
　　{
　　public static $my_static = 'foo';
　　public function staticValue() {
　　return self::$my_static;
　　}
　　}
　　class Bar extends Foo
　　{
　　public function fooStatic() {
　　return parent::$my_static;
　　}
　　}
　　print Foo::$my_static . "\n";
　　$foo = new Foo();
　　print $foo->staticValue() ."\n";
　　//print $foo->my_static ."\n";      // Undefined"Property" my_static
　　//print $foo::$my_static . "\n";
　　//$classname = 'Foo';
　　//print $classname::$my_static ."\n"; // PHP 5.3.0之后可以动态调用
　　print Bar::$my_static . "\n";
　　$bar = new Bar();
　　print $bar->fooStatic() ."\n";
　　显示为：foofoo foo foo
　　
　　单态设计模式
　　单态（单例、单件）
　　（1）如果想让一个类、只能有一个对象、就要先让这个类、不能创建对象、将构造方法private
　　（2）可以在类的内存使用一个方法、来创建对象
　　class Person{
　　         static $obj = null;
　　         static function getObj(){
　　//如果第一次调用时、没有对象则创建、以后调用时、直接使用第一次创建的对象
　　                   if(is_null(self::$obj)){
　　                            self::$obj = newself;
　　                   }
　　                   return self::$obj;
　　         }
　　         
　　         function __destruct(){
　　         echo "####";
　　         }
　　         function say(){
　　                   echo "say";
　　         }
　　}
　　$p =Person::getObj();
　　$p ->say();
　　显示为：say####
　　
　　Const（类常量）修饰的成员属性为常量、只能修饰成员属性
　　类中：
　　（1）常量建议用大写、不能使用$
　　（2）常量一定要在声明时就给好初值
　　（3）常量的访问方式和static的访问方式相同、但只能读
　　在类外部使用类名：：常量名
　　在类内部使用 self：：常量名
　　class MyClass
　　{
　　    const constant = 'cv';
　　
　　    function showConstant() {
　　        echo self::constant . "\n";
　　    }
　　}
　　
　　echoMyClass::constant . "\n";
　　
　　//$classname ="MyClass";
　　//echo$classname::constant . "\n"; // PHP 5.3.0之后
　　
　　$class = newMyClass();
　　$class->showConstant();
　　
　　//echo$class::constant."\n"; // PHP 5.3.0之后
　　显示为：cv cv
　　
　　8、php魔术方法
　　__construct()  __destruct() __set()   __get()   __isset()  __unset()
　　__tostring()
　　（1）直接使用 echo print printf输出一个对象引用时、自动调用这个方法
　　（2）将对象的基本信息放在__toString()方法内部、形成字符串返回
　　（3）__toString()方法中、不能有参数、而且必须返回一个字符串
　　class test{
　　         private $foo;
　　         public function __construct($foo){
　　                   $this->foo = $foo;
　　         }
　　         public function __toString(){
　　                   return $this->foo;
　　         }
　　}
　　
　　$p = newtest("ssw");
　　echo $p;
　　显示为：ssw
　　
　　克隆对象__clone()方法
　　克隆对象：
　　（1）使用clone这个关键字复制一个对象
　　__clone()魔术方法：
　　（1）是在克隆对象时、自动调用的方法
　　（2）作用：和构造方法一样、是对新克隆的对象进行初使化
　　（3）在这个__clone()方法中$this代表的是副本、所以就可以给所有副本的成员初始化
　　class Person{
　　         public $name;
　　         public $age;
　　         public $sex;
　　
　　         function __construct($name,$age,$sex){
　　                   $this->name = $name;
　　                   $this->age = $age;
　　                   $this->sex = $sex;
　　         }
　　         function say(){
　　                   echo "名子：{$this->name},年龄：{$this->age},性别：{$this->sex}";
　　         }
　　         function __destruct(){
　　         }
　　         function __clone(){
　　                   $this->name="克隆的";
　　                   $this->age=2;
　　         }
　　}
　　$p = newPerson("ssw", 22, "男");
　　$p->say();
　　echo"";
　　$p2=clone $p;
　　$p2->name="www";
　　$p2->say();
　　显示为：
　　名子：ssw,年龄：22,性别：男
名子：www,年龄：2,性别：男
　　
　　__call()魔术方法：
　　（1）在调用一个对象中不存的方法时、自动调用__call方法
　　（2）有二个参数、第一个参数是、调用的不存在的方法的方法名、第二个参数、调用这个不存在的方法名的方法参数、
　　（3）作用：可以写提示、但这个不是主要的功能、将方法的功能相似、但方法名不同的、就可以用这个方式来完成
　　class Person{
　　         public $name;
　　         public $age;
　　         public $sex;
　　
　　         public $marr = array("say","run", "eat");
　　
　　         function __call($method,$args){
　　                   if(in_array($method,$this->marr)){
　　                            echo$args['0']."";
　　                   }else{
　　                            echo "你调用的方法{$method}()不存在";
　　                   }
　　         }
　　
　　         function __construct($name,$age,$sex){
　　                   $this->name = $name;
　　                   $this->age = $age;
　　                   $this->sex = $sex;
　　         }
　　}
　　
　　$p = newPerson();
　　$p->say("sss");
　　$p->run("rrr");
　　$p->eat("eee");
　　$p->ww("www");
　　显示为：sss  rrr  eee你调用的方法ww()不存在
　　
　　对象串行化
　　$p=newPerson();//声明一个对象
　　$str=serialize($p);//将对象串行化
　　File_put_contents(“objstr.txt”,$str);//将字符串保存在文件objstr.txt中
　　——————————
　　读出字符串从文件中、返串行化
　　$str=file_get_contents(“objstr.txt”);
　　$p =unserialize($str);
　　$p->say();
　　__sleep() 在串行化时自动调用方法
　　作用：可以设置需要串行化的对象属性
　　只要在这个方法中、返回一个数、在数组中声明了那个属性、那个属性就会被串行化、没有在这个数组中的就不被串行化、默认这个方法、全部属性都串行化、
　　
　　__wakeup() 在返串行化时自动调用的方法
　　作用：对象串行化回来的对象、进行初始化，用的和下面二个方法作用相似
　　__construct()
　　__clone()
　　
　　Function __sleep(){
　　         Echo “串行化name和age”;
　　         Return array(“name”,”age”);
　　}
　　Function __wakeup(){
　　         Echo “返串行化时自动调用这个方法”;
　　         $this->age=12;
　　}
　　
　　数组串行化
　　Json_encode串行化
　　Json_decode返串行化
　　$arr =array("name"=>"ssw", "age"=>10,"sex"=>"男");
　　
　　//串行化
　　$str =json_encode($arr);
　　
　　//返串行化、第二个参数true返串行化为数组(无第二个参数为对象 )
　　$parr =json_decode($str, true);
　　echo$parr['name'];
　　显示为：ssw
　　
　　魔术方法__set_state()
　　(1)、eval()函数、检查并执行php代码
　　$arr ="echo 'ss';";
　　echo $arr;
　　eval($arr);
　　显示为：echo 'ss';  ss
　　
　　(2)var_export()返回传递给该函数的变量的结构信息(和var_dump类似)
　　返回合法的php代码、可以直接当作php代码赋值一个变量
　　   $arr = array ( "apple" ,"banana" , "orange" );
　　    var_export ( $arr );
　　显示为：array ( 0 => 'apple', 1=> 'banana', 2 => 'orange', )
　　
　　__set_state()方法、就是在使用var_export()方法时、导出一个类的信息时自动调用的方法
　　输出内容以该魔术方法的返回值为准。__set_state()必须的为静态（static）函数、参数必为数组。
　　
　　class Person{
　　         public $name;
　　         public $age;
　　         public $sex;
　　         function __construct($name, $age,$sex){
　　                   $this->name = $name;
　　                   $this->age = $age;
　　                   $this->sex = $sex;
　　         }
　　         static function __set_state($arr){
　　                            print_r($arr);
　　                            echo"";
　　                            $p = newPerson("李静", 20, "女");
　　                  
　　                            return $p;
　　                   }
　　}
　　
　　$p = newPerson("ss", 39, "女");
　　
　　//$p ->name = "111";
　　//$p -> age= 30;
　　
　　eval('$b='.var_export($p, true).";");
　　var_dump($b);
　　显示为：
　　Array( [name] => ss [age] => 39 [sex] => 女 )
object(Person)#2 (3) { ["name"]=> string(6) "李静"["age"]=> int(20) ["sex"]=> string(3) "女"}
　　
　　class Person{
　　         public $name;
　　         public $age;
　　         public $sex;
　　         function __construct($name, $age,$sex){
　　                   $this->name = $name;
　　                   $this->age = $age;
　　                   $this->sex = $sex;
　　         }
　　         static function __set_state($arr){
　　                            //print_r($arr);
　　         
　　                            $p = newPerson("李静", 20, "女");
　　                            $p->name=$arr['name'];
　　                            $p->age=$arr['age'];
　　                            return $p;
　　                   }
　　}
　　
　　$p = newPerson("ss", 39, "女");
　　
　　$p -> name= "111";
　　$p -> age =30;
　　
　　eval('$b='.var_export($p, true).";");
　　var_dump($b);
　　显示为：object(Person)#2 (3) {["name"]=> string(3) "111" ["age"]=>int(30) ["sex"]=> string(3) "女" }
　　
　　Php5.3以后新的魔术方法
　　__invoke()在创建实例后、可以直接调用对象
　　class Person{
　　         public $name;
　　         public $age;
　　         public $sex;
　　         function __construct($name, $age,$sex){
　　                   $this->name = $name;
　　                   $this->age = $age;
　　                   $this->sex = $sex;
　　         }
　　
　　                   function __invoke($a,$b,$c){
　　                            echo "在对象引用后加上()调用时自动调用这个方法{$a}{$b}{$c}";
　　                   }
　　}
　　$p = newPerson("ss", 39, "女");
　　$p(1,2,3);
　　显示为：在对象引用后加上()调用时自动调用这个方法123
　　
　　__callstatic()调用不存的在静态方法时、自动调用这个函数
　　class Person{
　　         public $name;
　　         public $age;
　　         public $sex;
　　         function __construct($name, $age,$sex){
　　                   $this->name = $name;
　　                   $this->age = $age;
　　                   $this->sex = $sex;
　　         }
　　                   static function__callstatic($method, $args){
　　                            echo "你调用的静态方法 $method(".implode(".",$args).")不存在";
　　                   }
　　}
　　$p = newPerson("ss", 39, "女");
　　Person::hello(1,2,3);
　　显示为：你调用的静态方法 hello(1.2.3)不存在
　　
　　__autoload 只要在这个脚本中、需要加载类的时候（必须用到类名）、就自动调用这个方法
　　function__autoload($classname){
　　         echo $classname."";
　　         includestrtolower($classname).".class.php";
　　}
　　$t = newTest();
　　$t ->one();
　　显示为：Test  ttt
　　类文件
　　test.class.php
　　         class Test{
　　         
　　         public $name;
　　
　　         public function one(){
　　                   echo "ttt";
　　                   }
　　         }
　　
　　9、php抽象方法和抽象类
　　
　　抽象方法：
　　（1）        声明一个方法、没有方法体（就是不能有{}）、而且直接分号结束
　　（2）        如果是抽象方法、必须使用abstract（抽象关键词来修饰）
　　（3）        除了抽象类中可以有抽象方法、以外、和正常的类完全一样
　　
　　抽象类：
　　（1）        如果类中有一个方法为抽象方法、这个类就是抽象类
　　（2）        如果声明一个抽象类、这个类必须要使用abstract关键字来修饰
　　（3）        抽象类不能创建对象、必须写这个类的子类、将抽象类中的抽象的方法覆盖（加上方法体）
　　（4）         子类必须全部实（覆盖重写）抽象方法、这个类才能创建对象、如果只实现部分、那么还有抽象方法、则类也就必须是抽象类
　　抽象方法作用：
　　抽象方法的作用就是规定了、子类必须有这个方法的实现、功能交给子类。
　　只写出来结构、而没有实现、实现交给具体的子类（按自已的功能）去实现。
　　抽象类的作用：
　　就是要求子类的结构规范、所以抽象类就是一个规范
　　abstract classAbstractClass
　　{
　　 // 强制要求子类定义这些方法
　　    abstract protected function getValue();
　　    abstract protected functionprefixValue($prefix);
　　
　　    // 普通方法（非抽象方法）
　　    public function printOut() {
　　        print $this->getValue() ."\n";
　　    }
　　}
　　
　　classConcreteClass1 extends AbstractClass
　　{
　　    protected function getValue() {
　　        return "ConcreteClass1";
　　    }
　　
　　    public function prefixValue($prefix) {
　　        return"{$prefix}ConcreteClass1";
　　    }
　　}
　　
　　classConcreteClass2 extends AbstractClass
　　{
　　    public function getValue() {
　　        return "ConcreteClass2";
　　    }
　　
　　    public function prefixValue($prefix) {
　　        return"{$prefix}ConcreteClass2";
　　    }
　　}
　　
　　$class1 = newConcreteClass1;
　　$class1->printOut();
　　echo$class1->prefixValue('FOO_') ."\n";
　　
　　$class2 = newConcreteClass2;
　　$class2->printOut();
　　echo$class2->prefixValue('FOO_') ."\n";
　　显示为：ConcreteClass1FOO_ConcreteClass1 ConcreteClass2 FOO_ConcreteClass2
　　
　　10、PHP接口
　　抽象类是一种抽象的类、接口是一种特殊的抽象类、接口也是一种特殊特殊的类
　　（1）        抽象类和接口都有抽象方法
　　（2）        抽象类和接口都不能创建实例对象
　　（3）        抽象类和接口的使用意义也就是作用相同
　　接口和抽象类相比、特殊在哪里：
　　（1）        接口中的方法、必须全部是抽象方法（不能用不抽象的方法）所有在接口中的抽象方法不需要使用abstract、直接使用分号结束即可。
　　（2）        接口中的成员属性、必须是常量、（不能是变量）接口常量和类常量的使用完全相同，但是不能被子类或子接口所覆盖
　　（3）        所有的权限必须是公有的(public)
　　（4）        声明接口不使用class、而是使用interface
　　（5）        接口也可以继承、通过extends操作符
　　（6）        可以使用一个类来实现接口中的全部方法、也可以使用一个抽象类、来实现接口中的部分方法
　　（7）        类或抽象类实现一个接口用implements关键字操作。
　　// 声明一个'iTemplate'接口
　　interfaceiTemplate{
　　    public function setVariable($name, $var);
　　    public function getHtml($template);
　　}
　　// 实现接口
　　class Templateimplements iTemplate{
　　    private $vars = array();
　　    public function setVariable($name, $var){
　　        $this->vars[$name] = $var;
　　    }
　　    public function getHtml($template) {
　　        return $template;
　　    }
　　}
　　
　　//接口也可以继承、通过extends操作符
　　interface a{
　　    public function foo();
　　}
　　interface bextends a{
　　    public function baz(Baz $baz);
　　}
　　Class world {
　　         Function test(){}
　　}
　　// 正确写法
　　class cextents world implements b{
　　    public function foo(){
　　    }
　　publicfunction baz(Baz $baz){
　　    }
　　}
　　//接口继承多个接口、然后类来实现在
　　interface a{
　　    public function foo();
　　}
　　interface b{
　　    public function bar();
　　}
　　interfacec extends a, b{
　　    public function baz();
　　}
　　class dimplements c{
　　    public function foo(){
　　    }
　　    public function bar(){
　　    }
　　    public function baz(){
　　    }
　　}
　　
　　接口常量（和类常量用法一样）
　　interface a{
　　    const b = 'Interface constant';
　　}
　　// 输出接口常量
　　echo a::b;
　　显示为：Interface constant
　　
　　PHP多态
　　         interface USB {
　　                   const WIDTH = 12;
　　                   const HEIGHT = 3;      
　　                   function load();
　　                   function run();
　　                   function stop();   
　　         }
　　         class Cumputer {
　　                   function useUSB(USB $usb) {
　　                            $usb -> load();
　　                            $usb -> run();
　　                            $usb -> stop();              
　　                   }
　　         }
　　         class Mouse implements USB{
　　                   function load() {
　　                            echo "加载鼠标成功!";
　　                   }
　　                   function run() {
　　                            echo "运行鼠标功能!";
　　                   }
　　                   function stop() {
　　                            echo "鼠标工作结束!";
　　                   }
　　         }
　　         class KeyPress implements USB {
　　                   function load() {
　　                            echo "加载键盘成功!";
　　                   }
　　                   function run() {
　　                            echo "运行键盘成功!";
　　                   }
　　                   function stop() {
　　                            echo "停止键盘使用!";
　　                   }
　　         }
　　         class Worker {
　　                   function work() {
　　                            $c = new Cumputer();
　　                           
　　                            $m = new Mouse;
　　
　　                            $k = new KeyPress;
　　
　　                            $c->useUSB($k);
　　                            $c->useUSB($m);
　　                   }
　　         }
　　         $w = new Worker;
　　         $w -> work();
　　显示为：
　　加载键盘成功!
运行键盘成功!
停止键盘使用!
加载鼠标成功!
运行鼠标功能!
鼠标工作结束!
　　
　　与类有关的魔术常量和函数

__LINE__	文件中的当前行号。
__FILE__	文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名。自  PHP 4.0.2 起，__FILE__  总是包含一个绝对路径（如果是符号连接，则是解析后的绝对路径），而在此之前的版本有时会包含一个相对路径。
__DIR__	文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。它等价于  dirname(__FILE__)。除非是根目录，否则目录中名不包括末尾的斜杠。（PHP  5.3.0中新增）  =
__FUNCTION__	函数名称（PHP  4.3.0 新加）。自  PHP 5 起本常量返回该函数被定义时的名字（区分大小写）。在  PHP 4 中该值总是小写字母的。
__CLASS__	类的名称（PHP  4.3.0 新加）。自  PHP 5 起本常量返回该类被定义时的名字（区分大小写）。在  PHP 4 中该值总是小写字母的。
__METHOD__	类的方法名（PHP  5.0.0 新加）。返回该方法被定义时的名字（区分大小写）。
__NAMESPACE__	当前命名空间的名称（大小写敏感）。这个常量是在编译时定义的

　　
　　class_alias— Creates an alias for a class
　　class_exists— 检查类是否已定义
　　get_called_class— the "Late Static Binding" class name
　　get_class_methods— 返回由类的方法名组成的数组
　　get_class_vars— 返回由类的默认属性组成的数组
　　get_class— 返回对象的类名
　　get_declared_classes— 返回由已定义类的名字所组成的数组
　　get_declared_interfaces— 返回一个数组包含所有已声明的接口
　　get_declared_traits— Returns an array of all declared traits
　　get_object_vars— 返回由对象属性组成的关联数组
　　get_parent_class— 返回对象或类的父类名
　　interface_exists— 检查接口是否已被定义
　　is_a— 如果对象属于该类或该类是此对象的父类则返回 TRUE
　　is_subclass_of— 如果此对象是该类的子类，则返回 TRUE
　　method_exists— 检查类的方法是否存在
　　property_exists— 检查对象或类是否具有该属性
　　
　　
　　11、命名空间
　　(1)、任意合法的php代码都可以包含在命名空间中、但只有三种类型的代码受命名空间的影响、类、函数、和常量。命令空间通过关键字 namespace 命名空间名来声明、必须要其它所有代码之前声明
　　（2）、定义多个名子空间、以最后一个为主
　　（3）、在实际编程实践中、非常不提倡在同一个文件中定义多个命名空间、不要在大括号外面加任何代码
　　Namespace  myname{}
　　Namespace mn1;
　　
　　
　　Namespace  hello\world;
　　         Function demo(){
　　         Echo “1111”;}
　　Demo();
　　\hello\world\demo();
　　Namespace\demo();
　　Echo__NAMESPACE__;
　　
　　命名空间别名：
　　Namespacenet\lamp\www;
　　Use  net\lamp\www as lamp;
Function demo(){
　　         Echo “111”;
　　}
　　Lamp\demo();