编程思想之设计模式（一）

Factory Method模式

1、模式简介

设计模式的简单定义就是对于一类重复出现的问题的可重用的解决方案。在软件工程中一个设计模式解决一类软件设计问题。

在《设计模式》一书中涉及到23个模式，被分类为创建型模式(Creational Patterns)，结构型模式(Structural Patterns)和行为模式(Behavioral Patterns)，分别从对象的创建，对象和对象间的结构组合以及对象交互这三个方面为面向对象系统建模方法给予了解析和指导。

其中创建型设计模式(Creational Patterns)描述怎样创建一个对象。它隐藏对象创建的细节，使程序代码不依赖具体的对象，这样当我们增加一个新的对象时几乎不需要修改代码。结构型设计模式(Structural Patterns)描述类和对象之间怎么组织起来形成大的结构，主要使用继承来组织接口或实现。行为型设计模式(Behavioral Patterns)描述算法以及对象之间的任务分配，它所描述的不仅仅是对象或类的设计模式，还有它们之间的通讯模式。

2、设计模式之Factory Method

此模式属于创建型设计模式，它只定义创建对象的接口，而由它的子类负责创建具体的对象,利用子类实例化不同的对象。图一是Factory Method 模式结构的类图(Class Diagram),其中:

1. Product 定义了由factory method所创建对象的统一接口.

{见下面的Shape.java文件}

1. ConcreteProduct 具体的类，实现Product接口。

{见下面的Square.java文件，它实现了一个具体的类}

1. Creator 一般为抽象类，声明若干factory method（方法）,由它创建类型为Product的对象。正因为它能"生产"对象，所以称为factory method。Creator也可能拥有一个方法创建某个缺省的具体对象。[工厂类生产对象用的]

{见下面的ShapeFactory.java类}

1. ConcreteCreator 重载factory method以创建某个 ConcreteProduct 的具体实例.

{见下面的SquareFactory.java类 表示创建具体的一个类}

也就是说Creator依赖于ConcreteCreator创建Product型的ConcreteProduct对象。 Factory method使应用程序代码只需处理Product接口，而与具体的类（ConcreteProduct）无关，增强了代码可重用性，因为它独立于用户定义的具体的类。

3、一个JAVA实例

1.a 首先定义一个抽象类Shape,定义两个抽象的方法.

public abstract class Shape {
    public String name;
    public Shape(String aName) {
        name = aName;
    }
    public abstract void draw();
    public abstract void erase();
}

1.b 定义 Shape的两个子类: Circle, Square,实现Shape中定义的抽象方法

public class Circle extends Shape{

    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("It will draw a circle.");
    }

    @Override
    public void erase() {
        // TODO Auto-generated method stub
        System.out.println("It will erase a circle.");
    }
    public Circle(String name){
        super(name);
    }
}

public class Square extends Shape{

@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println("It will draw a Square.");
}

@Override
public void erase() {
// TODO Auto-generated method stub
System.out.println("It will erase a Square.");
}
public Square(String aName){
super(aName);
}
}

1.c 定义抽象的创建器,anOperation调用factoryMethod创建一个对象,并对该对象进行一系列操作.

public abstract class ShapeFactory {
//这就是为什么叫做ShapeFactory了。因为它不关心具体的实现的。只关心 [接口/抽象类]
    protected abstract Shape factoryMethod(String aName);
    //在anOperation定义Shape的一系列行为
    public void anOperation(String aName) {
        Shape s = factoryMethod(aName);
//创建一个接口对象。子类想怎么实现就怎么实现
        System.out.println("The current shape is: " + s.name);
        s.draw();
        s.erase();
    }
}

1.d 定义与circle和square相对应的两个具体创建器CircleFactory,SquareFactory,实现父类的methodFactory方法

public class CircleFactory extends ShapeFactory {

    @Override
    protected Shape factoryMethod(String aName) {
        // TODO Auto-generated method stub
        return new Circle(aName + "(created by CircleFactory)");
    }
}

public class SquareFactory extends ShapeFactory {

    @Override
    protected Shape factoryMethod(String aName) {
        // TODO Auto-generated method stub
        return new Square(aName + " (created by SquareFactory)");
    }
}

1.e 测试类:请注意这个客户端程序多么简洁,既没有罗嗦的条件判断语句,也无需关心ConcreteProduct和ConcreteCreator的细节(因为这里我用anOperation封装了Product里的两个方法,所以连Product的影子也没看见,当然把Product里方法的具体调用放到客户程序中也是不错的).

public class Test {
    public static void main(String[] args) {
        ShapeFactory sf1 = new SquareFactory();
        ShapeFactory sf2 = new CircleFactory();
        sf1.anOperation("Shape one");
        sf2.anOperation("Shape two");
    }
}

运行结果如下：

The current shape is: Shape one (created by SquareFactory)

It will draw a Square.

It will erase a Square.

The current shape is: Shape two(created by CircleFactory)

It will draw a circle.

It will erase a circle.

换一种实现方式如下：

参数化的Factory Method: 这种方式依靠指定的参数作为标志来创建对应的实例,这是很常见的一种办法，参数化的创建方式克服了Factory Method模式一个最显著的缺陷,就是当具体产品比较多时,我们不得不也建立一系列与之对应的具体构造器. 但是在客户端我们必须指定参数来决定要创建哪一个类.

2.a 我们在第一种方法的基础上进行修改,首先自定义一个的异常,这样当传入不正确的参数时可以得到更明显的报错信息.

public class NoThisShape extends Exception {
    private static final long serialVersionUID = 1L;

    public NoThisShape(String aName) {
        super(aName);
    }
}

2.b去掉了ShapeFactory的两个子类,改为由ShapeFactory直接负责实例的创建. ShapeFactory自己变成一个具体的创建器,直接用参数化的方法实现factoryMethod返回多种对象.

public abstract class ShapeFactory {
    private static Shape s;
    private ShapeFactory(){}

    static Shape factoryMethod(String aName,String aType) throws NoThisShape {
        if (aType.compareTo("square") == 0) {
            return new Square(aName);
        } else if (aType.compareTo("circle") == 0) {
            return new Circle(aName);
        } else {
            throw new NoThisShape(aType);
        }
    }

    static void anOperation(String aName,String aType) throws NoThisShape {
        s = factoryMethod(aName, aType);
        s.draw();
        s.erase();
    }
}

2.c 测试类:这里客户端必须指定参数来决定具体创建哪个类.这个例子里的anOperation是静态函数,可以直接引用.

public class Test {
    public static void main(String[] args)  throws NoThisShape{
        ShapeFactory.anOperation("Shape one","circle");
        ShapeFactory.anOperation("Shape two","square");
        ShapeFactory.anOperation("Shape three", "delta");
    }
}

运行输出：

It will draw a circle.

Exception in thread "main" com.design.factory.NoThisShape: delta

at com.design.factory.ShapeFactory.factoryMethod(ShapeFactory.java:13)

at com.design.factory.ShapeFactory.anOperation(ShapeFactory.java:18)

at com.design.factory.Test.main(Test.java:7)

It will erase a circle.

It will draw a Square.

It will erase a Square.