Detailed explanation of classes and objects in php

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

简介

在php中，类型的继承使用extends关键字，而且最多只能继承一个父类，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单文件和多文件上传实例讲解

PHP多人模块开发的原理解析

使用XHProf查找PHP性能瓶颈的实例讲解

The above is the detailed content of Detailed explanation of classes and objects in php. For more information, please follow other related articles on the PHP Chinese website!