论坛风格切换切换到宽版
  • 5617阅读
  • 2回复

[分享]PHP 面向对象(OOP) 笔记 [复制链接]

上一主题 下一主题
离线voiphaozi
 

只看楼主 倒序阅读 使用道具 楼主  发表于: 2011-04-06
关键词: PHP
1:PHP中类初步接触
    
  1. class Mypc                        //类名  
  2. {  
  3.     public $name;            //声明属性,对象名称  
  4.     function game()         //类的方法、动作  
  5.     {  
  6.         return "玩游戏";  
  7.     }  
  8. }  
  9. [color=#000000]$pc1=new Mypc();           // 创建PC1对象实例[/color]
  10. $pc1->name="IBM电脑";      // 给PC1对象赋值,声明对象名称  
  11. echo $pc1->name;        //输出对象名称  
  12. echo $pc1->game();       //输出对象执行的动作方法
2:this 关键子的应该(访问当前对象中的对象属性和对象方法的系统变量)
  
  1. class Mypc  
  2. {  
  3.     public $name;  
  4.     function game()  
  5.     {  
  6.         return $this->name."玩游戏";   //这里,注意看清楚  
  7.     }  
  8. }  
  9.   
  10. $pc1=new Mypc();  
  11. $pc1->name="IBM电脑";  
  12. echo $pc1->game();  
  13. 输出结构为:IBM电脑玩游戏
3:__construct 初始化函数  在PHP 4中初始化可以这么写  function Mypc(){}..和类名一定要相同
  
  1. class Mypc  
  2. {  
  3.     public $name;  
  4.     function __construct($name)     //初始化函数,不需要在new之后写很多的echo==  
  5.     {  
  6.         $this->name=$name;    // 初始化对象  
  7.         $this->game();        //初始方法,动作  
  8.     }  
  9.     function game()  
  10.     {  
  11.        echo $this->name."玩游戏";  
  12.     }  
  13. }  
  14.   $pc=new Mypc("IBM电脑");           //实例化对象  
  15. 输出结果:IBM电脑玩游戏
  4:private 关键子的应用,修饰类中的属性和方法。使其属性或方法只能在本类中访问,
  
  1. class Mypc  
  2. {  
  3.     private $name;                     // private 设置私有对象属性  
  4.     function __construct($name)        //初始化函数  
  5.     {  
  6.         $this->name=$name;           // 在本类中可以用this关键子访问  
  7.     }  
  8.     function game()  
  9.     {  
  10.         echo $this->name."玩游戏";  //方法中同样  
  11.     }  
  12. }  
  13. $pc=new Mypc("IBM电脑");  
  14. // echo $pc->name="IBM电脑";   //那么在类的外面就访问不了  
  15. echo $pc->game();  
  16. //输出结果为:IBM电脑游戏,//若类外访问会报错
  5:__get() 函数应用   取得当前类中的封装的过属性或方法并转换成共有属性  
    
  1. class Mypc  
  2. {  
  3.     private $name;  
  4.     function __construct($name)  //初始化函数  
  5.     {  
  6.         $this->name=$name;  
  7.     }  
  8.     function __get($name)      //__get函数  
  9.     {  
  10.         return $this->name;  
  11.     }  
  12. }  
  13.   $pc=new Mypc("IBM电脑");  
  14.   echo $pc->name;  
  15.   //即使name是私有属性,系统提高了__get()函数来对其访问,输出结果还是 IBM电脑
  6:__set() 函数的应用 取得当前类中的封装的过属性或方法重新赋值执行操作
  
  1. class Mypc  
  2. {  
  3.     private $name;  
  4. function __construct($name)  //初始化函数  
  5. {  
  6.     $this->name=$name;  
  7. }  
  8. function __get($name)      
  9. {  
  10.     return $this->name;  
  11. }  
  12. function __set($n,$v)   //__set 函数  
  13. {  
  14.     $this->$n=$v;  
  15. }  
  16. }  
  17. $pc=new Mypc("IBM电脑");  
  18. $pc->name="aa";         //  这里就执行了__set函数,并重新赋值,输出结构是 aa  
  19. echo $pc->name;
7: extends 继续     实现对基类(父类)中属性和方法的复用
  
  1. class Mypc            //声明类Mypc  
  2. {  
  3.     public $name;  
  4.     function game()  
  5.     {  
  6.         return "aaa";  
  7.     }  
  8. }  
  9. class Mypc1 extends Mypc   //声明类Mypc1继承Mypc  
  10. {  
  11.     // 那么既然Mypc1继承了Mypc,就可以访问其属性,和方法  
  12. }  
  13.   
  14. $pc=new Mypc1;  
  15. echo $pc->name="haha";  
  16. echo $pc->game();  
  17. // 输出结果为:aaahaha
8:重载。。我的理解是 当子类继承父类时候,实例化子类的时候,需要用到父类重的某写方法,那么我们不需要在去实例化父类,就可以得到父类中的木某写方法
  
  1. class Mypc  
  2.    {  
  3.         function game()  
  4.         {  
  5.             return "aaa";  
  6.         }  
  7.    }  
  8.    class Mypc1 extends Mypc  
  9.    {  
  10.         function game()  
  11.         {  
  12.             return Mypc::game()."bbb";   //这里就重载了父类的方法  
  13.         }  
  14.    }  
  15.    $pc=new Mypc1;  
  16.    echo $pc->game();  
  17. //输出结果是:aaabbb
   9:abstract 抽象  声明抽象类的关键子
    
  1. abstract class Mypc           //声明抽象类  
  2.   {  
  3.     abstract function game();    //方法也必须是抽象的  
  4.   }  
  5.   class Mypc1 extends Mypc  
  6.   {  
  7.     function game()           //重载抽象类中的方法,必须一一重载  
  8.     {  
  9.         return "aaa";  
  10.     }  
  11.   }  
  12.   $pc=new Mypc1;  
  13.   echo $pc->game();        // 输出结果:aaa
10:final 修饰类 则类不能被继承
  
  1. final class A          //声明不能被继承的类A  
  2.    {  
  3.         public $name;  
  4.    }  
  5.    class B extends A    // 那么这里继承A 是不允许的  
  6.    {  
  7.     
  8.    }  
  9.    $c=new A;         // 但实例化B的时候则会报错
11: static  用来定义类的静态属性或方法,可以在类未被实例化时使用。
        self     用来用类访问当前类中的静态属性或方法的关键字,类似与$this关键字      
    
  1. class A  
  2.   {  
  3.     static $name="aaa";       //声明静态属性  
  4.     static function game()  
  5.     {  
  6.         return self::$name."bbb";   // 这里用self直接访问本类中静态属性  
  7.     }  
  8.   }  
  9.   echo A::$name;        //  声明为静态的属性,类外部可以不实例化,直接用“类名::属性”访问  
  10.   echo A::game();       // 方法也是一样  
  11. // 输出结果为:aaaaaabbb
12:const 定义常量
    
  1. class A  
  2. {  
  3.     const NAME="aaa";         // 定义常量,一般采用大写  
  4. static function game()    // 声明静态方法,以便方法常量  
  5. {  
  6.     return self::NAME;   // self 访问常量  
  7. }  
  8. }  
  9. echo A::game();        //直接方法类AZ中的静态方法  
  10. / 输出结果:aaa
13: interface 接口   implements  引用接口
    
  1. interface demo  //定义接口。接口中的的属性必须为常量  
  2.   {  
  3.       function fun();  //定义抽象方法。。。接口中抽象方法不需要加abstract    
  4.   }  
  5.   class Mypc implements demo   //应用接口  
  6.   {  
  7.     function fun()  //必须重载接口中所有的抽象方法  
  8.     {  
  9.         echo "aa";  
  10.     }  
  11.   }  
  12.   $pc=new Mypc;  
  13.   $pc->fun();   //输出:aa
14: 接口的综合应用
  
  1. interface demo1       //定义接口1  
  2.   {  
  3.     const NAME="aaa";  
  4.     function fun1();    
  5.   }  
  6.   interface demo2       //接口2  
  7.   {  
  8.     function fun2();  
  9.   }  
  10.   interface demo3       //接口3  
  11.   {  
  12.     function fun3();  
  13.   }  
  14.   class Mypc implements demo1,demo2   //类Mypc引用了接口1和2  
  15.   {  
  16.     function fun1()  
  17.     {  
  18.         echo "111";  
  19.     }  
  20.     function fun2()  
  21.     {  
  22.         echo "222";  
  23.     }  
  24.   }  
  25.   class Mypc2 extends Mypc implements demo3  //类Mypc2 先继承 父类Mypc,然后在引用接口3 ,那么该类就拥有了上面所有属性和方法  
  26.   {  
  27.      function fun3()  
  28.      {  
  29.         echo "333";  
  30.      }  
  31.   }  
  32.   $pc=new Mypc2;  
  33.   echo Mypc2::NAME;  
  34.   $pc->fun3();         // 当被实例化的时候,我们需要用到哪个接口,直接调用就OK了,很方便的,可以想象下电源插板的那种感觉  
  35.     
  36.    // 这里的输出结果是:aaa333
  37. view plaincopy to clipboardprint?
  38. interface usb                        //定义usb接口  
  39.       {  
  40.          function type();                 //定义usb接口类型  
  41.          function alert();               // 接口动作  
  42.       }  
  43.       class zip implements usb  
  44.       {  
  45.         function type()  
  46.         {  
  47.          echo "1.0";  
  48.         }  
  49.         function alert()  
  50.         {  
  51.          echo "aaa";  
  52.         }  
  53.       }  
  54.       class mp3 implements usb  
  55.       {  
  56.          function type()  
  57.          {  
  58.          echo "2.0";  
  59.          }  
  60.          function alert()  
  61.          {  
  62.          echo "bbb";  
  63.          }  
  64.       }  
  65.       class Mypc  
  66.       {  
  67. function pcusb($what)  
  68. {  
  69. $what->type();  
  70. $what->alert();  
  71. }  
  72.       }  
  73.       $zip=new zip();  
  74.       $mp3=new mp3();  
  75.       $mypc=new Mypc();  
  76. $mypc->pcusb($zip);                   // 输出 1.0aaa
15:instanceof 用来测定一个给定的对象是否来自指定的对象类。
    
  1. class A{}    //类A  
  2.      class B{}    //类B  
  3. $ab=new A();            
  4. if($ab instanceof A)  
  5. {  
  6. echo "A";  
  7. }  
  8. elseif($ab instanceof B)  
  9. {  
  10. echo "B";  
  11. }                                                //输出A
16: __tostring() 直接打印对象句柄,从而获得该方法的基本信息或其他内容
  
  1. class My  
  2.      {  
  3.      function __tostring()  
  4.      {  
  5.      return "aaa";  
  6.      }  
  7.      }  
  8.      $p=new My();  
  9.      echo $p;                                //输出aaa
17: __call($funname,$arr_value)  对象方法的异常处理...
  
  1. class A  
  2. {  
  3. function __call($funname,$arr_value)  
  4. {  
  5.     echo "这是一个不存的方法:".$funname."<br>";  
  6.        echo "错误的参数:".$arr_value."<br>";  
  7. }  
  8. function B()  
  9. {  
  10. }  
  11. }  
  12. $p=new A;  
  13. $p->demo();               //这里 实际上 demo方法不存在,,那么程序就会调用 __call中方法。  
  14. / 输出结果是:这是一个不存的方法:demo  
  15.             错误的参数:Array
18:__autoload()   快速取得对象名称并自动载入进当前页面
   如果我们一般调用某个文件中的类或方法时。。一般都如下写
  
  1. include("mypc.php");  
  2. include("demo.php");
如果这里有N多文件要被调用。岂不要些很多的 include()..
  下面__autoload()方法很好解决

  1. function __autoload($name)  
  2.    {  
  3. include($name."php")   //  这里将会自动调用。执行include(...php)  
  4.    }



仅供参考
评价一下你浏览此帖子的感受

精彩

感动

搞笑

开心

愤怒

无聊

灌水
离线ggh147258

只看该作者 沙发  发表于: 2015-01-12
aaaaa
欢迎来到“Asterisk资源分享-互助学习社区”——-Asterisk工程师的家园
请记住我们的网址 www.Asterisk-help.com [这是默认签名,更换签名点这里<<]
离线ggh147258

只看该作者 板凳  发表于: 2015-01-12
好帖,好贴啊,强烈支持
欢迎来到“Asterisk资源分享-互助学习社区”——-Asterisk工程师的家园
请记住我们的网址 www.Asterisk-help.com [这是默认签名,更换签名点这里<<]
快速回复
限100 字节
>> 支持Asterisk-help社区, 谢绝无意义字符回复
如果您在写长篇帖子又不马上发表,建议存为草稿
 
上一个 下一个