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();   

通过这三种方法，我们可以很容易的应用单件模式，如果能够结合工厂模式，将使我们的编程变得更有条理和效率。
---------------------------------------------------------------------------------------