设计模式之工厂模式

前言

本篇文章主要讲述了简单工厂模式，工厂方法模式和抽象工厂模式的实现以及三者的区别。

简单工厂模式

其实简单工厂模式并不是真正的设计模式，更像一种编程习惯，可以将客户从具体类中解耦。我们先看他的类图，然后在看具体实现的代码。

首先创建了一个接口，然后创建了几个类实现了该接口，最后定义了一个工厂类，通过传入不同的参数，返回不同的对象。

interface IFruit{    public void createFruit();}class Apple implements IFruit{    @Override    public void createFruit() {        System.out.println("生产苹果");    }}class Orange implements IFruit{    @Override    public void createFruit() {        System.out.println("生产橘子");    }}class  Banana implements IFruit{    @Override    public void createFruit() {        System.out.println("生产香蕉");    }}class SimpleFactory{    public IFruit createFruit(String fruit){        if("apple".equals(fruit)){            return new Apple();        }else if("orange".equals(fruit)){            return new Orange();        }else if("banana".equals(fruit)){            return new Banana();        }else{            try {                throw new Exception("没有该水果的生产方式");            } catch (Exception e) {                e.printStackTrace();            }        }        return null;    }}

调用如下：

SimpleFactory simpleFactory=new SimpleFactory();simpleFactory.createFruit("apple").createFruit();simpleFactory.createFruit("orange").createFruit();simpleFactory.createFruit("banana").createFruit();

接着再看工厂方法模式

工厂方法模式

定义了一个创建对象的接口，但由子类决定要实例化哪一个类。工厂方法让类把实例化推迟到子类。

先上类图

工厂方法模式，也是先定义了一个接口，然后创建了几个子类实现了该接口，继而在为每一个子类实现一个工厂类。具体代码实现如下：

interface  Factory {    IFruit create();}class AppleFactory implements Factory{    @Override    public IFruit create() {        return new Apple();    }   }class OrangeFactory implements Factory{    @Override    public IFruit create() {        return new Orange();    }   }class BananaFactory implements Factory{    @Override    public IFruit create() {        return new Banana();    }   }

调用如下：

Factory appleFactory=new AppleFactory();Factory orangeFactory=new OrangeFactory();Factory bananaFactory=new BananaFactory();appleFactory.create().createFruit();orangeFactory.create().createFruit();bananaFactory.create().createFruit();

抽象工厂模式

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

具体实现：

interface IFactory{    IProductA createA();    IProductB createB();}interface IProductA{    void createProductA();}interface IProductB{    void createProductB();}class  ProductA implements IProductA{    @Override    public void createProductA() {        System.out.println("生产产品A");    }}class  ProductB implements IProductB{    @Override    public void createProductB() {        System.out.println("生产产品B");    }}class AbstractFactory implements IFactory{    @Override    public IProductA createA() {        return new ProductA();    }    @Override    public IProductB createB() {        return new ProductB();    }}

调用如下：

AbstractFactory  abstractFactory=new AbstractFactory();abstractFactory.createA().createProductA();abstractFactory.createB().createProductB();

区别

简单工厂模式和工厂方法模式的区别：

简单工厂模式是将通过传递参数给函数，函数通过参数，再确认返回哪一个对象，一个函数就实现了全部；而工厂方法模式，是为每一个对象创建一个工厂，再由工厂返回该对象。在使用的时候，由子类具体操作实例化哪一个。

工厂方法模式和抽象工厂模式的区别：

工厂方法模式是为每一个子类创建一个工厂，一个工场只能创建一种产品；而抽象工厂模式在接口中定义了一个对象的家族，通过工厂获得实例化的对象以后，同一个工厂可以创建多个产品。

最后，简单工厂模式不适合添加产品，因为要修改代码才能完成，这不符合关闭开放原则（即允许扩展类，但是不允许修改类）；工厂方法模式是为每一个子类生成一个工厂类，然后由子类决定具体实例化哪一个类，很方便添加产品；抽象工厂模式方便添加产品族，不方便添加新的产品，因为要添加新的产品，需要修改IFactory接口和IFactory接口的实现类AbstractFactory。