李华东 阅读(17) 评论(0)

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。然后创建一个工厂创造器/生成器类 FactoryProducerAbstractFactoryPatternDemo,我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shapebig / small / verylarge),以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Colorred / 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

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