设计模式----创建型模式之工厂模式(FactoryPattern)

  工厂模式主要分为三种简单工厂模式、工厂方法模式、抽象工厂模式三种。顾名思义,工厂主要是生产产品,作为顾客或者商家,我们不考虑工厂内部是怎么一个流程,我们要的是最终产品。将该种思路放在我们面向对象开发实战中,就能使我们代码达到解耦。

  首先,在引出这三种关于工厂模式,我们介绍几组对象:

  1、抽象产品。所谓抽象产品,是具体抽象的抽象形式。例如:披萨、原料、汽车等(注:披萨和原料引自head first设计模式一书)。

  2、具体产品。抽象产品的具体化。蛤蜊披萨和素食披萨等就是抽象产品的具体化产品,面团、酱料和芝士等就是原料的具体化产品,但是会因为地域性差异,同一种产品是有所区别的。

  3、工厂。客户使用工厂对象方法获取到具体产品。

  • 简单工厂模式(Simple Factory Pattern)

   UML结构图如下所示:

   

 

  从UML结构图可以看出(注:简单工厂模式又称静态工厂模式):

  1. 工厂与抽象产品的关系是组合关系;
  2. 工厂类通过createProduct()方法创建产品,该方法内部根据形参;
  3. 作为Client,只需要通过实例化Factory调用creatProduct(){若该方法为非静态方法,若静态方法直接调用,不需要实例}获取相应的具体产品实例。

   简单工厂模式遵循着“封装变化”原则。客户后续需要更多种类的产品,只需要修改工厂类及新增具体产品类即可,从而产品的使用和产生的隔离。

  简单实例:

public abstract class Product {

}

public class ProductA extends Product{
    public String toString() {
        return "I am Product A";
    }
}

public class ProductB extends Product{
    public String toString() {
        return "I am Product B";
    }
}

public class SimpleFactory {
    Product product;
    public Product createProduct(int param){
        switch (param) {
        case 1: 
            product =new ProductA();
            break;
        case 2:
            product =new ProductB();
            break;
        default:
            break;
        }
        return product;
    }
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product proA = factory.createProduct(1);
        System.out.println(proA);
        Product proB = factory.createProduct(2);
        System.out.println(proB);
    }
       /**     输出:
     *   I am Product A
     *   I am Product B
     * 
     */
}
View Code
  • 工厂方法模式(Factory Method Pattern

  简单工厂模式自身存在缺点,主要实现的目的是把变化部分出去出来,便于我们修改。但是这样对于新增产品,我们就得就修改工厂类,这样一来就已经不遵循“开-闭”原则{对修改关闭,对扩展开放}。

  因此,我们引入工厂方法模式

    定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。

  UML结构图如下所示:

  

  利用工厂方法模式生产产品A或产品B,代码如下所示: 

//所有具体工厂的抽象工厂
public abstract class Factory {
    public abstract Product createProduct();
}
//生产A的具体工厂
public class ProductFactoryA extends Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

//生产B的具体工厂
public class ProductFactoryB extends Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factory = new ProductFactoryA();
        Product proA = factory.createProduct();
        System.out.println(proA);
        Factory factory2 = new ProductFactoryB();
        Product proB = factory2.createProduct();
        System.out.println(proB);
        /**
         * 输出:
         * I am Product A
         * I am Product B
         */
    }
}
View Code
  • 抽象工厂模式(Abstract Factory Pattern

   抽象工厂模式提供一个接口,用于创建相关或依赖的家族,而不需要明确指定具体类。

  UML结构图如下图所示(参照于head first设计模式一书):

  抽象工厂方法其实就是工厂方法的一种升华:1、从客户的角度来看,只需要关注抽象工厂和抽象产品,不需要关注具体的产品和具体的工厂类实现。2、从抽象工厂的角度来看,不需要关注具体的工厂实现,也不需要关注生产产品,生产产品的都是派生类来实现。3、从具体工厂的角度来看,生产的产品有一定的共性,不需要关注具体产品的实现。。。这些都可以从类图里面看出来。通过类图,我们发现:工厂抽象和产品抽象是隔离的。

  觉得《Head First 设计模式》书中的例子才是经典的,就不给出源码,想看的只能找度娘了。

  • 总结

  1、所谓工厂,都是用来封装对象的创建;

  2、简单工厂实现将客户程序从具体类中解耦。但如果扩展产品,只能在工厂类里面修改,对于后期的维护以及扩展增加了困难;

  3、工厂方法使用了继承,把对象创建委托给子类,子类实现工厂方法来创建对象;

  。。。。

  这两个月工作有点忙,顺便学习了原始的servlet,设计模式看得比较少。共勉

  

 

posted on 2017-05-05 16:20  轻浅初夏  阅读(173)  评论(0编辑  收藏  举报

导航