1. 技术文章
  2. PHP 面向对象（OOP) 笔记

PHP 面向对象（OOP) 笔记

由 戏子无情 提交于 2020-03-01 12:55:35
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
  38. view plaincopy to clipboardprint?
  39. interface usb                        //定义usb接口  
  40.       {  
  41.          function type();                 //定义usb接口类型  
  42.          function alert();               // 接口动作  
  43.       }  
  44.       class zip implements usb  
  45.       {  
  46.         function type()  
  47.         {  
  48.          echo "1.0";  
  49.         }  
  50.         function alert()  
  51.         {  
  52.          echo "aaa";  
  53.         }  
  54.       }  
  55.       class mp3 implements usb  
  56.       {  
  57.          function type()  
  58.          {  
  59.          echo "2.0";  
  60.          }  
  61.          function alert()  
  62.          {  
  63.          echo "bbb";  
  64.          }  
  65.       }  
  66.       class Mypc  
  67.       {  
  68. function pcusb($what)  
  69. {  
  70. $what->type();  
  71. $what->alert();  
  72. }  
  73.       }  
  74.       $zip=new zip();  
  75.       $mp3=new mp3();  
  76.       $mypc=new Mypc();  
  77. $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.    }


仅供参考
标签
php
函数声明
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!