ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 应用开发 > IT综合 > PHP面向对象编程

PHP面向对象编程

原创 IT综合 作者：bestpaydata 时间：2015-11-16 13:59:25 0 删除 编辑
编者：Matlon
        面向对象是一种计算机编程架构，比面向过程编辑具有更强的灵活性和扩展性。苹果CEO乔布斯认为面向对象编程就是在与一个抽象的有生命的人在对话，高屋建瓴，细细品味确实如此。
一、 面向对象的基本概念
       面向对象编程(OOP)，是面向对象的一部分。面向对象包括3个部分：面向对象分析(Object OrientedAnalysis,OOA)、面向对象设计(Object Oriented Design,OOD)、以及面向对象编程(Object OrientedProgramming,OOP)。面向对象编程的两个重点概念是类和对象。
   1.  类
       世间万物都具有其自身的属性和方法，通过这些属性和方法可以将不同物质区分开来。例如，人具有身高，体重，以及肤色等属性，还可以进行吃饭、学习、走路等能 动活动，这些活动可以说是人具有的功能。可以把人看作程序中的一个类，那么人的身高可以比作类中的属性，走路可以比作类中的方法。也就是说，类是属性和方 法的集合，是面向对象编程方式的核心和基础，通过类可以将零散的用于实现某项功能的代码进行有效管理。
   2.  对象
       类只是具备某项功能的抽象模型，实际应用中还需要对类进行实例化，这样就引入了对象的概念。对象是类进行实例化后的产物，是一个实体。仍然以人为例，“黄种 人是人”这句话没有错误，但过来说,”人是黄种人”这句话一定是错误的。因为除了有黄种人，还有黑人、白人等。那么“黄种人”就是“人”这个类的一个实例 对象。可以就样理解对象和类的关系：对象实际上就是“有血有肉的、能摸得到看得到的“一个类。
   3. 面向对象编程的三大特点
     1) 封闭性
          封闭性，也可以称为信息隐藏。就是将一个类的使用和实现分开，只保留有限的接口(方法)与外部联系。对于用到该类的开发人员，只要知道这个类如何使用即可， 而不用去关心这个类是如何实现的。这样做可以让开发人员更好地把精力集中起来专注别的事情，同时也避免了程序之间的相互依赖而带来的不便。
     2) 继承性
          继承性就是派生类(子类)自动继承一个或多个基类(父类)中的属性与方法，并可以重写或添加新的属性和方法。继承这个特性简化了对象和类的创建，增加了代码的可重性。继承分单继承和多继承，PHP所支持的是单继承，也就是说，一个子类有且只有一个父类。
     3) 多态性
        多态性是指同一个类的不同对象，使用同一个方法可以获得不同的结果，这种技术称为多态性。多态性增强了软件的灵活性和重用性。
二、面向对象的特性
1.  类的定义
     和很多面向对象的语言一样，PHP也是通过class关键字加类名来定义类的。类的格式如下:

点击(此处)折叠或打开

  1. <?php
  2.  class People{
  3. }
  4. ?>
     如上述People就是一个最简单的类了,上述两个大括号中间的部分是类的全部内容,People类仅有一个类的骨架，什么功能都没有实现，但这并不影响它的存在。
    注意：类名的首字母必须大写
2.  成员方法
       类中的函数被称为成员方法。函数和成员方法唯一的区别就是，函数实现的是某个独立的功能，而成员方法是实现类中的一个行为，是类的一部分。
下面就来扩充上面的People类，为它添加一个成员方法，代码如下：

点击(此处)折叠或打开

  1. <?php
  2.  class People{
  3.   function get_name($name)
  4.   {
  5.    echo "人的名字是：".$name;
  6.   }
  7.  }
  8. ?>
      该方法的作用是输出对象的名称，对象名称是通过方法的参数传进来的。
3. 类的实例化
        类的方法已经添加进去了，接下来就是使用方法，但使用方法不像使用函数那么简单。首先要对类进行实例化，实例化是通过关键字new来声明一个对象。然后使用如下格式来调用要使用的方法：
      “对象名->成员方法”
     类是一个抽象的描述，是功能相似的一组对象的集合。如果想用到类中的方法和变量，首先就要把它具体落实到一个实体，也就是对象上。

点击(此处)折叠或打开

  1. <?php
  2. class  People{
  3.     function get_name($name){
  4.         echo "人的名字是：".$name;
  5.     }
  6. $people = new People();   //实例化对象
  7. $people->get_name("Bob"); //调用get_name方法
  8. }
  9. ?>
