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

在面向对象的程序设计（英语：Object-oriented programming，缩写：OOP）中，对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象，然而在现实世界里我们所面对的事情都是对象，如计算机、电视机、自行车等，我们来看下对象的三个主要特征：

对象的行为：可以对 对象施加那些操作，开灯，关灯就是行为。

对象的形态：当施加那些方法是对象如何响应，颜色，尺寸，外型。

对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。

举个栗子，比如 Animal(动物) 是一个抽象类，我们可以具体到一只狗跟一只羊，而狗跟羊就是具体的对象，他们有颜色属性，可以写，可以跑等行为状态，来看张图片感受下：

来看下面向对象的主要内容：

类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。

对象 − 是类的实例。

成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可称为对象的属性。

成员函数 − 定义在类的内部，可用于访问对象的数据。

继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。

子类 − 一个类继承其他类称为子类，也可称为派生类。

多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。

封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。

构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。

析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

接下来，咱们通过通过 Car 类 创建了三个对象，Mercedes, Bmw, 和 Audi ，看下代码：

1. $mercedes = new Car (); 
2. $bmw = new Car (); 
3. $audi = new Car (); 

看了代码是不是一脸懵，不要紧，咱们看下图片感受下：

到了这里呢，咱们对于对象有了一个简单的认知了已经，接下来咱们就看下这个类，PHP 定义类通常语法格式如下：

2. class phpClass { 
3.  var $var1; 
4.  var $var2 = "constant string"; 
5.  function myfunc ($arg1, $arg2) { 
6.    [..] 
7.  } 
8.  [..] 
9. } 
10. ?> 

来看下文字解析：

类使用 class 关键字后加上类名定义。

类名后的一对大括号({})内可以定义变量和方法。

类的变量使用 var 来声明, 变量也可以初始化值。

函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。

来看下实例：

2. class Site { 
3.  /* 成员变量 */ 
4.  var $url; 
5.  var $title; 
6.  /* 成员函数 */ 
7.  function setUrl($par){ 
8.    $this->url = $par; 
9.  } 
10.  function getUrl(){ 
11.    echo $this->url . PHP_EOL; 
12.  } 
13.  function setTitle($par){ 
14.    $this->title = $par; 
15.  } 
16.  function getTitle(){ 
17.    echo $this->title . PHP_EOL; 
18.  } 
19. } 
20. ?> 

当类创建后，我们可以使用 new 运算符来实例化该类的对象，如下：

$luyaran = new Site;

$cuijinpeng = new Site;

通过以上代码，我们已经创建了两个对象，并且两个对象各自都是独立的，接下来我们来看看如何访问成员方法与成员变量。

首先，在实例化对象后，我们可以使用该对象调用成员方法，该对象的成员方法只能操作该对象的成员变量，如下：

1. // 调用成员函数，设置标题和URL 
2. $luyaran->setTitle( "luyaran" ); 
3. $cuijinpeng->setTitle( "cuijinpeng" ); 
4. $luyaran->setUrl( 'www.luyaran.com' ); 
5. $cuijinpeng->setUrl( 'www.cuijinpeng.com' ); 
6. // 调用成员函数，获取标题和URL 
7. $luyaran->getTitle(); 
8. $cuijinpeng->getTitle(); 
9. $luyaran->getUrl(); 
10. $cuijinpeng->getUrl(); 

咱们接下来就要继续完善咱们刚刚创建的类了。

先来看构造函数，它是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，在创建对象的语句中与 new 运算符一起使用。PHP 5 允许开发者在一个类中定义一个方法作为构造函数，语法格式如下：

void __construct ([ mixed $args [, $... ]] )

接下来我们来通过构造方法来初始化 $url 和 $title 变量，以晚上Site类，如下：

1. function __construct( $par1, $par2 ) { 
2.   $this->url = $par1; 
3.   $this->title = $par2; 
4. } 

到了这里呢，我们如果要设置url和title值，就不需要再调用 setTitle 和 setUrl 方法了，具体设置方法如下：

1. $luyaran = new Site('www.luyaran.com', 'luyaran'); 
2. $cuijinpeng = new Site('www.cuijinpeng.com', 'cuijinpeng'); 
3. // 调用成员函数，获取标题和URL 
4. $luyaran->getTitle(); 
5. $cuijinpeng->getTitle(); 
6. $google->getTitle(); 
7. $luyaran->getUrl(); 
8. $cuijinpeng->getUrl();  

完事来看析构函数(destructor)，它与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言，其语法格式如下：

void __destruct ( void )

来看实例：

2. class MyDestructableClass { 
3.   function __construct() { 
4.     print "构造函数\n"; 
5.     $this->name = "MyDestructableClass"; 
6.   } 
7.   function __destruct() { 
8.     print "销毁 " . $this->name . "\n"; 
9.   } 
10. } 
11. $obj = new MyDestructableClass(); 
12. ?> 

输出结果为：

构造函数

销毁 MyDestructableClass

咱们接下来就来看下类的继承。

