转载请注明出处！！！http://blog.csdn.net/zhonghuan1992
所有配套代码均在github上：https://github.com/ZHONGHuanGit/DesignPattern



跟着ZHONGHuan学习设计模式
简单工厂
简介：
         从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
 
类图：
        
         从UML类图中，可以看出，简单工厂模式的意思，就是把一个类内部，需要生成的部分，提取出来，变为一个工厂，通过工厂来new对象。
         假设我们要吃苹果了，我们可以在代码中new一个苹果出来；当我们需要吃香蕉了，我们在代码中new一个香蕉出来。这种做法你会不会觉得麻烦，new的事情都要自己做。所以可以把new的事情交给一个工厂来做（顾名思义，工厂是生产东西的地方）。而简单工厂通过传进来的参数，决定生产什么产品。
言语表达不清，请看下面的代码：
 
代码：
当我们一开始没有使用简单工厂模式，可能，我们会这样做，看下面的代码

class apple{
         public apple(){
                   System.out.println("生产了一个苹果");
         }
}
 
class banana{
         public banana(){
                   System.out.println("生产了一个香蕉");
         }
}
 
public class Main{
         public static void main(String[] args){
                   applea=new apple();
                   bananab=new banana();
         }
}



我们需要什么，则自己在代码中new出来，这样有时候是很方便的，但有时候，我们想想这样的情况，代码比较复杂，我们希望很多事情不是交给主程序来做，而是把new这样的事情交给一个工厂来做，这样，在后面更改的时候，我就不用一个一个在主程序代码中去审查，而是在工厂代码中统一更改。
看简单工厂模式的代码：

class fruit{
        
}
class apple extends fruit{
         public apple(){
                   System.out.println("生产了一个苹果");
         }
}
 
class banana extends fruit{
         public banana(){
                   System.out.println("生产了一个香蕉");
         }
}
 
class Factory{
         //通过传进来的参数str，来决定生产什么产品
         public fruit create(String str){
                   if(str.equals("apple"))
                            return new apple();
                   if(str.equals("banana"))
                            return new banana();
                   return null;
         }
}
 
public class Main{
         public static void main(String[] args){
                   Factory fac=new Factory();
                   apple a=(apple)fac.create("apple");//传进apple，生产apple
                   banana b=(banana)fac.create("banana");
         }
}



希望上述代码能够表述清楚。
 
为什么要简单工厂模式？看下面简单工厂模式的优点：
         这个模式的核心是工厂，这个工厂类有自己的逻辑，就是他懂得根据传进来的参数决定创造什么样的产品，客户端（就是调用工厂类方法的）不用管创建对象的事情，仅仅是知道告诉工厂类，他要什么，然后得到什么。这样实现了创建对象责任的分割。
 
简单工厂模式的缺点：
         没有完美的东西嘛，而且简单工厂离完美还差得远呢！这个模式关键缺点就是，工厂类好像是一个上帝一样，创造了所有。从科学的角度上说，上帝是不存在的。所以，当所有的创造对象都放在一个工厂类的时候，可想而知，这个工厂类是多么的复杂。所以，当产品多的时候，慎重考虑是否使用该模式。
 
遵循的原则：
         讨论一下简单工厂遵循的原则，顺便回顾一下。
         比较明显的，简单工厂遵循了开闭原则。（对开闭原则忘了，请看这里http://blog.csdn.net/zhonghuan1992/article/details/37391441）设想一下，当我们需要新的产品的时候，比如客人想吃西瓜了（夏天嘛，吃西瓜解暑），该模式不用更改原来的代码，仅仅是写一个新的类继承自fruit，然后，共产类中增加代码。这样就是满足了对拓展开放，对修改关闭的开闭原则。
 
 
 
 
 

 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况,新对象的建立就是一个 “过程”，不仅是一个操作，像一部大机器中的一个齿轮传动。

 

模式的问题：你如何能轻松方便地构造对象实例，而不必关心构造对象实例的细节和复杂过程呢？

解决方案：建立一个工厂来创建对象

实现：

一、引言

    1）还没有工厂时代：假如还没有工业革命，如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车，然后拿来用。

    2）简单工厂模式：后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。

    3）工厂方法模式时代：为了满足客户，宝马车系列越来越多，如320i，523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。

   4）抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。

   最终是客户只要对宝马的销售员说：我要523i空调车，销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车.

   这就是工厂模式。

二、分类 

        工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 

工厂模式可以分为三类： 

1）简单工厂模式（Simple Factory） 

2）工厂方法模式（Factory Method） 