4.  成员变量
       类中的变量，也称为成员变量(也有称为属性或字段的)。成员变量用来保存信息数据，或与成员方法进行交互来实现某功能。定义成员变量的格式为：
              关键字 成员变量名
       关键字可以使用public、private、protected、static和final中的任意一个。
       访问成员变量和访问成员方法是一样的。只要把成员方法换成成员变量即可，格式为：
             对象名->成员变量。

点击(此处)折叠或打开

  1. <?php
  2. class People{
  3.     public $name; //定义name属性
  4.     function set_name($name){ //声明成员方法
  5.         $this->name = $name;
  6.     }
  7.     function get_name(){ //声明成员方法
  8.         return $this->name;
  9.     }
  10. $people = new People(); //实例化对象
  11. $people->set_name("Bob"); //调用get_name方法
  12. echo $people->get_name();
  13. }
      注：$this->作用是用来调用本类中的成员变量或成员方法，只能在本类中使用，相当于self
5.  类常量
        既然有变量，当然也会有常量了。常量就是不会改变的量，是一个恒值。众所周知的一个常量就是圆周率Pi。定义常量使用关键字const如：
        ConstPI=3.14159;

点击(此处)折叠或打开

  1. <?php
  2. class People{
  3.     const count_people = 0;  //声明一个常量
  4.     public $name; //定义name属性
  5.     function set_name($name){ //声明成员方法
  6.         self::count_pepple++; //在成员方法中调用常量
  7.         $this->name = $name;
  8.     }
  9.     function get_name(){ //声明成员方法
  10.         return $this->name;
  11.     }
  12. $people = new People(); //实例化对象
  13. $people->set_name("Bob"); //调用get_name方法
  14. echo $people->get_name();
  15. People::count_people++ ；//
  16. }
        可以看出常量和变量的输出是不一样。常量不需要实例化对象，直接由类名+常量名调用即可。常量输出的格式为：
类名::常量名; 在成员方法中，可以使用self调用。
        类名和常量名之间的两个冒号称为作用域操作符，使用这个操作符可以在不创建对象的情况下调用类的常量、变量和方法。
6.  构造方法和析构方法
     1)  构造方法
      当一个类实例化一个对象时，可能会随着对象初始化一些成员变量。
             __construect([mixed args,[……]])
      注：函数中的__是两条下划线，不是一条。

点击(此处)折叠或打开

  1. <?php
  2.         class People{
  3.             public $name; //定义name属性
  4.             function __construct($name,$age,$sex)
  5.             {
  6.                 $this->name = $name ;
  7.                 $this->age = $age ;
  8.                 $this->sex = $age ;
  9.             }
  10.             function set_name($name){ //声明成员方法
  11.                 self::count_pepple++; //在成员方法中调用常量
  12.                 $this->name = $name;
  13.             }
  14.             function get_name(){ //声明成员方法
  15.                 return $this->name;
  16.             }
  17.         $people1 = new People('Bob','15','man'); //实例化对象
  18.         $people2 = new People('Alice','16','woman'); //实例化对象
  19.         echo $people1->get_name();
  20.         echo "
    "    ;
  21.         echo $people2->get_name();
  22.         }
       构造方法是初始化对象时使用的。如果类中没有构造方法，那么PHP会自动生成一个。自动生成的构造方法没有任何参数，没有任何操作。
       注:php中类的构造方法只能有一个，不同于java中可以声明多个构造方法。
     2)  析构方法
         析构方法的作用和构造方法正好相反，是对象被销毁时被调用的，作用是释放内存。析构方法的格式为：
            Void   __destruct(){}

点击(此处)折叠或打开

  1. <?php
  2.         class People{
  3.             public $name; //定义name属性
  4.             function __construct($name,$age,$sex)
  5.             {
  6.                 $this->name = $name ;
  7.                 $this->age = $age ;
  8.                 $this->sex = $age ;
  9.             }
  10.             function set_name($name){ //声明成员方法
  11.                 self::count_pepple++; //在成员方法中调用常量
  12.                 $this->name = $name;
  13.             }
  14.             function get_name(){ //声明成员方法
  15.                 return $this->name;
  16.             }
  17.             function __destruct() //声明析构函数
  18.             {
  19.              echo  "对象被销毁时调用" ； 
  20.              }
  21.         $people1 = new People('Bob','15','man'); //实例化对象
  22.         $people2 = new People('Alice','16','woman'); //实例化对象
  23.         echo $people1->get_name();
  24.         echo "
    "    ;
  25.         echo $people2->get_name();
  26.         }
       PHP使用的是一种“垃圾回收”机制，自动清除不再使用的对象，释放内存。就是说即使不使用unset函数，析构方法也会自动被调用，这里只是明确一下析构函数在何时被调用。一般情况下是不需要手动创建析构方法的。析构函数没有参数。
