Java 工厂模式

Java 工厂模式

　　工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

工厂模式定义

我们以类Sample为例， 如果我们要创建Sample的实例对象:

Sample sample=new Sample();

可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:

Sample sample=new Sample(参数);

　　但是，如果创建sample实例时所做的初始化工作不是像赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了。分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有悖于Java面向对象的原则，面向对象的封装(Encapsulation)和分(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间耦合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。

这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向借口编程,我们需要将Sample抽象成一个接口.Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:

ISample mysample=new MySample();
ISample hissample=new HisSample();

　　下面我给大家写一个简单的工厂模式的实例：

/**
 * 工厂模式
 * @author lihuadong
 */
interface ISample{
    //创建一个接口，并生成一个hello方法
    void hello();
}
class SampleA implements ISample{
    //SampleA是ISample的实现类，重写hello方法
    @Override
    public void hello() {
        // TODO Auto-generated method stub
        System.out.println("hello SampleA");
    }
    
}
class SampleB implements ISample{

    @Override
    public void hello() {
        // TODO Auto-generated method stub
        System.out.println("hello SampleB");
    }
    
}
/**
 * 构造ISample的工厂Factory
 * 并实现一个creater（int）方法用于获取ISample对象
 */
public class Factory {
    public static ISample creater(int which) {
        if(which == 1)
            return new SampleA();
        else if(which == 2)
            return new SampleB();
        return null;
    }
    public static void main(String[] args) {
        //测试：首先生成对象，然后调用hello（）方法
        ISample sampleA = Factory.creater(1);
        sampleA.hello();
        ISample sampleB = Factory.creater(2);
        sampleB.hello();
    }
}

测试结果：

hello SampleA
hello SampleB

　　这样,在整个就不涉及到ISample的具体的实现类,达到封装效果,也就减少错误修改的机会。使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的ISample类的接口,产品接口下有ISample接口的实现类,如SampleA,其次要有一个Factory类，用来生成产品ISample接口的具体实例。

抽象工厂模式

 

　　抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

　　提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。主要解决接口选择的问题

具体实现

　　我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。AbstractFactoryPatternDemo，我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（big / small / verylarge），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（red / black / white），以便获取它所需对象的类型。

package Factory;
/**
 * 
 * @author lihuadong
 * abstract factory
 */
/**
 *Step one 
 */
interface Shape{
    //定义shape接口
    void out();
}
interface Color{
    //定义color接口
    void out();
}
/**
 * Step two
 * 定义Shape的实现类--big,small,verylarge
 */
class Big implements Shape{

    @Override
    public void out() {
        // TODO Auto-generated method stub
        System.out.println("big");
    }
    
}
class Small implements Shape{

    @Override
    public void out() {
        // TODO Auto-generated method stub
        System.out.println("small");
    }
    
}
class VeryLarge implements Shape{

    @Override
    public void out() {
        // TODO Auto-generated method stub
        System.out.println("very large");
    }
    
}
/**
 * Step three
 * 定义Color的实现类--red,black,white
 */
class Red implements Color{

    @Override
    public void out() {
        // TODO Auto-generated method stub
        System.out.println("red");
    }
    
}
class Black implements Color{

    @Override
    public void out() {
        // TODO Auto-generated method stub
        System.out.println("black");
    }
    
}
class White implements Color{

    @Override
    public void out() {
        // TODO Auto-generated method stub
        System.out.println("white");
    }
    
}
/**
 * Step four
 * 为Color和Shape对象创建抽象类来获取工厂
 */
abstract class AbstractFactory{
    public abstract Shape getShape(String name);
    public abstract Color getColor(String name);
} 
/**
 * Step five
 * 创建扩展了AbstractFactory的工厂类，基于给定的信息生成实体类对象
 */
class ShapeFactory extends AbstractFactory{

    @Override
    public Shape getShape(String shapeType) {
        // TODO Auto-generated method stub
         if(shapeType == null){
             return null;
          }        
          if(shapeType.equalsIgnoreCase("big")){
             return new Big();
          } else if(shapeType.equalsIgnoreCase("small")){
             return new Small();
          } else if(shapeType.equalsIgnoreCase("verylarge")){
             return new VeryLarge();
          }
          return null;
    }

    @Override
    public Color getColor(String colorType) {
        // TODO Auto-generated method stub
        return null;
    }
    
}
class ColorFactory extends AbstractFactory{

    @Override
    public Shape getShape(String shapeType) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Color getColor(String colorType) {
        // TODO Auto-generated method stub
         if(colorType == null){
             return null;
          }        
          if(colorType.equalsIgnoreCase("red")){
             return new Red();
          } else if(colorType.equalsIgnoreCase("black")){
             return new Black();
          } else if(colorType.equalsIgnoreCase("white")){
             return new White();
          }
          return null;
    }
    
}
/**
 * Step six
 * 创造一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂
 */
class FactoryProducer{
    public static AbstractFactory getFactory(String choice) {
        if(choice.equalsIgnoreCase("shape")) {
            return new ShapeFactory();
        }else if(choice.equalsIgnoreCase("color")) {
            return new ColorFactory();
        }
        return null;
    }
}
/**
 * Step seven
 * 抽象工厂的测试
 */
public class Main {
    public static void main(String[] args) {
        
        //获取形状工厂
        AbstractFactory shapeFactory = FactoryProducer.getFactory("shape");
        //获取形状为big的对象
        Shape big = shapeFactory.getShape("big");
        //调用big对象的out方法
        big.out();
        
        //获取形状为small的对象
        Shape small = shapeFactory.getShape("small");
        //调用small对象的out方法
        small.out();
        
        //获取形状为verylarge的对象
        Shape verylarge = shapeFactory.getShape("verylarge");
        //调用verylarge对象的out方法
        verylarge.out();
        
        
        //获取颜色工厂
        AbstractFactory colorFactory = FactoryProducer.getFactory("color");
        //获取颜色为red的对象
        Color red = colorFactory.getColor("red");
        //调用red对象的out方法
        red.out();
        
        //获取颜色为black的对象
        Color black = colorFactory.getColor("black");
        //调用black对象的out方法
        black.out();
        
        //获取颜色为white的对象
        Color white = colorFactory.getColor("white");
        //调用white对象的out方法
        white.out();
        
    }
}

运行结果：

big
small
very large
red
black
white

　　通过上面的例子，我们可以充分的理解抽象工厂的运行步骤和机理。