面向对象的设计模式---工厂模式和单例模式

1.工厂模式：     

　　a.概述：     工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程（new 关键字和具体的构造器）隐藏起来。用一个工厂方法来替代，对外提供的只是一个工厂方法，达到提高灵活性的目的。 
     b.优点： 
           1.隐藏了new关键字和构造器 
           2.降低了这个对象与别的类之间的耦合度，提高了程序的可扩展性。 
             原因：当子类被别的类替代，或者构造器的参数发生变化的时候，只需改动工厂方法内的new即可，改动量降到了最低，而如果不用工厂模式，而是直接用new关键字的话，需要改动的地方就很多了 
           3.把对象的设计和实现分割开来，从而代码扩展性强、灵活性高。 
     c.工厂模式的使用范围： 
       当遇到下面的情况时，开发人员可以考虑采用工厂模式： 
       * 在编码时不能预见需要创建哪一个种类的实例。 
       * 一个类使用它的子类来创建对象。 
       * 开发人员不希望创建了那个类的实例以及如何创建实例的信息暴露给外部程序。 
      除了上面提到的例子，工厂模式的实现方式还允许有一些小小的变化，例如： 
       * 基类可以是一个抽象类，在这种情况下，工厂类必须返回一个非抽象类。 
       * 基类提供了一些缺省方法，只有当这些缺省方法不能满足特殊需求的情况下才能在子类中重写这些方法。 
       * 可以直接通过传递给工厂类的参数决定应该返回哪一个子类的实例。 
     d. 使用工厂模式，它的设计期于运行期的对象不同，这样就增强了代码的可扩展性。 
        它把构造器隐藏了起来，降低了代码的耦合度，增强了代码的复用性。 
        工厂模式与new的比较：如果使用new关键字的话，那么如果这个类的对象在很多的地方用到，必须要使用多次的new操作，这样容易引起代码的重复使用，如果需要改动或者替换成这个类的子类对象，那么，就需要把执行了new操作的所有地方都要改，比较麻烦。而工厂模式，因为它代替了构造器和new关键字，而且，它是使用面向接口的，所以，需要这个类的对象的时候，只需要调用这个方法就可以了，如果，需要改动或者替换成这个类的子类对象。只要修改这个工厂里面的内容，而其他的地方都不需要改动。 
          工厂模式的结构是：用一个方法来代替new关键字和构造器。 

 

工厂模式相当于创建实例对象的new，经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，工厂模式是现今最常用的模式，在Java程序系统中随处可见。

<?php
class YunSuan
{
	public $a;
	public $b;
	//写一个空方法，让子类继承重写父类
	public function Suan()
	{
		
	}
}

class Jia extends YunSuan
{
	public function Suan()
	{
		return $this->a+$this->b;	
	}	
}
//工厂模式
//工厂类：生产对象

class GongChang
{
	static function ShengChan($ysf)
	{
		switch($ysf)
		{
			case "+":
				return new Jia();
				break;
			case "-":
				return new Jian();
				break;
		}
			
	}
}
$jia = GongChang::ShengChan("+");
$jia->a = 10;
$jia->b = 10;
echo $jia->Suan();
//结果为20

　　

 2.  单例模式： 

  
   一、单例模式的四大特征： 
  懒汉式： 
        1。声明一个私有的，静态的本类对象，但并不在声明的时候就初始化，因此，它  的值为null。 
        2。私有化构造器 
        3。对外提供一个全局的，共有的，静态的，唯一的方法，用来获得该实例，但注意的是：必须要手动保持线程同步（synchronized） 
        4.在该方法里，判断对象是否为null，如果是null的话，表示这个类还没有被实例化，就会初始化这个对象，再返回如果不是null的话，就直接返回。 
  饿汉式： 
        1.声明一个私有的，静态的本类对象，并在声明的时候就初始化 
        2.私有构造器 
        3.对外提供一个全局的，共有的，静态的，唯一的方法，用来获得该实例（饿汉式线程本身就是同步的） 
        4.在该方法里，直接返回该对象即可 
    从资源利用效率角度来讲，这个比懒汉式单例类稍微差些。从速度和反应时间角度来讲，则比懒汉式单例类稍好些。 
    
     二、它能解决什么问题： 
      它确保一个类在java虚拟机里只有一个实例，使一个类只有一个对象，整个系统共享这个对象。 
     三、什么时候使用懒汉式和饿汉式： 
         1。 在使用的几率很少的情况下使用懒汉式。 --用的时候实例 
         2。 而使用的几率很高的话就用饿汉式。--一开始就初始化实例 
     四、单例模式的好处： 
         整个系统中的所有的类共用一个实例化对象，这样可以有效的节省资源。 

 