7.  继承和多态的实现
        People 的某些属性是共同的，比如，他们都有姓名，会走、会跳、能说话等，但也用一些自我属性，比如，性别、身高、体重等，这时可以使用面向对象中的继承来解决这个难题。
       在PHP中实现继承是通过关键字extends来声明的，继承格式如下：

点击(此处)折叠或打开

  1. <?php
  2. class Man extends People{
  3. }
  4. ?>
说明：Man为子类的名称，People为父类名称。

点击(此处)折叠或打开

  1. <?php
  2.                 class People{
  3.                     public $name; //定义name属性
  4.                     function __construct($name,$age,$sex)
  5.                     {
  6.                         $this->name = $name ;
  7.                         $this->age = $age ;
  8.                         $this->sex = $age ;
  9.                     }
  10.                     function set_name($name){ //声明成员方法
  11.                         self::count_pepple++; //在成员方法中调用常量
  12.                         $this->name = $name;
  13.                     }
  14.                     function get_name(){ //声明成员方法
  15.                         return $this->name;
  16.                     }
  17.                     function show_atr() //声明
  18.                     {
  19.                      echo "显示属性" ；
  20.                      }
  21.                 class Man extends People{           //子类man
  22.                     function __construct($height,$weight){
  23.                         parent::__construct();
  24.                         $this->height = $height;
  25.                         $this->weight = $weight ;
  26.                     }

  28.                     function show_atr()           //子类重构方法
  29.                     {
  30.                         echo "姓名：".$this->name.<br>."年龄" .$this->age."<br>"."性别".$this->sex."<br>"."身高".$this->height."<br>"."体重".$this-weight ;
  31.                     }
  32.                 }
  33.                
  34.                 class Women extends People{                //子类women方法
  35.                         function __construct(){
  36.                             parent::__construct();        
  37.                         }
  38.                         function show_atr()               //子类重构方法
  39.                         {
  40.                             echo "姓名：".$this->name."<br>"."年龄" .$this->age."<br>"."性别".$this->sex;
  41.                         }
  42.                     }
  43.                 }
  44.          $p1 = new People('Bob','19','man');
  45.          $p1->show_atr();
  46.          $p2 = new Man('kobran','20','man','190','140');
  47.          $p2->show_atr();
  48.          $p3 = new Woman('Julice','22','woman','170','60');
  49.          $p3->show_atr();

       子类继承了父类的所有成员变量和方法，包括构造函数。这就是继承的实现。
当子类被创建时，PHP会先在子类中查找构造方法。如果子类有自己的构造方法，PHP会先调用子类中的方法，当子类中没有时，PHP则会去调用父类中的构造方法.

8.   数据隐藏
        面向对象编辑的特点之一是封装性，即数据隐藏。可在前面的学习中并没有突出这一点。对象中的所有变量和方法可以随意调用，甚至不用实例化也可以使用类中的方法、变量。这就是面向对象吗？
这当然不算是真正的面向对象。关键字public、private、protected、static和final。这就是用来限定类成员(包括变量和方法)的访问权限。
成员变量和成员方法在关键字的使用上都是一样的。这里只以成员变量为例说明几种关键字的不同用法。对于成员方法同样适用。
       1、public公共成员
            顾名思义，就是可以公开的、没有必要隐藏的数据信息。可以在程序的任何地点(类内、类外)被其他的类和对象调用。子类可以继承和使用父类中所有的公共成员。所有的变量都被声明为public，而所有的方法在默认的状态下也是public。所以对变量
和方法的调用显示得十分混乱。为了解决这个问题，就需要使用第二个关键字：private。
       2、 private私有成员
           被private关键字修饰的变量和方法，只能在所属类的内部被调用和修改，不可以在类外被访问。在子类中也不可以。
