1.判断代码的好处就是高内聚低耦合
高内聚就是软件模块是由相关性很强的代码组成,只负责一项任务,也就是常说的单一责任原则。
低耦合就是每个模块之间耦合度要低,如果要修改,修改一点点就可以而不是修改一大部分。
而在代码中体现出来的设计模式就是依赖注入和控制反转
2.依赖注入:
就是A类所依赖的B类C类等以属性或者构造函数等方式注入A类而不是直接在A类中实例化。
例如:
class A
{
public $b;
public $c;
public function __construct()
{
//TODO
}
public function method()
{
$this->b=new B();
$this->c=new C();
$this->b->method();
$this->c->method();
//TODO
}
}
class B
{
public function __construct()
{
//TODO
}
public function method()
{
//TODO
echo 'b';
}
}
class C
{
public function __construct()
{
//TODO
}
public function method()
{
//TODO
echo 'c';
}
}
$a=new A();
$a->method();
上面中A类中依赖了B和C类,如果后期开发中涉及函数改名,就会牵动到a类的整个都需要修改。有没有方法真的修改了B和C类,尽量也不要去改动A呢?这里要用到控制反转,就是现在是b和c控制着a,我们要反转过来,a这边可以主动控制,不管b和c改成什么。控制反转(IOC)是一种思想,依赖注入(ID)是实施这种思想的方法。
第一种方法:构造器注入(不推荐使用,但比不用好)
class A{
public $b;
public $c;
public function __construct($b,$c){
$this->b=$b;
$this-<c=$c;
}
public function method(){
$this->b->method();
$this->c->method();
}
}
这样调用
$a = new A(new B(),new C());
$a->method();
第二种方法:工厂模式注入
class Factory
{
public function Factory()
{
//TODO
}
public function create($s)
{
switch($s)
{
case 'B':
{
return new B();
break;
}
case 'C':
{
return new C();
break;
}
default:
{
return null;
break;
}
}
}
}
然后把A类改成这样
class A
{
public $b;
public $c;
public function __construct()
{
//TODO
}
public function method()
{
$f=new Factory();
$this->b=$f->create('B');
$this->c=$f->create('C');
$this->b->method();
$this->c->method();
//TODO
}
}
这样至少如果B和C类的构造函数发生变化,比如修改参数时,只需要修改Factory类就可以了。
把B类和C类的方法再抽象出来,做一个接口.
这样,A类中的b变量和c变量就不再是一个具体的变量了,而是一个抽象类型的变量,不到运行那一刻,不知道他们的Method方式是怎么实现的。
interface IMethod
{
public function method();
}
class B implements IMethod
{
public function __construct()
{
//TODO
}
public function method()
{
//TODO
echo 'b';
}
}
class C implements IMethod
{
public function __construct()
{
//TODO
}
public function method()
{
//TODO
echo 'c';
}
}
总结:
1.我们把A类中的B类对象和C类对象的创建移至A类外
2.原本A类依赖B类和C类,现在变成了A依赖Factory,Factory依赖B和C。