首页 > 代码库 > PHP 类与对象 全解析（ 二)
PHP 类与对象 全解析（ 二)
目录
PHP 类与对象 全解析（ 一)
PHP 类与对象 全解析（ 二）
PHP 类与对象 全解析（三 )
7.Static关键字
声明类成员或方法为static，就可以不实例化类而直接访问。不能通过一个对象来访问其中的静态成员（静态方法除外）。
静态成员属于类，不属于任何对象实例，但类的对象实例都能共享。
小结:
在类内部访问静态成员属性或者方法，使用 self::（没有 $ 符号），如：
self:: $country //类内部访问静态成员属性
self:: myCountry()
在子类访问父类静态成员属性或方法，使用 parent::（没有 $ 符号），如：
parent:: $country
parent:: myCountry()
外部访问静态成员属性和方法为 类名/子类名:: ，如：
Person::$country
Person::myCountry()
Student::$country
但静态方法也可以通过普通对象的方式访问
<?php Class Person{ // 定义静态成员属性 public static $country = "中国"; // 定义静态成员方法 public static function myCountry() { // 内部访问静态成员属性 echo "我是".self::$country."人<br />"; } } class Student extends Person { function study() { echo "我是". parent::$country."人<br />"; } } // 输出成员属性值 echo Person::$country."<br />"; // 输出：中国 $p1 = new Person(); //echo $p1->country; // 错误写法 // 访问静态成员方法 Person::myCountry(); // 输出：我是中国人 // 静态方法也可通过对象访问： $p1->myCountry(); // 子类中输出成员属性值 echo Student::$country."<br />"; // 输出：中国 $t1 = new Student(); $t1->study(); // 输出：我是中国人 ?>
---------------------------------------------------
8.抽象类 PHP5支持抽象类和抽象方法。
抽象类不能直接被实例化，你必须先继承该抽象类，然后再实例化子类。
抽象类中 至少要包含一个抽象方法。如果类方法被声明为抽象的，那么其中就不能包括具体的功能实现。
继承一个抽象类的时候，子类必须实现抽象类中的所有抽象方法；
另外，这些方法的可见性 必须和抽象类中一样（或者更为宽松）。
如果抽象类中某个抽象方法被声明为protected，那么子类中实现的方法就应该声明为protected或者public，而不 能定义为private。
//抽象方法：abstract protected function getValue();
例子1
abstract class AbstractClass{ // 定义抽象方法 abstract protected function getValue(); // 普通方法 public function printOut(){ print $this->getValue()."<br />"; } } class ConcreteClass extends AbstractClass{ protected function getValue(){ return "abstract ";//抽象方法的实现 } } $class1 = new ConcreteClass; $class1->printOut();
例子2
abstract class AbstractClass { // 强制要求子类定义这些方法 abstract protected function getValue(); abstract protected function prefixValue($prefix); // 普通方法（非抽象方法） public function printOut() { print $this->getValue() . "\n"; } } class ConcreteClass1 extends AbstractClass { protected function getValue() { return "ConcreteClass1"; } public function prefixValue($prefix) { return "{$prefix}ConcreteClass1"; } } class ConcreteClass2 extends AbstractClass { public function getValue() { return "ConcreteClass2"; } public function prefixValue($prefix) { return "{$prefix}ConcreteClass2"; } } $class1 = new ConcreteClass1; $class1->printOut(); echo $class1->prefixValue(‘FOO_‘) ."\n"; $class2 = new ConcreteClass2; $class2->printOut(); echo $class2->prefixValue(‘FOO_‘) ."\n";
/*
* 抽象类不能直接被实例化，你必须先继承该抽象类，然后再实例化子类。
抽象类中 至少要包含一个抽象方法。如果类方法被声明为抽象的，那么其中就不能包括具体的功能实现。
继承一个抽象类的时候，子类必须实现抽象类中的所有抽象方法；
另外，这些方法的可见性 必须和抽象类中一样（或者更为宽松）。
如果抽象类中某个抽象方法被声明为protected，那么子类中实现的方法就应该声明为protected或者public，而不 能定义为private。
*
*/
class Person { public $name; public $age; function say() { echo "my name is:".$this->name."<br />"; echo "my age is:".$this->age; } }
// 类的继承
class Student extends Person { var $school; //学生所在学校的属性 function study() { echo "my name is:".$this->name."<br />"; echo "my shool is:".$this->school; } } $t1 = new Student(); $t1->name = "zhangsan"; $t1->school = "beijindaxue"; $t1->study();
---------------------------------------------------------------------
9.接口
接口定义：方法和常量值定义的集合
通过interface来定义一个接口，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
接口的特性：接口中定义的所有方法都必须是public
接口的实现：一个接口可以使用implements操作符，类中必须实现接口中的所有方法，否则会报fatal错误，如果要实现多个接口，可以使用逗号来分隔多个接口的名称。
抽象类和接口的区别
接口是特殊的抽象类，也可以看做是一个模型的规范。接口与抽象类大致区别如下：
1.一个子类如果 implements 一个接口，就必须实现接口中的所有方法（不管是否需要）；如果是继承一个抽象类，只需要实现需要的方法即可。
2.如果一个接口中定义的方法名改变了，那么所有实现此接口的子类需要同步更新方法名；而抽象类中如果方法名改变了，其子类对应的方法名将不受影响，只是变成了一个新的方法而已（相对老的方法实现）。
3.抽象类只能单继承，当一个子类需要实现的功能需要继承自多个父类时，就必须使用接口。
实例1：
// 声明一个‘iTemplate‘接口
nterface iTemplate { public function setVariable($name, $var); public function getHtml($template); }
// 实现接口
// 下面的写法是正确的
class Template implements iTemplate { private $vars = array(); public function setVariable($name, $var) { $this->vars[$name] = $var; } public function getHtml($template) { foreach($this->vars as $name => $value) { $template = str_replace(‘{‘ . $name . ‘}‘, $value, $template); } return $template; } }
实例2：
//定义接口
interface User{ function getDiscount(); function getUserType(); }
//VIP用户 接口实现
class VipUser implements User{ // VIP 用户折扣系数 private $discount = 0.8; function getDiscount() { return $this->discount; } function getUserType() { return "VIP user"; } } class Goods{ var $price = 100; var $vc; //定义 User 接口类型参数，这时并不知道是什么用户 function run(User $vc){ $this->vc = $vc; $discount = $this->vc->getDiscount(); $usertype = $this->vc->getUserType(); echo $usertype."goods Price:".$this->price*$discount; } } display ->run(new VipUser); //可以是更多其他用户类型
-------------------------------------------------------------
10.重载
定义：一个类中的方法与另一个方法名称相同，但参数不同
什么情况下执行重载？ 当调用当前的环境下未被定义的属性或者方法时，或者当调用当前环境下不可见的属性或方法。
提示:
如果父类定义方法时使用了 final 关键字，则不允许被子类方法覆盖。
访问父类被覆盖的方法
可以通过parent:: 符号来访问父类被覆盖的方法或成员属性：
//PHP 重载方法 __call()
__call()（Method overloading）
为了避免当调用的方法不存在时产生错误，可以使用 __call() 方法来避免。该方法在调用的方法不存在时会自动调用，程序仍会继续执行下去。
语法：
// __call()方法重载
class Test{ public function __call($name,$args){ if($name== ‘null‘ && count($args)==2 ){ $type=‘num‘; foreach($args as $key => $val){ if(!(is_int($val) || is_float($val))){ $type= ‘string‘; } } $method=$name.ucfirst($type); if(method_exists($this,$method),$args){ call_user_func_array(array($this,$method),$args); } } } public addNum($i,$j){ echo $i+$j; } public addString($i,$j){ echo $i.$j; } } $test =new Test(); $test->add(3,4); $test->add(3,‘4‘);
案例：
class MemberTest { private $data = array();//被重载的数据保存在此 public $declared = 1;/** 重载不能被用在已经定义的属性 */ private $hidden = 2; /** 只有从类外部访问这个属性时，重载才会发生 */ public function __set($name, $value) { echo "Setting ‘$name‘ to ‘$value‘\n"; $this->data[$name] = $value; } public function __get($name) { echo "Getting ‘$name‘\n"; if (array_key_exists($name, $this->data)) { return $this->data[$name]; } $trace = debug_backtrace(); trigger_error( ‘Undefined property via __get(): ‘ . $name . ‘ in ‘ . $trace[0][‘file‘] . ‘ on line ‘ . $trace[0][‘line‘], E_USER_NOTICE); return null; } /** PHP 5.1.0之后版本 */ public function __isset($name) { echo "Is ‘$name‘ set?\n"; return isset($this->data[$name]); } /** PHP 5.1.0之后版本 */ public function __unset($name) { echo "Unsetting ‘$name‘\n"; unset($this->data[$name]); } /** 非魔术方法 */ public function getHidden() { return $this->hidden; } } echo "<pre>\n"; $obj = new MemberTest; $obj->a = 1; echo $obj->a . "\n\n"; var_dump(isset($obj->a)); unset($obj->a); var_dump(isset($obj->a)); echo "\n"; echo $obj->declared . "\n\n"; echo "Let‘s experiment with the private property named ‘hidden‘:\n"; echo "Privates are visible inside the class, so __get() not used...\n"; echo $obj->getHidden() . "\n"; echo "Privates not visible outside of class, so __get() is used...\n"; echo $obj->hidden . "\n";
//属性重载：__set(),__get(),__isset(),__unset()
class Person{ private $data =array(); function __set($name,$value){ $this->data[$name]=$value; } function __get($name){ return $this->data[$name]; } }
-----------------------------------------------------------------------------------
11.对象迭代
PHP5提供了一种迭代（iteration）对象的功能，就像使用数组那样，可以通过foreach 来遍历对象中的属性
class MyClass { public $var1 = ‘value 1‘; public $var2 = ‘value 2‘; public $var3 = ‘value 3‘; protected $protected = ‘protected var‘; private $private = ‘private var‘; function iterateVisible() { echo "MyClass::iterateVisible:\n"; foreach($this as $key => $value) { print "$key => $value\n"; } } } $class = new MyClass(); foreach($class as $key => $value) { print "$key => $value\n"; } echo "\n"; $class->iterateVisible();
---------------------------------------------------------------------------
12.设计模式: 工厂模式和 单例模式， 观察者模式，命令链模式和策略模式
命令链 模式以松散耦合主题为基础，发送消息、命令和请求，或通过一组处理程序发送任意内容。每个处理程序都会自行判断自己能否处理请求。
如果可以，该请求被处理，进程停止。您可以为系统添加或移除处理程序，而不影响其他处理程序。
工厂模式
定义：工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。
工厂模式语法：
<?php class Example { public static function factory($type) { if (include_once ‘Drivers/‘ . $type . ‘.php‘) { $classname = ‘Driver_‘ . $type; return new $classname; } else { throw new Exception (‘Driver not found‘); } } } ?>
工厂模式案例：
<?php interface IUser{ function getName(); } class User implements IUser{ public function __construct($id){} public function getName(){ return "haha"; } } class UserFactory{ public static function Create($id){ return new User($id); } } $uo =UserFactory::Create(1); echo $uo->getName(); ?>
单例
定义三要素：1，某个类只能有一个实例 2，必须自行创建这个实例 3，必须自行向系统提供这个实例
作用： 1，如果系统中需要有一个类来全局控制某些配置信息，那么使用单例模式可以很方便的实现。
2，使用单例模式，可以避免大量的new操作消耗资源（）
3在一个页面请求中，便于调试，因为所有的代码都集中在一个类中（如数据库操作类） 可以在类中设置钩子，输出日志，从而避免到处都是var_dump
单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。
单件模式是我们在开发中经常用到的一种设计模式，利用PHP5面向对象的特性，我们可以很容易的构建单件模式的应用，下面是单件模式在PHP中的几种实现方法：
class Stat{ static $instance = NULL; static function getInstance(){ if(self::$instance == NULL){ self::$instance = new Stat(); } return self::$instance; } private function __construct(){ } private function __clone(){ } function sayHi(){ return "The Class is saying hi to u "; } } echo Stat::getInstance()->sayHi();
这是一种最通常的方式，在一个getInstance方法中返回唯一的类实例。
对这里例子稍加修改，便可以产生一个通用的方法，只要叫道任何你想用到单件的类里，就可以了。
class Teacher{ function sayHi(){ return "The teacher smiling and said ‘Hello ‘"; } static function getInstance(){ static $instance; if(!isset($instance)){ $c = __CLASS__; $instance = new $c; } return $instance; } } echo Teacher::getInstance()->sayHi();
最后一种是提供一个singleton类，然后通过调用getInstance方法，可以为任何一个类生产出一个实例来。
class singleton{ function getInstance($class){ static $instances = array(); if(!array_key_exists($class,$instances)){ $instances[$class] = &new $class; } $instance = $instances[$class]; return $instance; } } class People{ function sayHi(){ return ‘Hello i am a people?‘; } } echo "<br />"; echo singleton::getInstance(‘People‘)->sayHi();
通过这三种方法，我们可以很容易的应用单件模式，如果能够结合工厂模式，将使我们的编程变得更有条理和效率。
---------------------------------------------------------------------------------------
PHP 类与对象 全解析（ 二)