<!--?php
对于成员方法，如果没有写关键字，那么默认就是public。从本节开始，以后所有的方法及变量都会带个关键字，这是一种良好的书写习惯。
        3、 protected保护成员
       private 关键字可以将数据完全隐藏起来，只允许类和其子类可以使用
      PHP中没有对修饰变量的关键字做强制性的规定和要求，但从面向对象的特征和设计方面考虑，一般使用private或protected关键字来修饰变量，以防止变量在类外被直接修改和调用。
9.  静态变量（方法）
      不是所有的变量(方法)都要通过创建对象来调用的。可以通过给变量(方法)加上static关键字来直接调用。调用静态成员的格式为：
                       关键字::静态成员
      关键字可以是：
                 Self:在类内部调用静态成员时所使用。
                静态成员所在的类名，在类外调用类内部的静态成员时所用。

点击(此处)折叠或打开

  1. <?php
  2. class People{
  3.     static people_count = 0; //声明静态变量
  4. }
  5. People::people_count++;
  6. ?
      注：在静态方法中，只能调用静态变量，而不能调用普通变量，而普通方法则可以调用静态变量。使用静态成员，除了可以不需要实例化对象，另一个作用就是在对象被销毁后，仍然保存被修改的静态数据。以便下次继续使用，静态成员不用实例化对象，当类第一次被加载时就已经分配了内存空间，所以直接调用静态成员的速度要快一些。但如果静态成员声明得过多，空间一直被占用，反而会影响系统的功能。这个尺度只能通过实践、积累，才能真正地把握。
三、PHP对象的高级应用
1.  final关键字
final，中文含义是最终的、最后的。被final修饰过的类和方法就是“最终版本”;
如果有一个类的格式为：

点击(此处)折叠或打开

  1. Final class class_name{
  2. }
说明该类不可以再被继承，也不能再有子类。
如果有一个方法的格式为：
Final function method_name();
说明该方法在子类中不可以进行重写，也不可以被覆盖。
<!--?php
例：

点击(此处)折叠或打开

  1. final class myobject{
  2.   function __construct(){
  3.       echo "initialize object";
  4.    }
  5. }
  6. class mybook extends myobject{
  7.   static function exam(){
  8.       echo "you can't see me.";
  9.    }
  10. }
  11.                                  
  12. mybook::exam()
2. 抽象类
抽象类是一种不能被实例化的类，只能作为其他类的父类来使用。抽象类使用abstract关键字来声明，格式为：
     Abstract class abstractname{
}
抽象类和普通类相似，都包含成员变量、成员方法。两者的区别在于，抽象类至少要包含一个抽象方法。抽象方法没有方法体，其功能的实现只能在子类中完成。抽象方法也是使用abstract关键字修饰的。它的格式为：
Abstractfunction abstractname();
注意：在抽象方法后面要有分号“;”
抽 象类和抽象方法主要应用于复杂的层次关系中，这种层次关系要求每一个子类都包含并重写某些特定的方法。举一个例子：中国的美食是多种多样的，有吉菜、鲁 菜、川菜、粤菜等。每种菜系使用的都是煎、炒、炸等手法，只是在具体的步骤上，各有各的不同。如果把中国美食当作一个大类cate，下面的各大菜系就是 cate的子类，而煎炒烹炸则是每个类中都有的方法。每个方法在子类中的实现都是不同的，在父类中无法规定。为了统一规范，不同子类的方法要有一个相同的 方法名：decoct(煎)、stir_fry(炒)、cook(烹)、fry(炸)。

点击(此处)折叠或打开

  1. <?php
  2.     /* 抽象类myobject */
  3.         abstract class myobject{ //抽象方法servie
  4.             abstract functionservice($getname,$price,$num);
  5.         }
  6.         //声明抽象类的子类mybook
  7.         class mybook extends myobject{ //实现抽象方法service
  8.             function service($getname,$price,$num){
  9.                   echo "您购买的商品是".$getname.",该商品的价格是：".$price."元";
  10.                       echo "您购买的数量为：".$num."本。";
  11.                       echo "如发现缺页、损坏、请在3日内更换。";
  12.                }
  13.         }
  14.         //声明另一个抽象类的子类mycomputer
  15.         class mycomputer extends myobject{ //实现抽象方法service
  16.             function service($getname,$price,$num){
  17.                   echo "您购买的商品是：".$getname.",该商品的价格是：".$price."元。";
  18.                       echo "您购买的数量为：".$num."台。";
  19.                       echo "如发生非人为质量问题，请在3个月内更换。";
  20.                }
  21.         }
  22.         $book=new mybook(); //实例化对象$book
  23.         $computer=new mycomputer(); //实例化对象$computer
  24.         $book->service("《PHP从入门到精通》",85,3); //调用$book对象的service方法
  25.         echo "
    "    ;
  26.         $computer->service("XX笔记本",8500,1); //调用computer对象的service方法
  27. ?>
