當前位置:首頁 > PHP教程 > php面向對象 > 列表

php面向對象中子類中重載父類詳解

發布:smiling 來源: PHP粉絲網  添加日期:2014-02-20 09:34:15 瀏覽: 評論:0 

因為在PHP中不能存在同名的函數,所以在同一個類中也就不能定義重名的方法,這里所說的重載是指在子類中可以定義和父類同名的方法從而覆蓋從父類中繼承過來的方法。

子類中重載父類的方法,實例代碼如下:

  1. <?php 
  2.       class Person{ 
  3.                                                                 
  4.            public $name;       
  5.                                                                
  6.            public function __construct($name="" ){ 
  7.                 $this->name =$name
  8.                                                                         
  9.            } 
  10.            public  function say(){ 
  11.                 echo "我叫".$this->name  ;  
  12.            } 
  13.                                                                    
  14.  } 
  15.  ?> 
  16.  <?php 
  17.       class Student extends Person{ 
  18.                                                                 
  19.            public $name;               
  20.                                                                
  21.            public function __construct($name=""){ 
  22.                 $this->name =$name
  23.                                                            
  24.            } 
  25.  //這里定義了一個和父類中同名的方法,將父類中的說話方法覆蓋并重寫 
  26.            public  function say(){ 
  27.                 echo "我叫".$this->name .",今年25歲了" ;  
  28.            } 
  29.                                                                    
  30.  } 
  31.  ?> 

重寫方法與訪問權限

子類中的覆蓋方法不能使用比父類中被覆蓋方法更嚴格的訪問權限,如果父類中的方法的訪問權限是protected,那么子類中重寫的方法的權限就要是protected或者public;    如果父類中的方法是public,那么子類要重寫的方法的權限就只能是public。也許這也就是為什么子類可以繼承父類的私有成員,但卻不能使用的原因吧。

重寫時的參數數量

子類可以擁有與父類不同的參數數量,如下面的構造方法中,多添加了一個參數$age,實例代碼如下:

  1. <?php  
  2.       class Student extends Person{  
  3.                                                  
  4.            public $name;       
  5.           public $age;           
  6.                                                  
  7.            public function __construct($name="",$age=25){   
  8.                 $this->name =$name;  
  9.                 $this->age =$age;  
  10.           }  
  11.           public  function say(){  
  12.                 echo "我叫".$this->name .",今年".$this->age."歲了" ;    
  13.            }    
  14.                                                     
  15.  }   
  16.  ?> 

構造函數重寫

上面提到的“重寫時的參數數量”就已經實現了子類對父類的構造函數進行了重寫,但這不是一種好的寫法,如果仔細觀察,你會發現,上面子類Student對父類Person構造函數的重寫,其實就是在父類的構造函數的基礎上多添加了一個參數,但是又把父類原有的參數照寫一遍,因為父類Person的構造函數只有一個參數,所以我們照寫一遍不覺得有什么麻煩,但是如果參數不止一個,而是幾個或者更多,那么你就會發現它的繁瑣之處,那么有沒有辦法可以簡化這個問題呢?答案是肯定的,可通過使用"parent::方法名" 在子類的重載方法中調用父類中被它覆蓋的方法,如使用"parent::__construct()"調用父類中被覆蓋的構造方法,其它方法的類似,于是上面的代碼可以簡化為:

  1. <?php  
  2.       class Student extends Person{  
  3.                                        
  4.            public $name;      
  5.            public $age;           
  6.                                        
  7.           public function __construct($name="",$age=25){  
  8.               parent::__construct($name,$age);  
  9.               $this->age =$age;   
  10.          }  
  11.            public  function say(){   
  12.              parent::say();  
  13.               echo ",今年".$this->age."歲了" ;    
  14.           }    
  15.                                            
  16.  }   
  17.  ?> 

下再看一個實例

PHP5重寫方法