PHP 使用关键字 extends 来继承一个类，但是PHP它不支持多继承，语法格式如下：

1. class Child extends Parent { 
2.   // 代码部分 
3. } 

咱们接下来使用Child_Site 类继承 Site 类，并扩展其功能，如下：

2. class Child_Site extends Site { 
3.   var $category; 
4.   function setCate($par){ 
5.     $this->category = $par; 
6.   } 
7.   function getCate(){ 
8.     echo $this->category . PHP_EOL; 
9.   } 
10. } 

再来看方法重写，它的定义就是，如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写，废话不多说，来看下重写了 getUrl 与 getTitle 方法的实例：

1. function getUrl() { 
2.   echo $this->url . PHP_EOL; 
3.   return $this->url; 
4. } 
5. function getTitle(){ 
6.   echo $this->title . PHP_EOL; 
7.   return $this->title; 
8. } 

PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的，来看下具体意思：

public（公有）：公有的类成员可以在任何地方被访问。

protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。

private（私有）：私有的类成员则只能被其定义所在的类访问。

类属性必须定义为公有，受保护，私有之一，如果用 var 定义，则被视为公有，看实例感受下：

2. /** 
3.  * Define MyClass 
4.  */ 
5. class MyClass 
6. { 
7.   public $public = 'Public'; 
8.   protected $protected = 'Protected'; 
9.   private $private = 'Private'; 
10.   function printHello() 
11.   { 
12.     echo $this->public; 
13.     echo $this->protected; 
14.     echo $this->private; 
15.   } 
16. } 
17. $obj = new MyClass(); 
18. echo $obj->public; // 这行能被正常执行 
19. echo $obj->protected; // 这行会产生一个致命错误 
20. echo $obj->private; // 这行也会产生一个致命错误 
21. $obj->printHello(); // 输出 Public、Protected 和 Private 
22. /** 
23.  * Define MyClass2 
24.  */ 
25. class MyClass2 extends MyClass 
26. { 
27.   // 可以对 public 和 protected 进行重定义，但 private 而不能 
28.   protected $protected = 'Protected2'; 
29.   function printHello() 
30.   { 
31.     echo $this->public; 
32.     echo $this->protected; 
33.     echo $this->private; 
34.   } 
35. } 
36. $obj2 = new MyClass2(); 
37. echo $obj2->public; // 这行能被正常执行 
38. echo $obj2->private; // 未定义 private 
39. echo $obj2->protected; // 这行会产生一个致命错误 
40. $obj2->printHello(); // 输出 Public、Protected2 和 Undefined 
41. ?> 

类中的方法可以被定义为公有，私有或受保护，然而如果没有设置这些关键字，则该方法默认为公有，感受下实例：

2. /** 
3.  * Define MyClass 
4.  */ 
5. class MyClass 
6. { 
7.   // 声明一个公有的构造函数 
8.   public function __construct() { } 
9.   // 声明一个公有的方法 
10.   public function MyPublic() { } 
11.   // 声明一个受保护的方法 
12.   protected function MyProtected() { } 
13.   // 声明一个私有的方法 
14.   private function MyPrivate() { } 
15.   // 此方法为公有 
16.   function Foo() 
17.   { 
18.     $this->MyPublic(); 
19.     $this->MyProtected(); 
20.     $this->MyPrivate(); 
21.   } 
22. } 
23. $myclass = new MyClass; 
24. $myclass->MyPublic(); // 这行能被正常执行 
25. $myclass->MyProtected(); // 这行会产生一个致命错误 
26. $myclass->MyPrivate(); // 这行会产生一个致命错误 
27. $myclass->Foo(); // 公有，受保护，私有都可以执行 
28. /** 
29.  * Define MyClass2 
30.  */ 
31. class MyClass2 extends MyClass 
32. { 
33.   // 此方法为公有 
34.   function Foo2() 
35.   { 
36.     $this->MyPublic(); 
37.     $this->MyProtected(); 
38.     $this->MyPrivate(); // 这行会产生一个致命错误 
39.   } 
40. } 
41. $myclass2 = new MyClass2; 
42. $myclass2->MyPublic(); // 这行能被正常执行 
43. $myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行 
44. class Bar  
45. { 
46.   public function test() { 
47.     $this->testPrivate(); 
48.     $this->testPublic(); 
49.   } 
50.   public function testPublic() { 
51.     echo "Bar::testPublic\n"; 
52.   } 
53.   private function testPrivate() { 
54.     echo "Bar::testPrivate\n"; 
55.   } 
56. } 
57. class Foo extends Bar  
58. { 
59.   public function testPublic() { 
60.     echo "Foo::testPublic\n"; 
61.   } 
62.   private function testPrivate() { 
63.     echo "Foo::testPrivate\n"; 
64.   } 
65. } 
66. $myFoo = new foo(); 
67. $myFoo->test(); // Bar::testPrivate  
68.         // Foo::testPublic 
69. ?> 

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

Tags: Object oriented programming

分享到：