本文实例讲述了PHP中类与对象功能、用法，分享给大家供大家参考，具体如下：

1. 类与对象

类是面向对象程序设计的基本概念，是一类东西的结构描述 , 是一种抽象的概念 . 对象是一类东西的一个具体的实例 , 是具体事物 .

对象通过new关键字进行实例化：

比如汽车可以抽象为一个类，汽车拥有名字、轮胎、速度、重量等属性，可以有换挡、前进、后退等操作方法。

1. // 定义一个汽车类 
2. class Car { 
3.   $name = '汽车'; 
4.   function getName() { 
5.     return $this->name; 
6.   } 
7. } 
8. //对象通过new关键字进行实例化  
9. $car = new Car(); 
10. echo $car->getName(); 

2. 属性与对象

在类中定义的变量称之为属性。属性声明是由关键字 public，protected 或者 private 开头，后面跟一个普通的变量声明来组成。属性的变量可以设置初始化的默认值，默认值必须是常量。

方法就是在类中的function，很多时候我们分不清方法与函数有什么差别，在面向过程的程序设计中function叫做函数，在面向对象中function则被称之为方法。

访问控制的关键字代表的意义为：

public：公开的 , 任何地方都可以访问

protected：受保护的 , 类内自身 , 其子类和父类可以访问

private：私有的 , 类内自身可访问

类属性的访问控制必须定义 , 即必须写出关键字 , 定义为三个中的一个

类方法不写关键字 , 则默认为公有的

1. class Car { 
2.   public $speed = 0; 
3.   //增加speedUp方法，使speed加10 
4.   public function speedUp(){ 
5.     $this->speed += 10; 
6.   } 
7. } 
8. // 创建对象 
9. $car = new Car(); 
10. // 通过对象获取类属性与类方法 
11. $car->speedUp(); 
12. echo $car->speed; 

3. 构造函数与析构函数

PHP5可以在类中使用__construct()定义一个构造函数，具有构造函数的类，会在每次对象创建的时候调用该函数，因此常用来在对象创建的时候进行一些初始化工作。

在子类中如果定义了__construct则不会调用父类的__construct，如果需要同时调用父类的构造函数，需要使用parent::__construct()显式的调用。

同样，PHP5支持析构函数，使用__destruct()进行定义，析构函数指的是当某个对象的所有引用被删除，或者对象被显式的销毁时会执行的函数。

1. class Car { 
2.   function __construct() { 
3.     print "构造函数被调用 \n"; 
4.   } 
5.   function __destruct() { 
6.     print "析构函数被调用 \n"; 
7.   } 
8. } 
9. $car = new Car(); //实例化时会调用构造函数 
10. echo '使用后，准备销毁car对象 \n'; 
11. unset($car); //销毁时会调用析构函数 

当PHP代码执行完毕以后，会自动回收与销毁对象，因此一般情况下不需要显式的去销毁对象。

4. 静态属性与静态方法

静态属性:

public / protected / private static $变量名

不用实例化类 , 直接调用 类名 :: $变量名

但实例化后 , 不允许使用 对象 -> $变量名

静态方法

public / protected / private static function 方法名()

不用实例化类 , 直接调用 类名 :: 方法名()

实例化后 , 对象 -> 方法名()

静态方法中，$this伪变量不允许使用，可以使用self，parent，static在内部调用静态方法与属性。

1. class Car { 
2.   private static $speed = 10; 
3.     
4.   public static function getSpeed() { 
5.     return self::$speed; 
6.   } 
7.     
8.   public static function speedUp() { 
9.     return self::$speed+=10; 
10.   } 
11. } 
12. class BigCar extends Car { 
13.   public static function start() { 
14.     parent::speedUp(); 
15.   } 
16. } 
17.  
18. BigCar::start(); 
19. echo BigCar::getSpeed(); 

如果构造函数定义成了私有方法，则不允许直接实例化对象了，这时候一般通过静态方法进行实例化，在设计模式中会经常使用这样的方法来控制对象的创建，比如单例模式只允许有一个全局唯一的对象。