3.   接口的使用
       继承特性简化了对象、类的创建，增加了代码的可重性。但PHP只支持单继承。如果想实现多重继承，就要使用接口。PHP可以实现多个接口。
接口类通过interface关键字来声明，并且类中只能包含未实现的方法和一些成员变量，格式如下：

点击(此处)折叠或打开

  1. Interface interfacename{
  2.   Function interfacename1();
  3.   Function interfacename2();
  4.   ………………
  5. }
注意：接口类的所有成员方法必须都是公有的。
      子类是通过implements关键字来实现接口的，如果要实现多个接口，那么每个接口之间使用逗号“，”连接。而且所有未实现的方法需要在子类中全部实现，否则PHP将会出现错误。格式如下：

点击(此处)折叠或打开

  1. Class subclass implements interfacename1,interfacename2{
  2.     Function interfacename1(){
  3.        //功能实现
  4.      }
  5.     Function interfacename2(){
  6.        //功能实现
  7.      }
  8.      …………
  9. }
例：本例首先声明了两个接口mpopedom和mpurview，接着声明了两个类member和manager，其中member类继承了mpopedom接 口;manager继承了mpopedom和mpurview接口。分别实现各自的成员方法后，实例化两个对象$member和$manager。最后调 用实现的方法。

点击(此处)折叠或打开

  1. <?php
  2.      interface mpopedom{
  3.            function popedom();
  4.         }
  5.         interface mpurview{
  6.            function purview();
  7.         }
  8.         class member implements mpurview{
  9.             function purview(){
  10.                     echo "会员拥有的权限";
  11.                 }
  12.         }
  13.         class manager implements mpurview,mpopedom{
  14.             function purview(){
  15.                 echo "管理员拥有会员的全部权限。";
  16.                 }
  17.                 function popedom(){
  18.                     echo "管理员还有会员没有的权限。";
  19.                 }
  20.         }
  21.         $member=new member();
  22.         $manager=new manager();
  23.         $member->purview();
  24.         echo "
    "    ;
  25.         $manager->purview();
  26.         $manager->popedom();
  27. ?>
通过上面的实例可以发现，抽象类和接口实现的功能十分相似。抽象类的优点是可以在抽象类中实现公共的方法，而接口则可以实现多继承。至于何时使用抽象类和接口就要看具体实现了。
4.  克隆对象
   （1）克隆对象
    在PHP4中，对象被当作普通的数据类型来使用。如果想引开对象，需要使用&来声明，否则会按照PHP4的默认方式来按值传递对象。
例：本实例首先实例化一个myobject类的对象$book1，$book1的默认值是book，然后将对象$book1使用普通数据类型的赋值方式给对象$book2赋值。改变$book2的值为computer，再输出对象$book1的值。

点击(此处)折叠或打开

  1. <?php
  2.      classmyobject{
  3.              private $object_type="book";
  4.                public function settype($type){
  5.                    $this->object_type=$type;
  6.                 }
  7.                public function gettype(){
  8.                    return $this->object_type;
  9.                 }
  10.         }
  11.         $book1=new myobject();
  12.         $book2=$book1;
  13.         $book2->settype("computer");
  14.         echo "对象\$book1的值为：".$book1->gettype();
  15. ?>
上面的实例，在PHP5中的返回值为：对象$book1的值为：computer。
    因为$book2只是$book1的一个引用，而在PHP4中的返回值是：对象$book1的值为：book，因为对象$book2是$book1的一个备份。
在PHP5中如果需要将对象复制，也就是克隆一个对象。需要使用关键字clone来实现。克隆一个对象的格式为：
     $object1=new classname();
     $object2=clone $object1;
     （2）__clone()方法
有时除了单纯地克隆对象外，还需要克隆出来的对象可以拥有自己的属性和行为。这时就可以使用_clone()方法来实现。__clone()方法的作用是：在克隆对象的过程中，调用_clone()方法，可以使用克隆出来的对象保持自己的一些行为及属性。