单例模式的目的是将类只能造一个对象出来

单例模式的主要方法是：将构造 变成私有的-->做一个静态的生成对象的方法-->造一个静态的存储对象-->return 静态的对象

<?php
class DBDA
{
	//连接数据库的类让他只能造一个对象出来，在不加任何控制的时候可以造很多的类出来
    //在造对象的时候会调用构造的方法，
    //把构造方法变成私有的就可以可以控制住
	public static $dx;//存储对象
	//把构造做为私有
	private function __construct()
	{
			
	}	
	//生成对象
	static function DuiXiang()
	{
		if(empty(self::$dx))
		{
			self::$dx = new DBDA();	//调用静态对象
		}
		return self::$dx;
	}
}
//DBDA::DuiXiang();//调用静态方法

$db = DBDA::DuiXiang();

　　

面向对象的设计原则：

OOD基本上有6大原则，而实际上都是互补的，也就是说一些原则需要利用另一些原则来实现自己。6大原则如下：

1) Open-Close Principle（OCP），开-闭原则，讲的是设计要对扩展有好的支持，而对修改要严格限制。这是最重要也是最为抽象的原则，基本上我们所说的Reusable Software既是基于此原则而开发的。其他的原则也是对它的实现提供了路径。

2) Liskov Substituition Principle（LSP），里氏代换原则，很严格的原则，规则是“子类必须能够替换基类，否则不应当设计为其子类。”也就是说，子类只能去扩展基类，而不是隐藏或覆盖基类。

3) Dependence Inversion Principle（DIP），依赖倒换原则，“设计要依赖于抽象而不是具体化”。换句话说就是设计的时候我们要用抽象来思考，而不是一上来就开始划分我需要哪些哪些类，因为这些是具体。这样做有什么好处呢？人的思维本身实际上就是很抽象的，我们分析问题的时候不是一下子就考虑到细节，而是很抽象的将整个问题都构思出来，所以面向抽象设计是符合人的思维的。另外这个原则会很好的支持OCP，面向抽象的设计使我们能够不必太多依赖于实现，这样扩展就成为了可能，这个原则也是另一篇文章《Design by Contract》的基石。

4) Interface Segregation Principle（ISP），接口隔离原则，“将大的接口打散成多个小接口”，这样做的好处很明显，我不知道有没有必要再继续描述了，为了节省篇幅，实际上我对这些原则只是做了一个小总结，如果有需要更深入了解的话推荐看《Java与模式》，MS MVP的一：本巨作！^_^

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

6) Law of Demeter or Least Knowlegde Principle（LoD or LKP），迪米特法则或最少知识原则，这个原则首次在Demeter系统中得到正式运用，所以定义为迪米特法则。它讲的是“一个对象应当尽可能少的去了解其他对象”。也就是又一个关于如何松耦合（Loosely-Coupled）的法则。

好了，以上是6大原则（或法则）的介绍，对这些原则的深入研究正是如何得到设计模式的道路。在进行了深入了解后我们就可以开始看看设计模式了，设计模式正是对这些法则的应用，著名的设计模式有四人帮（Gang of Four，GoF）的23个模式，除此之外还有很多其他的一些著名模式，大家可以慢慢研究，如果能自己产出一两个模式的话那就太好了，证明你也是高手了！^_^