PHP面向对象设计模式和设计原则

时间：2018-01-11 16:16:15 阅读：152 评论：0 收藏：0 [点我收藏+]

一、设计模式

　　1.单例模式

　　　　目的：让一个类只能生成一个对象

　　　　步骤： ①将构造函数变成私有的

　　　　　　　　②在类里面做一个静态成员函数造对象

　　　　　　　　③在方法里加限制条件

    //单例模式
    class Ren{                //定义人类
        public static $r;    //设定静态成员变量，为了可以带入静态成员函数中
        public $name;        //普通成员变量，用于测试是否只实例化了一个对象
        private function __construct(){        //私有化构造函数，阻止实例化对象
                
        }
        public static function duixiang(){    //创建一个静态成员函数，用于访问构造函数以实例化对象
            if(empty(self::$r)){            //设定限制条件
                self::$r = new Ren();
            }
            return self::$r;                //返回$r中的唯一的实例化对象
        }
    }
    
    $r = Ren::duixiang();    //访问静态函数实例化对象
    $r->name = "张三";        //给对象的$name赋值"张三"
    $r1 = Ren::duixiang();    //测试是否只有一个对象
    var_dump($r1);

　　　　只有一个对象

　　　　技术分享图片

　　工厂模式

　　　　目的：做一个专门造对象的工厂

　　　　　　如果一个父类的子类量比较庞大，子类名命名方式不一致，可以用这种模式以代号方式造对象

    //工厂模式
    class Jisuan{        //定义一个计算父类
        public $a;        //两个普通成员变量
        public $b;        
        public function Js(){    //定义一个计算的普通成员函数
            echo"计算结果为";    
        }
        public function __construct($a,$b){    //构造函数，用于实例化对象时设定初始的$a和$b的值
            $this->a = $a;
            $this->b = $b;    
        }    
    }
    class Jia extends Jisuan{    //子类加法
        public function Js(){    //子类重写的计算函数
            parent::Js();
            return($this->a+$this->b);    
        }    
    }
    class Jian extends Jisuan{    //子类减法
        public function Js(){    //子类重写的计算函数    
            parent::Js();
            return($this->a-$this->b);    
        }    
    }
    class Cheng extends Jisuan{    //子类乘法
        public function Js(){    //子类重写的计算函数
            parent::Js();
            return($this->a*$this->b);    
        }    
    }
    class Chu extends Jisuan{    //子类除法
        public function Js(){    //子类重写的计算函数
            parent::Js();
            return($this->a/$this->b);    
        }    
    }
    class Quyu extends Jisuan{    //子类取余
        public function Js(){    //子类重写的计算函数
            parent::Js();
            return($this->a%$this->b);    
        }    
    }
    
    class GongChang{        //定义一个工厂类，用于生产实例化对象
        public static function duixiang($a,$b,$ysf){    //设置静态成员函数并传入参数，以运算符号代替子类的名称
            switch($ysf){        //分支较多，用switch case 语句设计不同运算符号所对应不同的子类并实例化对象
                case "+";
                    return new Jia($a,$b);
                    break;    
            
                case "-";
                    return new Jian($a,$b);
                    break;    
            
                case "*";
                    return new Cheng($a,$b);
                    break;    
            
                case "/";
                    return new Chu($a,$b);
                    break;    
            
                case "%";
                    return new Quyu($a,$b);
                    break;    
            }
        }    
    }
    $j = GongChang::duixiang(3,2,"%");    //测试
    echo $j->Js();    //输出