设计模式之工厂模式

前言

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

简单工厂模式

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

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

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。