《设计模式》之工厂模式（Factory）

仅供自己参考，因初次，有很多东西都只是我自己的理解，如想学习请找下一家。

1、简介

　　是一种创建型模式，他定义了创建对象的接口，Factory Method可以根据不同的条件产生不同的实例，他们属于相同的类型，共同的父类。工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

　　有简单工厂模式跟工厂方法模式。

2、自己的理解

　　将一个产品共有的部分定义为抽象类，然后通过一个工厂类来根据不同的条件产生不同的是实例。客户端类直接调用这个工厂类。这样就实现了客户端不直接操作这个产品类，实现低耦合。

3、盗过来的介绍

　　 FactoryMethod是一种创建性模式,它定义了一个创建对象的接口,但是却让子类来决定具体实例化哪一个类.当一个类无法预料要创建哪种类的对象或是一个类需要由子类来指定创建的对象时我们就需要用到Factory Method 模式了.简单说来,Factory Method可以根据不同的条件产生不同的实例,当然这些不同的实例通常是属于相同的类型,具有共同的父类.Factory Method把创建这些实例的具体过程封装起来了,简化了客户端的应用,也改善了程序的扩展性,使得将来可以做最小的改动就可以加入新的待创建的类. 通常我们将Factory Method作为一种标准的创建对象的方法,当发现需要更多的灵活性的时候,就开始考虑向其它创建型模式转化。

3、代码

　　（1）、简单工厂模式

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();  
    }  
}  

　　（2）、工厂方法模式

 

　　包名啥的。

　　抽象类（图形）

package com.hzj.product;

public abstract class Shape
{
    public String name;
    
    public Shape(String name)
    {
        this.name = name;
    }
    
    public abstract void draw();
    
    public abstract void clean();
}

　　具体类（正方形跟圆形）

　　正方形

package com.hzj.concretproduct;

import com.hzj.product.Shape;

public class Square extends Shape
{

    public Square(String name)
    {
        super(name);
    }

    @Override
    public void draw()
    {
        System.out.println("It will draw a Square");
    }

    @Override
    public void clean()
    {
        System.out.println("It will clean a Square");
    }
    
}

　　圆形

package com.hzj.concretproduct;

import com.hzj.product.Shape;

public class Circle extends Shape
{

    public Circle(String name)
    {
        super(name);
    }

    @Override
    public void draw()
    {
        System.out.println("It will draw a Circle");
    }

    @Override
    public void clean()
    {
        System.out.println("It will clean a Circle");
    }
    
}

　　抽象工厂方法类

package com.hzj.creator;

import com.hzj.product.Shape;

public abstract class ShapeFactory
{
    protected abstract Shape factoryMethod(String name);
    
    public void anOperation(String name)
    {
        Shape s = factoryMethod(name);
        System.out.println("The current shape is:"+s.name);
        s.draw();
        s.clean();
    }
}

　　具体工厂方法类

package com.hzj.concretecreator;

import com.hzj.concretproduct.Square;
import com.hzj.creator.ShapeFactory;
import com.hzj.product.Shape;

/**
 * 
 * ConcreteCreator: 具体的创建器,重写Creator中的Factory Method, 返回ConcreteProduct类型的实例.
 *
 * @author hzj
 */
public class SquareFactory extends ShapeFactory
{
    
    @Override
    protected Shape factoryMethod(String name)
    {
        
        return new Square(name+"(created by SquareFactory)");
    }
}


package com.hzj.concretecreator;

import com.hzj.concretproduct.Circle;
import com.hzj.creator.ShapeFactory;
import com.hzj.product.Shape;

public class CircleFactory extends ShapeFactory
{

    @Override
    protected Shape factoryMethod(String name)
    {
        return new Circle(name+"(created by CircleFactory)");
    }
    
}

　　客户端类

package com.hzj.client;

import com.hzj.concretecreator.CircleFactory;
import com.hzj.concretecreator.SquareFactory;
import com.hzj.creator.ShapeFactory;

public class MainClient
{
    public static void main(String[] args)
    {
        ShapeFactory s1 = new CircleFactory();
        ShapeFactory s2 = new SquareFactory();
        s1.anOperation("Shape--Circle");
        s2.anOperation("Shape--Square");
    }
}

　　运行结果：

　　是不是感觉没什么变化？是的，就是这么任性。虽然说结果没什么变化，但是这其中就有很大的玄机，使用了这个模式之后就客户端就不知道产品类具体是怎么实现了，它只能看到工厂给他的东西，这样大大的降低了耦合度。

　　看代码比看文字能更好的理解。

　　（4）、参考

　　http://blog.csdn.net/cjjky/article/details/7314118

　　http://blog.csdn.net/jason0539/article/details/23020989