先設置一個父類,這個父類是 “Dog”類,這個類描述了dog的特性,Dog有2個眼睛,會跑,會叫。就這樣描述先,我養了一直狗,是只小狗,符合Dog類的特性,但有所不同,我的小狗有名字,我的小狗太小了,不會大聲的叫,只會哼哼,我們用繼承的概念去實現這個設計,代碼如下:

  1. <? 
  2. // 狗有兩只眼睛,會汪汪叫,會跑. 
  3. class  Dog { 
  4.  protected  $eyeNumber =2; //屬性 
  5.  //返回封裝屬性的方法. 
  6.  public function getEyeNumber(){  
  7.   return $this->eyeNumber; 
  8.  } 
  9.  //狗會叫  
  10.  public function  yaff(){ 
  11.   return  "Dog yaff, wang ..wang .."
  12.  } 
  13.  //狗會跑 
  14.  public function  run(){ 
  15.   return  "Dog run..running ..."
  16.  } 
  17. $dog = new Dog(); 
  18. echo "dog have ".$dog->getEyeNumber()." eyes. <br>"
  19. echo $dog->yaff() ."<br>".$dog->run(); 
  20. echo  "<br><br>"
  21. //這是我的小狗叫"狗狗",它很小.不會汪汪叫,只會哼哼哼.. 
  22. class MyDog extends Dog { 
  23.  private $name = "狗狗"
  24.  public function getName(){ 
  25.   return $this->name; 
  26.  } 
  27.     public function  yaff(){ 
  28.   return  $this->name." yaff, heng...heng .."
  29.  }  
  30. $myDog = new MyDog(); 
  31. echo $myDog->getName()." have ".$myDog->getEyeNumber()." eyes. <br>"
  32. echo $myDog->yaff() ."<br>".$myDog->run(); 
  33. ?> 
  34. //程序運行結果: 
  35. //dog have 2 eyes.  
  36. //Dog yaff, wang ..wang .. 
  37. //Dog run..running ... 
  38. //狗狗 have 2 eyes.  
  39. //狗狗 yaff, heng...heng .. 
  40. //Dog run..running ... 

重寫方法與訪問權限

子類中的覆蓋方法不能使用比父類中被覆蓋方法更嚴格的訪問權限,父類為public 子類為 private時,實例代碼如下:

  1. <? 
  2. // 簡化dog類和mydog類,演示重寫的訪問權限. 
  3. class Dog { 
  4.  protected  $eyeNumber =2; //屬性 
  5.  //返回封裝屬性的方法. 
  6.  public function getEyeNumber(){  
  7.   return $this->eyeNumber; 
  8.  }  
  9. class MyDog extends Dog { 
  10.  protected function getEyeNumber(){  
  11.   return $this->eyeNumber; 
  12.  }  
  13. /* 
  14. class MyDog extends Dog { 
  15.  private function getEyeNumber(){  
  16.   return $this->eyeNumber; 
  17.  }  
  18. } 
  19. */ 
  20. ?> 
  21. //程序運行結果: 
  22. //Fatal error: Access level to MyDog::getEyeNumber() must be public (as in class Dog) in E:PHPProjectstest.php on line 15 

父類為public子類為protected時,實例代碼如下:

  1. <?php 
  2. // 簡化dog類和mydog類,演示重寫的訪問權限. 
  3. class Dog { 
  4.  protected  $eyeNumber =2; //屬性 
  5.  //返回封裝屬性的方法. 
  6.  public function getEyeNumber(){  
  7.   return $this->eyeNumber; 
  8.  }  
  9. class MyDog extends Dog { 
  10.  private function getEyeNumber(){  
  11.   return $this->eyeNumber; 
  12.  }  
  13. ?> 
  14. //程序運行結果: 
  15.  //Fatal error: Access level to MyDog::getEyeNumber() must be public (as in class Dog) in E:PHPProjectstest.php on line 15 

重寫時的參數數量

子類可以擁有與父類不同的參數數量,這點與java不同,PHP是弱類型語言,實例代碼如下:

  1. <? 
  2. // 簡化dog類和mydog類,演示重寫方法的參數. 
  3. class  Dog { 
  4.  protected  $eyeNumber =2; //屬性 
  5.  //返回封裝屬性的方法. 
  6.  public function getEyeNumber(){  
  7.   return $this->eyeNumber; 
  8.  }  
  9. class MyDog extends Dog { 
  10.  //重寫的方法與父類的方法有不同的參數數量. 
  11.  public function getEyeNumber($eys){ 
  12.   $this->eyeNumber = $eys
  13.   return $this->eyeNumber; 
  14.  }  
  15. $myDog = new MyDog(); 
  16. echo "my dog hava ".$myDog->getEyeNumber(3) ." eyes."
  17. //嘯天犬..哈.. 
  18. //下面這句會報一個丟失參數的錯誤. 
  19. //echo "my dog hava ".$myDog->getEyeNumber() ." eyes."; 
  20. ?> 
  21. //程序運行結果: 
  22. //my dog hava 3 eyes. 

構造函數重寫

下面這個例子中,父類和子類都有自己的構造函數,當子類被實例化時,子類的構造函數被調用,而父類的構造函數沒有被調用,請對比第一節的構造函數繼承,實例代碼如下:

  1. <? 
  2. //2-2 / extends1.php 
  3. //構造函數繼承的問題. 
  4. class Animal{ 
  5.  public $legNum = 0;  
  6.  public function __construct(){ 
  7.   $this->legNum = 4; 
  8.   echo "I am an animal<br>"
  9.  } 
  10. class Dog1 extends Animal { 
  11.  public function __construct(){ 
  12.   $this->legNum = 4; 
  13.   echo "I am a Dog .<br>"
  14.  } 
  15. $dog1 = new Dog1(); 
  16. echo "<br>"
  17. echo  "legNum is ".$dog1->legNum; 
  18. /* 
  19. 實例化子類時.構造函數被調用了. 
  20. */ 
  21. ?> 
  22. //程序運行結果: 
  23. //I am a Dog .   
  24. //legNum is 4 

注:這點和Java不同,在java中構造函數是不能被繼承的,而且子類實例化時,子類的構造函數被調用,父類的構造函數也會調用.

Tags: php面向對象 子類 重載父類

分享到:

天气网首页彩吧