Explication détaillée de l'héritage de classe et d'objet en php

在php中，类型的继承使用extends关键字，而且最多只能继承一个父类，php不支持多继承。本文主要和大家分享的是php中的类与对象继承详解，希望能帮助到大家。

class MyClass 
{
 public $dat = 0;
 public function __construct($dat) {
  $this->dat = $dat;
 }
 public function getDat() {
  return "$this->dat\n";
 }
}
class MySubClass extends MyClass
{
 public function getDat() {
  return "dat: $this->dat\n";
 }
}
$a = new MyClass(3);
$b = new MySubClass(4);
echo $a->getDat();  // 3
echo $b->getDat();  // dat: 4

   

方法覆盖

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

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

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

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

class MyClass 
{
 private $name = "";
 public $num = 0;
 public $str = "";
 public function __construct($name) {
  $this->name = $name;
  $this->num = 100;
  $this->str = "none";
 }
 public function getName() {
  return $this->name;
 }
}
class MySubClass extends MyClass
{
 public function __construct($name, $str) {
  parent::__construct($name);    // 调用父类方法
  $this->num = "0";
  $this->str = $str;
  echo parent::getName()."\n";    // 调用父类方法
 }
 public function getName() {
  return parent::getName()."$this->str\n"; // 调用父类方法 
 }
}
$b = new MySubClass("myName", true);  // myName
echo $b->getName();          // myName1
class MyClass 
{
 final public function getName() {
 }
}

属性重定义

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

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

class MyClass 
{
 public $a = 1;
 protected $b = 2;
 private $c = 3;
 public function f1() {
  echo "MyClass f1\n";
  echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; 
 }
 protected function f2() {
  echo "MyClass f2\n";
  echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; 
 }
 private function f3() {
  echo "MyClass f3\n";
 }
}
class MySubClass extends MyClass 
{
 public $b = 22;
 public $c = 33;
 public function f1() {
  echo "MySubClass f1\n";
  // 继承到父类中的$a属性，直接使用
  echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; 
  // 调用父类中的同名方法
  parent::f1();
  // 继承到父类中的f2()方法，直接使用
  $this->f2();
 }
 // 父类的f3()是私有的，这里的定义与父类无关
 public function f3() {
  echo "MySubClass f3\n";
 }
}
$b = new MySubClass;
$b->f1();echo "\n";
/*
MySubClass f1
$a:1; $b:22; $c:33;
MyClass f1
$a:1; $b:22; $c:3;
MyClass f2
$a:1; $b:22; $c:3;
*/
$b->f3();echo "\n";
/*
MySubClass f3
*/

   

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

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

class MyClass 
{
 public $a = 1;
 protected $b = 2;
 private $c = 3;
 public function f1() {
  echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; 
 }
}
class MySubClass extends MyClass 
{
 public $a = 11;   // 必须为public
 protected $b = 22; // 必须为protected或public
 private $c = 33;  
 public function f2() {
  echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; 
 }
}
$b = new MySubClass;
$b->f1(); // $a:11; $b:22; $c:3;
$b->f2(); // $a:11; $b:22; $c:33;

   

范围解析操作符 ::

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

class MyClass 
{
 const Name0 = "MyClass";  // 类常量
 public static $id0 = 0;  // 类变量
 public function put() {  // 将被子类覆盖的方法
  echo "MyClass put()\n";
 }
}
class MySubClass extends MyClass 
{
 const Name1 = "MySubClass";
 public static $id1 = 1; 
 public function put() {
  parent::put();        // 调用父类版本的对象方法 
  echo parent::Name0 . "\n";  // 父类常量
  echo parent::$id0 . "\n";   // 父类变量
  echo self::Name1."\n";    // 子类常量
  echo self::$id1 . "\n";    // 子类变量
  echo static::Name1 . "\n";  // 子类常理
  echo static::$id1 . "\n";   // 子类变量
 }
}
$a = "MyClass";
$ca = new MyClass;
$cb = new MySubClass; 
$cb->put();
echo MyClass::Name0 . "\n";
echo MyClass::$id0 . "\n";
echo $a::Name0 . "\n";
echo $a::$id0 . "\n";
echo $ca::Name0 . "\n";
echo $ca::$id0 . "\n";

   

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

final

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

// 声明为final的类不能被继承
final class MyClass
{
 private $dat;
 public function __construct($dat) {
  $this->dat = $dat;
 }
 // final方法不能被覆盖，不过此类已经是final类，方法无必要在声明为final了 
 final public 
 function getDat() 
{ return $this->dat; }}

相关推荐：

php类与对象易错笔记分享

php中的类与对象示例详解

php类与对象接口定义介绍和用法实例详解

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!