设计模式
设计模式的理解
研读GOF的\设计模式\和阎宏博士的\与模式\已经有一段时间，自己颇有一些体会，自己面向对象和软件设计模式有了一些深入的理解，下面就一步一步开始自己的模式历程吧，从最简单的工厂模式到适配器模式，从 State模式到Decorator模式，一直到最复杂难懂的visitor模式，没有一个模式不体现了前辈的聪明才智，需要我们大家用心去体会和理解
恰当地使用设计模式，能使软件系统的架构更合理，能使将来的维护和修改更方便，能使数据库表结构的设计更合理，恰当的冗余和数据关联，能使我们的软件更多地适应变化，总之，它的的作用是不可低估的！
1，简单工厂，工厂方法和抽象工厂模式
对于简单工厂来说，它的工厂只能是这个样子的 public class SimplyFactory { /**
* 静态工厂方法 */
public static Prouct factory(String which) throw NoSuchProductExcption {
if(which.equalIgnoreCase(\ {
return new Product1(); }
else if(which.equalsIgnoreCase(\ {
return new Product2(); }
else if(which.equalsIgnoreCase(\ {
return new Product3(); }
else throw NoSuchProductExcption(\ } } }
而对产品Product1,Product2,Product3,可以执行接口Product,也可以不执行接口Product（当然这样不好），这个Product接口只是用来抽象具体product用的
public interface Product {
1
设计模式
void productMethod1(); //这些只是 void productMethod2(); void productMethod3(); }
对工厂来说，只要有这么一种产品，一般来说就要在工厂里有它的生产的方法， 否则抛出异常，而要工厂生产的话，也必须下达生产什么产品的命令，至少要向工厂发出信号，让工厂足以区分是要生产什么产品，否则工厂是不知道生产哪一种产品，
对于简单工厂来说，就是需要在工厂中枚举所有的产品，所以说简单工厂还是非常笨的。
if(which.equalIgnoreCase(\ 只是用来区分生产什么产品的标记值，（也可以根据产品其它属性来判断，比如产品类型，产品大小，总之能够区分是什么产品的属性，或者是与产品属性相关的变量） 或者说标记值是A,生产A产品，或者工厂里定义不是这样的，我偏偏要生产B产品，或者再特殊一些，我偏偏要生产A产品+B产品，那么就要return new ProductA()+new ProductB()了。
这样，我们就可以看出一个问题来，如果要能够被简单工厂生产出来，就必须在简单工厂中有能够生产出的它的方法定义，当然还需要有这个具体产品类的定义，就是有class对应，这样确保在简单工厂中new 它的时候不会抛出 NoSuchProduct的Exception.
对于工厂方法来说
实质上它是让工厂实现了抽象的工厂接口，它把具体怎么生产一种东西，放在具体的工厂去实现了，所谓”延迟到子类中实现“ public interface Creator {
public Prouct factory(); }
public SubCreator1 implent Creator {
public Prouct factory() {
return new ConcreteProduct1(); } }
public SubCreator2 implent Creator {
public Prouct factory()
2
设计模式
{
return new ConcreteProduct2(); } }
请注意：返回类型是Product型的！！
这样客户端调用是直接new 一个具体工厂的实例，然后命令它去生产，而对于具体工厂的父类（既工厂接口，接口完全可以改成子类继承父类来实现，只是这样不好，不符合OO的原则），它完全不知道什么产品被生产了，甚至它连那个具体工厂被实例化它都不知道
抽象工厂模式
抽象工厂模式主要是用来解决具体产品是有几类产品簇的问题
public interface Creator {
public ProuctA factoryA(); public ProuctB factoryB(); }
public interface ProductA //ProductA 接口 { }
public interface ProductB //ProductB 接口 { }
public class ConCreator1 implements Creator {
public ProuctA factoryA() {
return new ConcreteProductA1(); }
public ProuctB factoryB() {
return new ConcreteProductB1(); } }
public class ConCreator2 implements Creator {
public ProuctA factoryA()
3
设计模式
{
return new ProductA2(); }
public ProuctB factoryB() {
return new ProductB2(); } }
public class ProductA1 implements ProductA {
public ProductA1() { } }
public class ProductA2 implements ProductA {
public ProductA2() { } }
public class ProductB1 implements ProductB {
public ProductB1() { } }
public class ProductB2 implements ProductB {
public ProductB2() { } }
实际上是这样的
1，两个工厂类ConCreator1，ConCreator2都实现了Creator接口 2，ProuctA1,ProductA2都实现了ProductA接口 3，ProuctB1,ProductB2都实现了ProductB接口
4，ConCreator1负责生产1类型的产品(包括ProductA1，ProductB1) 5，ConCreator2负责生产2类型的产品(包括ProductA2，ProductB2)
6，工厂方法也有这样的特征，也就是说Creator不知道什么被生产出来，甚至不知道ConCreator1还是ConCreator2被实例化了，因为client高兴调那一个工厂，就调那一个工厂，就是说工厂能生产什么，对客户端是可见的。甚至还有一种情
4
设计模式
况，客户端高兴起来就生产了ProductA1,我就不生产ProductA2,因为上面的例子中它们还都是松散的，没有绑定在一起
于是提出另外一个例子，也是老提起的电脑类型的例子
1，电脑生产商是接口， 2，CUP是接口， 3，硬盘是接口，
4，IBM工厂是制造IBM品牌的电脑的工厂 5，DELL工厂是制造DEll品牌的电脑的工厂 为讨论方便，就认为电脑=CUP+硬盘；
6，所以呀CUP有IBM的CPU和DELL的CPU 7，同样硬盘也是有IBM的硬盘和DELL的硬盘
8，IBM工厂生产IBM的CPU和IBM的硬盘，绝对不生产DELL的CPU，也不生产DELL的硬盘
9，同样DELL工厂也是一样
public interface 电脑生产商 {
public CPU 制造CPU(); public 硬盘 制造硬盘(); public 电脑 制造电脑(); }
public interface CPU { }
public interface 硬盘 { }
public class IBM的CPU implements CPU {
public IBM的CPU(); }
public class IBM的硬盘 implements 硬盘 {
public IBM的硬盘();
5
设计模式
}
public class DELL的CPU implements CPU {