1. class Car { 
2.   private function __construct() { 
3.     echo 'object create'; 
4.   } 
5.  
6.   private static $_object = null; 
7.   public static function getInstance() { 
8.     if (emptyempty(self::$_object)) { 
9.       self::$_object = new Car(); //内部方法可以调用私有方法，因此这里可以创建对象 
10.     } 
11.     return self::$_object; 
12.   } 
13. } 
14. $car = new Car(); //这里不允许直接实例化对象 
15. $car = Car::getInstance(); //通过静态方法来获得一个实例 

5. 继承

继承是面向对象程序设计中常用的一个特性，汽车是一个比较大的类，我们也可以称之为基类，除此之外，汽车还分为卡车、轿车、东风、宝马等，因为这些子类具有很多相同的属性和方法，可以采用继承汽车类来共享这些属性与方法，实现代码的复用。

1. class Car { 
2.   public $speed = 0; //汽车的起始速度是0 
3.     
4.   public function speedUp() { 
5.     $this->speed += 10; 
6.     return $this->speed; 
7.   } 
8. } 
9. //建立一个Truck类，扩展Car类，并覆盖speedUp方法，使速度累加50 
10. class Truck extends Car{ 
11.   public function speedUp(){ 
12.     parent::speedUp(); 
13.     $this->speed += 50; 
14.     return $this->speed; 
15.   } 
16. } 
17.  
18. $car = new Truck(); 
19. $car->speedUp(); 
20. echo $car->speed; 

5. 重载

PHP中的重载指的是动态的创建属性与方法，是通过魔术方法来实现的。

属性的重载通过__set，__get，__isset，__unset来分别实现对不存在属性的赋值、读取、判断属性是否设置、销毁属性。

1. class Car { 
2.   private $ary = array(); 
3.     
4.   public function __set($key, $val) { 
5.     $this->ary[$key] = $val; 
6.   } 
7.     
8.   public function __get($key) { 
9.     if (isset($this->ary[$key])) { 
10.       return $this->ary[$key]; 
11.     } 
12.     return null; 
13.   } 
14.     
15.   public function __isset($key) { 
16.     if (isset($this->ary[$key])) { 
17.       return true; 
18.     } 
19.     return false; 
20.   } 
21.     
22.   public function __unset($key) { 
23.     unset($this->ary[$key]); 
24.   } 
25. } 
26. $car = new Car(); 
27. $car->name = '汽车'; //name属性动态创建并赋值 
28. echo $car->name; 
29. if ($car->age){ 
30.   echo '有'; 
31. }else{ 
32.   echo '无'; 
33. } 
34. unset($car->name); 
35. var_dump($car->name); 

方法的重载通过__call来实现，当调用不存在的方法的时候，将会转为参数调用__call方法，当调用不存在的静态方法时会使用__callStatic重载。

1. class Car { 
2.   public $speed = 0; 
3.     
4.   public function __call($name, $args) { 
5.     if ($name == 'speedUp') { 
6.       $this->speed += 10; 
7.     } 
8.   } 
9. } 
10. $car = new Car(); 
11. $car->speedUp(); //调用不存在的方法会使用重载 
12. echo $car->speed; 

6. 高级特性

对象比较，当同一个类的两个实例的所有属性都相等时，可以使用比较运算符 == 进行判断，当需要判断两个变量是否为同一个对象的引用时，可以使用全等运算符 === 进行判断。

1. class Car { 
2. } 
3. $a = new Car(); 
4. $b = new Car(); 
5. if ($a == $b) echo '==';  //true 
6. if ($a === $b) echo '==='; //false 

对象复制，在一些特殊情况下，可以通过关键字clone来复制一个对象，这时__clone方法会被调用，通过这个魔术方法来设置属性的值。

1. class Car { 
2.   public $name = 'car'; 
3.     
4.   public function __clone() { 
5.     $obj = new Car(); 
6.     $obj->name = $this->name; 
7.   } 
8. } 
9. $a = new Car(); 
10. $a->name = 'new car'; 
11. $b = clone $a; 
12. var_dump($b); 

对象序列化，可以通过serialize方法将对象序列化为字符串，用于存储或者传递数据，然后在需要的时候通过unserialize将字符串反序列化成对象进行使用。

1. class Car { 
2.   public $name = 'car'; 
3. } 
4. $a = new Car(); 
5. $str = serialize($a); //对象序列化成字符串 
6. echo $str.'<br>'; 
7. $b = unserialize($str); //反序列化为对象 
8. var_dump($b);

Tags: PHP类 PHP对象

分享到：