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

Posted 2020-10-20 黑山大胖子

一、设计模式

　　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();    //输出

　　　输出结果　　　

 

 

二、设计六大原则

　　1.开-闭原则，讲的是设计要对扩展有好的支持，而对修改要严格限制。

　　2.里氏代还原则，子类必须能够替换基类，否则不应当设计为其子类。

　　3.依赖倒换原则，设计要依赖于抽象而不是具体化，换句话说就是设计的时候我们要用抽象来思考，而不是一上来就开始划分我需要哪些哪些类，因为这些是具体。

　　4.接口隔离原则，将大的接口打散成多个小接口

　　5.单一职责：一个类的功能尽量单一，降低耦合

　　6.迪米特法则（最少知识原则），一个对象应当对其他对象有尽可能少的了解，不和陌生人说话