点击(此处)折叠或打开

  1. <?php
  2.      class myobject{
  3.              private $object_type="book";
  4.                  public function settype($type){
  5.                       $this->object_type=$type;
  6.                  }
  7.                  public function gettype(){
  8.                       return $this->object_type;
  9.                  }
  10.                  public function __clone(){
  11.                      $this->object_type="computer";
  12.                                             }
  13.         }
  14.         $book1=new myobject();
  15.         $book2=clone $book1;
  16.         echo "对象$book1的变量值为：".$book1->gettype();
  17.         echo"
    "    ;
  18.         echo "对象$book2的变量值为：".$book2->gettype();
  19. ?>
5.  对象比较
    通过克隆对象，相信读者已经理解表达式$boject2=$object1和$object2=clone $object1所表示的不同含义。但在实际开发中，应如何判断两个对象之间的关系是克隆还是引用？
    这是可以使用比较运算符==和===。两个等号是比较两个对象的内容，3个等号===是比较对象的引用地址。
例：

点击(此处)折叠或打开

  1. <?php
  2.      class People{
  3.             private $name;
  4.             function __construct($name){
  5.                 $this->name=$name;
  6.             }
  7.      }
  8.      $person = new People('Bob');
  9.      $clone_person = clone $person;
  10.      $refer_person = $person;
  11.      if($clone_person == $person){
  12.         echo "两个对象的内容相等。
    "    ;
  13.      }
  14.      if($refer_person === $person){
  15.         echo "两个对象的引用地址相等。
    "    ;
  16.      }
  17. ?>
6.  对象类型检测
       Instanceof操作符可以检测当前对象是属于哪个类的。一般格式如为：
                Objectname instanceof classname
例：本实例首先创建两个类，一个基类(myobject)与一个子类(mybook)。实例化一个子类对象，判断对象是否属于该子类，再判断对象是否属于基类。
例：

点击(此处)折叠或打开

  1. <?php
  2.      class People{}
  3.      class child extends People{
  4.          private $type;
  5.      }
  6.      $cperson=new child();
  7.      if($cperson instanceof People){
  8.          echo "对象$cperson属于people类
    "    ;
  9.      }
  10.      if($cperson instanceof child){
  11.          echo "对象$cperson属于child类
    "    ;
  12.      }
  13. ?>
7.  魔术方法（_）
    PHP中有很多以两个下划线开头的方法，如前面已经介绍过的__construct()、__destruct()和__clone()，这些方法被称为魔术方法。下在我们将学习其他一些魔术方法。
注意：PHP中保留了所有以”__”开头的方法，所以只能使用在PHP文档中有的这些方法，不要自己创建。
（1）、__set()和__get()方法
这两个魔术方法的作用为：
     当程序试图写入一个不存在或不可见的成员变量时，PHP就会执行__set()方法。__set()方法包含两个参数，分别表示变量名称和变量值。两个参数不可省略。
     当程序调用一个未定义或不可见的成员变量时，可以通过__get()方法来读取变量值。__get()方法有一个参数，表示要调用的变量名。
注意：如果希望PHP调用这些魔术方法，那么首先必须在类中进行定义;否则PHP不会执行未创建的魔术方法。
例：

点击(此处)折叠或打开

  1. <?php
  2.      class myobject{
  3.            private $type="";
  4.                private function __get($name){
  5.                   if(isset($this->$name)){
  6.                         echo "变量".$name."的值为：".$this->$name."
    "    ;
  7.                      }
  8.                      else{
  9.                         echo "变量".$name."未定义，初始化为0
    "    ;
  10.                             $this->$name=0;
  11.                      }
  12.                }
  13.                private function __set($name,$value){
  14.                    if(isset($this->$name)){
  15.                          $this->$name=$value;
  16.                              echo "变量".$name."赋值为：".$value."
    "    ;
  17.                       }else{
  18.                           $this->$name=$value;
  19.                              echo "变量".$name."被初始化为：".$value."
    "    ;
  20.                       }
  21.                }
  22.         }
  23.         $mycomputer=new myobject();
  24.         $mycomputer->type="DIY";
  25.         $mycomputer->type;
  26.         $mycomputer->name;
  27. ?>
（2）__call()方法
       __call()方法的作用是：当程序试图调用不存在或不可见的成员方法时，PHP会先调用__call()方法来存储方法名及其参数。__call()方法包含两个参数，即方法名和方法参数。其中，方法参数是以数组形式存在的。
例：