3）抽象工厂模式（Abstract Factory） 

 这三种模式从上到下逐步抽象，并且更具一般性。 

        GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。

        将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。 

三、区别 

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。   

一个抽象工厂类，可以派生出多个具体工厂类。   

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   

一个抽象工厂类，可以派生出多个具体工厂类。   

每个具体工厂类可以创建多个具体产品类的实例。   

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

两者皆可。 

 四、简单工厂模式 

建立一个工厂（一个函数或一个类方法）来制造新的对象。

分布说明引子：从无到有。客户自己创建宝马车，然后拿来用。

 

 

public class BMW320 {
	public BMW320(){
		System.out.println("制造-->BMW320");
	}
}

public class BMW523 {
	public BMW523(){
		System.out.println("制造-->BMW523");
	}
}

public class Customer {
	public static void main(String[] args) {
		BMW320 bmw320 = new BMW320();
		BMW523 bmw523 = new BMW523();
	}
}


客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.为了降低耦合,就出现了工厂类,把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了：简单工厂模式

即我们建立一个工厂类方法来制造新的对象。如图：



产品类：

abstract class BMW {
	public BMW(){
		
	}
}

public class BMW320 extends BMW {
	public BMW320() {
		System.out.println("制造-->BMW320");
	}
}
public class BMW523 extends BMW{
	public BMW523(){
		System.out.println("制造-->BMW523");
	}
}


工厂类：

public class Factory {
	public BMW createBMW(int type) {
		switch (type) {
		
		case 320:
			return new BMW320();

		case 523:
			return new BMW523();

		default:
			break;
		}
		return null;
	}
}



客户类：

public class Customer {
	public static void main(String[] args) {
		Factory factory = new Factory();
		BMW bmw320 = factory.createBMW(320);
		BMW bmw523 = factory.createBMW(523);
	}
}


   简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。 

      先来看看它的组成： 

         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品

         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。         

         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 

        

        下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当客户不再满足现有的车型号的时候，想要一种速度快的新型车，只要这种车符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createBMW(int type)方法需要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。 

        我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。

        于是工厂方法模式作为救世主出现了。 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。
五、工厂方法模式 

        工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 

工厂方法模式组成： 

       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 

       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 

       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 

       4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 

       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！ 

代码如下： 

产品类：

abstract class BMW {
	public BMW(){
		
	}
}
public class BMW320 extends BMW {
	public BMW320() {
		System.out.println("制造-->BMW320");
	}
}
public class BMW523 extends BMW{
	public BMW523(){
		System.out.println("制造-->BMW523");
	}
}



创建工厂类：

interface FactoryBMW {
	BMW createBMW();
}

public class FactoryBMW320 implements FactoryBMW{

	@Override
	public BMW320 createBMW() {

		return new BMW320();
	}

}
public class FactoryBMW523 implements FactoryBMW {
	@Override
	public BMW523 createBMW() {

		return new BMW523();
	}
}




客户类：

public class Customer {
	public static void main(String[] args) {
		FactoryBMW320 factoryBMW320 = new FactoryBMW320();
		BMW320 bmw320 = factoryBMW320.createBMW();

		FactoryBMW523 factoryBMW523 = new FactoryBMW523();
		BMW523 bmw523 = factoryBMW523.createBMW();
	}
}



 工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。

参考http://blog.csdn.net/hguisu/article/details/7505909

 

以上就是简单工厂模式，工厂方法模式，抽象工厂模式在这里。

 

更多设计模式：23种设计模式系列



作者：jason0539

博客：http://blog.csdn.net/jason0539（转载请说明出处）

 

1 简单工厂

根据参数由工厂类来创建对象

/**
 * 简单工厂
 * 目的：根据参数获取对象
 * 缺点：新增实现类时，需要修改代码，不好动态扩展（可参考工厂方法）
 */
public class SimpleFactoryDP {

    public final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
    }

    //抽象产品
    public interface Product {
        void show();
    }

    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }

    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    public static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }

    void test(){
        Product product = SimpleFactory.makeProduct(1);
        product.show();
    }

}


2 工厂方法

解决简单工厂不能动态扩展实现类（开闭原则）

/**
 *  工厂方法
 *  单个工厂提供单个实现类，方便扩展更多实现类
 *  目的：优化简单工厂不好扩展新的类。这里只需要新增工厂类既能扩展
 *  缺点：有时需要工厂类能够同时提供多个不同对象（可参考抽象工厂）
 */
