Java设计模式之工厂模式

内容整理自《大话设计模式》

 

1.简单工厂模式

属于创建型模式，又叫做静态工厂方法模式，不属于23种GOF设计模式之一。是由一个工厂对象决定创建出哪一种产品类的实例。实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

作用：将“类实例化的操作”与“使用对象的操作”分开，让使用者不用知道具体参数就可以实例化出所需要的“产品”类，从而避免了在客户端代码中显式指定，实现了解耦。

优点：将创建使用工作分开，不必关心类对象如何创建，实现了解耦；
缺点：违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。

public interface Resaurant {

    void cook();}



public class Duck implements Resaurant{

    public void cook() {

        System.out.println("来一份烤鸭");

    }}



public class Fish implements Resaurant{

    public void cook() {

        System.out.println("来一份红烧鱼");

    }}



public class Meet implements Resaurant {

    public void cook() {

        System.out.println("来一份回锅肉");

    }}

public class Wait {

    public static final int MEAN_MEET = 1;

    public static final int MEAN_FISH = 2;

    public static final int MEAN_DUCK = 3;



    public static Resaurant getMean(int meantype){

        switch (meantype){

            case MEAN_MEET :

                return new Meet();

            case MEAN_FISH :

                return new Fish();

            case MEAN_DUCK :

                return new Duck();

            default:

                return null;

        }

    }}



public class Factory {

    public static void main(String[] args) {

        //简单工厂模式

        Resaurant resaurant = Wait.getMean(Wait.MEAN_DUCK);

        resaurant.cook();

    }}

2.工厂方法模式

又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。一种常用的对象创建型设计模式,此模式的核心精神是封装 类中不变的部分。

工厂方法模式（Factory Method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

 

public abstract class CookFactory {

    public abstract Resaurant createRestaurant();}



public class DuckFactory extends CookFactory {

    @Override

    public Resaurant createRestaurant() {

        return new Duck();

    }}



public class FishFactory extends CookFactory {

    public Resaurant createRestaurant() {

        return new Fish();

    }}



public class Cook {

    //工厂方法模式

    public static void main(String[] args) {

        Resaurant duck = new DuckFactory().createRestaurant();

        duck.cook();

        Resaurant fish = new FishFactory().createRestaurant();

        fish.cook();

    }}

 

3.抽象工厂模式

定义：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。
解决的问题：每个工厂只能创建一类产品（工厂方法模式）

抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个工厂可以创建多种类的产品；而工厂方法每个工厂只能创建一类

/**

 * @ Product.java

 * 抽象产品族 (食品)

 */abstract class Product {

    //产品介绍

    abstract void intro();}

/**

 * @ ProductA.java

 * 抽象产品  (饮料)

 */abstract class ProductA extends Product{

    @Override

    abstract void intro();}

/**

 * @ ProductB.java

 * 抽象产品  (零食)

 */abstract class ProductB extends Product{

    @Override

    abstract void intro();}

/**

 * @ ProductAa.java

 * 具体产品  (矿泉水)

 */

public  class ProductAa extends ProductA{

    @Override

    void intro() {

        System.out.println("矿泉水");

    }}

/**

 * @ ProductBb.java

 * 抽象产品  (面包)

 */

public class ProductBb extends ProductB{

    @Override

    void intro() {

        System.out.println("面包");

    }}



/**

 * @ Factory.java

 * 抽象工厂

 */abstract class Factory {

    //生产饮料

    abstract Product getProductA();

    //生产零食

    abstract Product getProductB();}

/**

 * @ FactoryA.java

 * 具体工厂A

 * 负责具体的A类产品生产

 */

public class FactoryA extends Factory{

    @Override

    Product getProductA() {

        //生产矿泉水

        return new ProductAa();

    }

    @Override

    Product getProductB() {

        //生产面包

        return new ProductBb();

    }}



public class Test {

    public static void main(String[] args) {

        //创建零食售卖机（具体工厂），

        FactoryA factoryA = new FactoryA();

        //获取矿泉水与面包（具体产品）

        factoryA.getProductA().intro();

        factoryA.getProductB().intro();

    }}

优点：

1. 降低耦合
2. 符合开-闭原则
3. 符合单一职责原则
4. 不使用静态工厂方法，可以形成基于继承的等级结构。

缺点：难以扩展新种类产品