点击(此处)折叠或打开

  1. <?php
  2.      class myobject{
  3.             public function mydream(){
  4.                      echo "调用的方法存在，直接执行此方法：
    "    ;
  5.                 }
  6.                 public function __call($method,$parameter){
  7.                      echo "如果方法不存在，则执行__call()方法。
    "    ;
  8.                        echo "方法名为：".$method."
    "    ;
  9.                        echo "参数有：";
  10.                        var_dump($parameter);
  11.                 }
  12.         }
  13.         $exam=new myobject();
  14.         $exam->mydream();
  15.         $exam->mdreadm('how','what','why');
  16. ?>
（3）sleep()和__wakeup()方法
       使用serialize()函数可以实现序列化对象。就是将对象中的变量全部保存下来，对象中的类则只保存类名。在使用serialize()函数时，如果 实例化的对象包含__sleep()方法，则会执行__sleep()方法。该方法可以清除对象并返回一个该对象中所有变量的数组。使用 __sleep()方法的目的是关闭对象可能具有的数据库连接等类似的善后工作。
      Unserialize()函数可以重新还原一个被serialize()函数序列化的对象，__wakeup()方法则是恢复在序列化中可能丢失的数据库连接及相关工作。
例：

点击(此处)折叠或打开

  1. <?php
  2.      class myobject{
  3.            private $type="DIY";
  4.                public function gettype(){
  5.                    return $this->type;
  6.                }
  7.                public function __sleep(){
  8.                    echo "使用serialize()函数将对象保存起来，可以存放到文本文件、数据库等地方。
    "    ;
  9.                       return $this;
  10.                }
  11.                public function __wakeup(){
  12.                    echo "当需要该数据时，使用unserialize()函数对已序列化的字符串进行操作，将其转换回来对象。
    "    ;
  13.                }
  14.         }
  15.        $mybook=new myobject();
  16.        $i=serialize($mybook);
  17.        echo "序列化后的字符串：".$i."
    "    ;
  18.        $rebook=unserialize($i);
  19.        echo "还原后的成员变量：".$rebook->gettype();
  20. ?>
（4）tostring()方法
魔术方法这个作用是：当使用echo 或print输出对象时，将对象转化为字符串。
例：

点击(此处)折叠或打开

  1. <?php
  2.      class myobject{
  3.             private $type="DIY";
  4.                 public function __tostring(){
  5.                     return $this->type;
  6.                 }
  7.         }
  8.         $mycomputer=new myobject();
  9.         echo "对象\$mycomputer的值为：";
  10.         echo $mycomputer;
  11. ?>
（5）autoload()方法
将一个独立、完整的类保存到一个PHP页中，并且文件名和类名保持一致，这是每个开发人员者需要养成的良好习惯。这样，在下次重复使用某个类时即能很轻易 地找到它。但还有一个问题是让开发人员头疼不已的，如果要在一个页面中引进很多的类，需要使用include_once()函数或 require_once()函数一个一个地引入。
PHP5解决了这个问题，__autoload()方法可以自动实例化需要使用的类。当程序要用到一个类，但该类还没有被实例化时，PHP5将使用 __autoload()方法，在指定的路径下自动查找和该类名称相同的文件。如果找到，程序则继续执行，否则，报告错误。
例：
Myobject.class.php页面代码如下：

点击(此处)折叠或打开

  1. <?php
  2.      class myobject{
  3.          private $cont;
  4.          public function __construct($cont){
  5.              $this->cont=$cont;
  6.          }
  7.          public function __tostring(){
  8.              return $this->cont;
  9.      }
  10. ?>
Index.php页面代码如下：

点击(此处)折叠或打开

  1. <?php
  2.      function__autoload($class_name){
  3.          $class_path=$class_name.'.class.php';
  4.          if(file_exists($class_path)){
  5.              include_once($class_path);
  6.          }else{
  7.              echo "class path is wrong";
  8.         }
  9.         }
  10.         $mybook=new myobject("You are wrong!");
  11.         echo $mybook;
  12.                               
  13. ?>
总结：以上纯属自我学习总结，如果有所遗漏或错误，请指出，勿喷！！！
-->

来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/30109892/viewspace-1839579/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： 将列统计信息中的high_value low_value 转换成可以读懂的数字，字符和日期
下一篇： logmnr 工具的使用
请登录后发表评论 登录
全部评论
bestpaydata

注册时间：2015-01-19

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593