public class FactoryMethodDP {
    //抽象产品：提供了产品的接口
    interface Product {
        public void show();
    }
    //具体产品1：实现抽象产品中的抽象方法
    class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }
    //具体产品2：实现抽象产品中的抽象方法
    class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    //抽象工厂：提供了厂品的生成方法
    interface AbstractFactory {
        public Product newProduct();
    }
    //具体工厂1：实现了厂品的生成方法
    class ConcreteFactory1 implements AbstractFactory {
        public Product newProduct() {
            System.out.println("具体工厂1生成-->具体产品1...");
            return new ConcreteProduct1();
        }
    }
    //具体工厂2：实现了厂品的生成方法
    class ConcreteFactory2 implements AbstractFactory {
        public Product newProduct() {
            System.out.println("具体工厂2生成-->具体产品2...");
            return new ConcreteProduct2();
        }
    }

    void test() {
        AbstractFactory abstractFactory = new  ConcreteFactory1();
        abstractFactory.newProduct().show();
    }


}


3 抽象工厂

解决工厂方法 单个工厂不能同时创建多个不同的实现类

/**
 * 抽象工厂
 * 工厂可以产生多个不同对象，实现对象可以扩展，工厂类也可以动态组装
 */
public class AbstractFactoryDP {

    interface ProductA{
        void aEat();
    }
    class Aimpl1 implements ProductA{
        @Override
        public void aEat() {
            System.out.println("class is Aimpl1");
        }
    }
    class Aimpl2 implements ProductA{
        @Override
        public void aEat() {
            System.out.println("class is Aimpl2");
        }
    }

    interface ProductB{
        void bUse();
    }
    class Bimpl1 implements ProductB{
        @Override
        public void bUse() {
            System.out.println("class is Bimpl1");
        }
    }
    class Bimpl2 implements ProductB{
        @Override
        public void bUse() {
            System.out.println("class is Bimpl2");
        }
    }

    interface AbstractProductFactory{
        ProductA createA();
        ProductB createB();
    }

    class ProductFactoryImplA implements  AbstractProductFactory{
        @Override
        public ProductA createA() {
            return new Aimpl1();
        }
        @Override
        public ProductB createB() {
            return new Bimpl1();
        }
    }

    class ProductFactoryImplB implements  AbstractProductFactory{
        @Override
        public ProductA createA() {
            return new Aimpl2();
        }
        @Override
        public ProductB createB() {
            return new Bimpl2();
        }
    }

    void test(){
        AbstractProductFactory productFactory = new ProductFactoryImplA();
        ProductA productA = productFactory.createA();
        productA.aEat();
        ProductB productB = productFactory.createB();
        productB.bUse();
    }

}


 

大话设计模式(一)简单工厂模式

      今天主要讲解简单工厂模式即静态工厂设计模式。

      其中，简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

简单工厂模式

包含的角色及其职责

      1.工厂（Creator）角色 简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

      2.抽象（Product）角色 简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

      3.具体产品（Concrete Product）角色 简单工厂模式所创建的具体实例对象。

UML图



优缺点

           简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。违背了OCP(开放-封闭原则，即对扩展开放，对修改封闭。开放-封闭原则是面向对象设计的核心所在。遵循这个原则可以提升软件的可维护、可扩展、可复用、灵活性好。) 在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。

            不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。 示例图如图1-1所示：



示例代码


package cn.edu.ujn.designpattern;

interface Fruit{
	// 种植 
	public void plant();
	// 生长 
	public void grow();
	// 收获 
	public void harvest();
}

class Apple implements Fruit{

	@Override
	public void grow() {
		System.out.println("Apple is growing.");
	}

	@Override
	public void harvest() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void plant() {
		// TODO Auto-generated method stub
		
	}
	
}

class Strawberry implements Fruit{

	@Override
	public void grow() {
		System.out.println("Strawberry is growing.");
	}

	@Override
	public void harvest() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void plant() {
		// TODO Auto-generated method stub
		
	}
	
}

class FruitFactory{
	public static Fruit creatFruit(String fruitName){
		Fruit fruit = null;
		switch (fruitName) {
		case "apple":
			fruit = new Apple();
			break;
		case "strawberry":
			fruit = new Strawberry();
			break;
		default:
			break;
		}
		return fruit;
	}
}

public class SimpleFactory {

	public static void main(String[] args) {
		Fruit fruit = FruitFactory.creatFruit("apple");
		fruit.grow();
	}

}



参考资料

1.http://www.cnblogs.com/zhouqiang/archive/2012/07/20/2601365.html

2.http://www.cnblogs.com/forlina/archive/2011/06/21/2086114.html

美文美图