在php中，类型的继承使用extends关键字，而且最多只能继承一个父类，php不支持多继承，这篇文章主要介绍了php中的类与对象(继承),需要的朋友可以参考下

简介

在php中，类型的继承使用extends关键字，而且最多只能继承一个父类，php不支持多继承。

1. class MyClass   
2. {  
3.  public $dat = 0;  
4.  public function __construct($dat) {  
5.   $this->dat = $dat;  
6.  }  
7.  public function getDat() {  
8.   return "$this->dat\n";  
9.  }  
10. }  
11. class MySubClass extends MyClass  
12. {  
13.  public function getDat() {  
14.   return "dat: $this->dat\n";  
15.  }  
16. }  
17. $a = new MyClass(3);  
18. $b = new MySubClass(4);  
19. echo $a->getDat();  // 3  
20. echo $b->getDat();  // dat: 4 

方法覆盖

包括构造函数在内，子类可以重新定义同名的类方法以覆盖父类方法。覆盖时遵循以下规则：

1.除构造函数之外，其他函数在覆盖时，函数的参数列表必须相同

2.包括构造函数在内，方法被覆盖后，调用子类方法时并不会自动调用父类方法

3.如果父类要禁止方法被子类覆盖，可以使用final来声明方法，这时如果子类仍要覆盖父类方法，将会出错

1. class MyClass   
2. {  
3.  private $name = "";  
4.  public $num = 0;  
5.  public $str = "";  
6.  public function __construct($name) {  
7.   $this->name = $name;  
8.   $this->num = 100;  
9.   $this->str = "none";  
10.  }  
11.  public function getName() {  
12.   return $this->name;  
13.  }  
14. }  
15. class MySubClass extends MyClass  
16. {  
17.  public function __construct($name, $str) {  
18.   parent::__construct($name);    // 调用父类方法  
19.   $this->num = "0";  
20.   $this->str = $str;  
21.   echo parent::getName()."\n";    // 调用父类方法  
22.  }  
23.  public function getName() {  
24.   return parent::getName()."$this->str\n"; // 调用父类方法  
25.  }  
26. }  
27. $b = new MySubClass("myName", true);  // myName  
28. echo $b->getName();          // myName1  
29. class MyClass   
30. {  
31.  final public function getName() {  
32.  }  
33. } 

属性重定义

在子类中，可以访问父类中的public和protected属性成员，除非重定义了同名的自有属性，这时，父类中的属性将无法访问。

方法则不同，子类对方法进行覆盖后，仍然可以访问到父类方法。

1. class MyClass   
2. {  
3.  public $a = 1;  
4.  protected $b = 2;  
5.  private $c = 3;  
6.  public function f1() {  
7.   echo "MyClass f1\n";  
8.   echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n";  
9.  }  
10.  protected function f2() {  
11.   echo "MyClass f2\n";  
12.   echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n";  
13.  }  
14.  private function f3() {  
15.   echo "MyClass f3\n";  
16.  }  
17. }  
18. class MySubClass extends MyClass   
19. {  
20.  public $b = 22;  
21.  public $c = 33;  
22.  public function f1() {  
23.   echo "MySubClass f1\n";  
24.   // 继承到父类中的$a属性，直接使用  
25.   echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n";  
26.   // 调用父类中的同名方法  
27.   parent::f1();  
28.   // 继承到父类中的f2()方法，直接使用  
29.   $this->f2();  
30.  }  
31.  // 父类的f3()是私有的，这里的定义与父类无关  
32.  public function f3() {  
33.   echo "MySubClass f3\n";  
34.  }  
35. }  
36. $b = new MySubClass;  
37. $b->f1();echo "\n";  
38. /*  
39. MySubClass f1  
40. $a:1; $b:22; $c:33;  
41. MyClass f1  
42. $a:1; $b:22; $c:3;  
43. MyClass f2  
44. $a:1; $b:22; $c:3;  
45. */ 
46. $b->f3();echo "\n";  
47. /*  
48. MySubClass f3  
49. */ 

重定义父类(同名)属性时，属性的可访问性可以变得更开放，但不能更严格，也就是说，父类中的public属性，不能在子类中修改为private属性。

如果通过子类对象调用父类方法，那么该父类方法在访问属性时，对于重定义了的同名属性，public和protected的属性将访问到子类版本，private属性将访问到父类版本。也可以理解为，public和protected属性可以被重定义(父类的版本被重定义，从而不存在了)，而private并未被重定义(父类中的属性仍然存在，通过父类方法进行访问，与子类中是否有同名属性毫不相干)。

1. class MyClass   
2. {  
3.  public $a = 1;  
4.  protected $b = 2;  
5.  private $c = 3;  
6.  public function f1() {  
7.   echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n";  
8.  }  
9. }  
10. class MySubClass extends MyClass   
11. {  
12.  public $a = 11;   // 必须为public  
13.  protected $b = 22; // 必须为protected或public  
14.  private $c = 33;    
15.  public function f2() {  
16.   echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n";  
17.  }  
18. }  
19. $b = new MySubClass;  
20. $b->f1(); // $a:11; $b:22; $c:3;  
21. $b->f2(); // $a:11; $b:22; $c:33; 

范围解析操作符 ::

又冒号常用于访问类常量、类静态变量，也用于在方法覆盖时调用父类版本。与其搭配的还包括parent、self、static等关键字。

1. class MyClass   
2. {  
3.  const Name0 = "MyClass";  // 类常量  
4.  public static $id0 = 0;  // 类变量  
5.  public function put() {  // 将被子类覆盖的方法  
6.   echo "MyClass put()\n";  
7.  }  
8. }  
9. class MySubClass extends MyClass   
10. {  
11.  const Name1 = "MySubClass";  
12.  public static $id1 = 1;   
13.  public function put() {  
14.   parent::put();        // 调用父类版本的对象方法  
15.   echo parent::Name0 . "\n";  // 父类常量  
16.   echo parent::$id0 . "\n";   // 父类变量  
17.   echo self::Name1."\n";    // 子类常量  
18.   echo self::$id1 . "\n";    // 子类变量  
19.   echo static::Name1 . "\n";  // 子类常理  
20.   echo static::$id1 . "\n";   // 子类变量  
21.  }  
22. }  
23. $a = "MyClass";  
24. $ca = new MyClass;  
25. $cb = new MySubClass;   
26. $cb->put();  
27. echo MyClass::Name0 . "\n";  
28. echo MyClass::$id0 . "\n";  
29. echo $a::Name0 . "\n";  
30. echo $a::$id0 . "\n";  
31. echo $ca::Name0 . "\n";  
32. echo $ca::$id0 . "\n"; 

在子类中访问父类中的成员时，应避免直接使用父类类名，而应使用parent::，以免破坏父类的封装性。

final

声明为final的方法不能被子类覆盖，如果类声明为final，则此类不能被继承。

1. // 声明为final的类不能被继承  
2. final class MyClass  
3. {  
4.  private $dat;  
5.  public function __construct($dat) {  
6.   $this->dat = $dat;  
7.  }  
8.  // final方法不能被覆盖，不过此类已经是final类，方法无必要在声明为final了  
9.  final public function getDat() {  
10.   return $this->dat;  
11.  }  
12. }

Tags: php类 php继承

分享到：