本文实例讲述了PHP面向对象（Object-oriented programming，OOP）基础，分享给大家供大家参考，具体如下：

我们可以使用接口（interface），指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容，我们可以通过 interface 关键字来定义，就像定义一个标准的类一样，但其中定义所有的方法都是空的，但是其中定义的所有方法都必须是公有，这是接口的特性。

但是我们如果要实现一个接口，就得使用 implements 操作符，并且类中必须实现接口中定义的所有方法，否则会报一个致命错误，其中类还可以实现多个接口，用逗号来分隔多个接口的名称，是不是很神奇？？？来看实例感受下：

1. <?php 
2. // 声明一个'iTemplate'接口 
3. interface iTemplate 
4. { 
5.   public function setVariable($name, $var); 
6.   public function getHtml($template); 
7. } 
8. // 实现接口 
9. class Template implements iTemplate 
10. { 
11.   private $vars = array(); 
12.   public function setVariable($name, $var) 
13.   { 
14.     $this->vars[$name] = $var; 
15.   } 
16.   public function getHtml($template) 
17.   { 
18.     foreach($this->vars as $name => $value) { 
19.       $template = str_replace('{' . $name . '}', $value, $template); 
20.     } 
21.     return $template; 
22.   } 
23. } 

我们可以把在类中始终保持不变的值定义为常量，但是在定义和使用常量的时候不需要使用 $ 符号。需要注意的就是，常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用。自 PHP 5.3.0 起，我们可以用一个变量来动态调用类，但该变量的值不能为关键字（如 self，parent 或 static），来看实例感受下：

1. <?php 
2. class MyClass 
3. { 
4.   const constant = '常量值'; 
5.   function showConstant() { 
6.     echo self::constant . PHP_EOL; 
7.   } 
8. } 
9. echo MyClass::constant . PHP_EOL; 
10. $classname = "MyClass"; 
11. echo $classname::constant . PHP_EOL; // 自 5.3.0 起 
12. $class = new MyClass(); 
13. $class->showConstant(); 
14. echo $class::constant . PHP_EOL; // 自 PHP 5.3.0 起 
15. ?> 

任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的，并且，定义为抽象的类不能被实例化，完事呢，被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现，这是抽象类的一些公知的概念。

但是当继承一个抽象类的时候，子类必须定义父类中的所有抽象方法，另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。举个栗子，例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的，了解了之后咱们就来看下实例：

1. <?php 
2. abstract class AbstractClass 
3. { 
4.  // 强制要求子类定义这些方法 
5.   abstract protected function getValue(); 
6.   abstract protected function prefixValue($prefix); 
7.   // 普通方法（非抽象方法） 
8.   public function printOut() { 
9.     print $this->getValue() . PHP_EOL; 
10.   } 
11. } 
12. class ConcreteClass1 extends AbstractClass 
13. { 
14.   protected function getValue() { 
15.     return "ConcreteClass1"; 
16.   } 
17.   public function prefixValue($prefix) { 
18.     return "{$prefix}ConcreteClass1"; 
19.   } 
20. } 
21. class ConcreteClass2 extends AbstractClass 
22. { 
23.   public function getValue() { 
24.     return "ConcreteClass2"; 
25.   } 
26.   public function prefixValue($prefix) { 
27.     return "{$prefix}ConcreteClass2"; 
28.   } 
29. } 
30. $class1 = new ConcreteClass1; 
31. $class1->printOut(); 
32. echo $class1->prefixValue('FOO_') . PHP_EOL; 
33. $class2 = new ConcreteClass2; 
34. $class2->printOut(); 
35. echo $class2->prefixValue('FOO_') . PHP_EOL; 
36. ?> 

输出结果为：

ConcreteClass1

FOO_ConcreteClass1

ConcreteClass2

FOO_ConcreteClass2

我们还要记得，子类方法可以包含父类抽象方法中不存在的可选参数，举个栗子，例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则也是可以正常运行的，如下：

1. <?php 
2. abstract class AbstractClass 
3. { 
4.   // 我们的抽象方法仅需要定义需要的参数 
5.   abstract protected function prefixName($name); 
6. } 
7. class ConcreteClass extends AbstractClass 
8. { 
9.   // 我们的子类可以定义父类签名中不存在的可选参数 
10.   public function prefixName($name, $separator = ".") { 
11.     if ($name == "Pacman") { 
12.       $prefix = "Mr"; 
13.     } elseif ($name == "Pacwoman") { 
14.       $prefix = "Mrs"; 
15.     } else { 
16.       $prefix = ""; 
17.     } 
18.     return "{$prefix}{$separator} {$name}"; 
19.   } 
20. } 
21. $class = new ConcreteClass; 
22. echo $class->prefixName("Pacman"), "\n"; 
23. echo $class->prefixName("Pacwoman"), "\n"; 
24. ?> 

输出结果为：

Mr. Pacman

Mrs. Pacwoman

声明类属性或方法为 static(静态)，它可以不实例化类而直接访问，但是，静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。另外，由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用，也就是说，静态属性不可以由对象通过 -> 操作符来访问。自 PHP 5.3.0 起，我们可以用一个变量来动态调用类，但该变量的值不能为关键字 self，parent 或 static，实例如下：

1. <?php 
2. class Foo { 
3.  public static $my_static = 'foo'; 
4.  public function staticValue() { 
5.    return self::$my_static; 
6.  } 
7. } 
8. print Foo::$my_static . PHP_EOL; 
9. $foo = new Foo(); 
10. print $foo->staticValue() . PHP_EOL; 
11. ?> 

输出结果如下：

foo

foo

PHP 5 新增了一个 final 关键字，它的作用就是，如果父类中的方法被声明为 final，则子类无法覆盖该方法，如果一个类被声明为 final，则不能被继承，如下案例，会报错的哦：

1. <?php 
2. class BaseClass { 
3.   public function test() { 
4.     echo "BaseClass::test() called" . PHP_EOL; 
5.   } 
6.   final public function moreTesting() { 
7.     echo "BaseClass::moreTesting() called" . PHP_EOL; 
8.   } 
9. } 
10. class ChildClass extends BaseClass { 
11.   public function moreTesting() { 
12.     echo "ChildClass::moreTesting() called" . PHP_EOL; 
13.   } 
14. } 
15. // 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting() 
16. ?> 

PHP 不会在子类的构造方法中自动的调用父类的构造方法，如果需要执行父类的构造方法，我们可以在子类的构造方法中调用 parent::__construct()，如下：

1. <?php 
2. class BaseClass { 
3.   function __construct() { 
4.     print "BaseClass 类中构造方法" . PHP_EOL; 
5.   } 
6. } 
7. class SubClass extends BaseClass { 
8.   function __construct() { 
9.     parent::__construct(); // 子类构造方法不能自动调用父类的构造方法 
10.     print "SubClass 类中构造方法" . PHP_EOL; 
11.   } 
12. } 
13. class OtherSubClass extends BaseClass { 
14.   // 继承 BaseClass 的构造方法 
15. } 
16. // 调用 BaseClass 构造方法 
17. $obj = new BaseClass(); 
18. // 调用 BaseClass、SubClass 构造方法 
19. $obj = new SubClass(); 
20. // 调用 BaseClass 构造方法 
21. $obj = new OtherSubClass(); 
22. ?> 

输出结果为：

BaseClass 类中构造方法

BaseClass 类中构造方法

SubClass 类中构造方法

BaseClass 类中构造方法

好啦，本次记录就到这里了。

Tags: Object oriented programming

分享到：