🔍
📢

简单工厂、工厂方法及抽象工厂的区别

工厂模式一般分为简单工厂、工厂方法和抽象工厂三种,看了很多资料,好多讲的都是云里雾里的。要么是概念太多,让人看得一脸懵逼,要么是举得例子不太恰当,看了更让人迷惑了。经过自己一番研究,通过一个简单的例子,终于搞明白了它们之间的区别。

下面以生产宝马、奔驰汽车的工厂为例,讲解它们之间的区别。

一、简单工厂模式

创建一个工厂类,根据传入的参数来决定创建哪个汽车类

//汽车接口
public interface Car {
    void getCar();
}
//宝马汽车类
public class BMWCar implements Car {
    @Override
    public void getCar() {
        System.out.println("这是宝马车");
    }
}
//奔驰汽车类
public class BenzCar implements Car {
    @Override
    public void getCar() {
        System.out.println("这是奔驰车");
    }
}
//工厂类,用于决定创建哪一个具体的汽车类
public class DefaultFactory {
    public Car produce(String name){
        if(name.equals("benz")){
            return new BenzCar();
        }else if(name.equals("bmw")){
            return new BMWCar();
        }
        return null;
    }
}

public class FTest {
    public static void main(String[] args) {
        DefaultFactory factory = new DefaultFactory();
        Car car = factory.produce("bmw");
        car.getCar(); //这是宝马车

        Car benz = factory.produce("benz");
        benz.getCar();  //这是奔驰车
    }
}

可以看到,在具体的工厂类DefaultFactory中,我们根据传入的name来决定创建哪一个汽车类。当需要创建宝马时,传入bmw,当需要创建奔驰时传入benz。思考一下,如果我需要创建一个大众汽车呢。是不是需要创建一个大众汽车类实现Car接口,还需要修改工厂类的produce方法,新增一个大众的分支。 再回忆一下,之前讲过的软件六大设计原则之一开闭原则。很明显,这违背了开闭原则(对修改是关闭的)。

于是,有了下边的工厂方法,可以保证遵循开闭原则。

二、工厂方法模式

工厂方法,相比于简单工厂,多了一个角色——工厂接口,负责定义生产汽车的公共接口,然后每个工厂实现类都去实现这个接口。

//工厂接口
public interface IFactory {
    Car produce();
}
//宝马生产工厂
public class BMWFactory implements IFactory{
    @Override
    public Car produce() {
        return new BMWCar();
    }
}
//奔驰生产工厂
public class BenzFactory implements IFactory {
    @Override
    public Car produce() {
        return new BenzCar();
    }
}

public class FacTest {
    public static void main(String[] args) {
        BMWFactory bmwFactory = new BMWFactory();
        bmwFactory.produce().getCar();   //这是宝马车

        BenzFactory benzFactory = new BenzFactory();
        benzFactory.produce().getCar();  //这是奔驰车
    }
}

可以看到,我把之前的一个工厂,拆分为两个工厂。当具体需要哪个汽车的时候,就去实例化它对应的工厂。这样,当再需要大众车的时候,我只需要添加一个大众车的类和大众车对应的工厂实现类去实现IFactory接口就可以了。不需要修改原来的代码,这就符合开闭原则了。

三、 抽象工厂模式

初识抽象工厂的同学,总是很迷惑它和工厂方法有什么区别,不就是在工厂实现类里多了几个方法吗。其实,抽象工厂是对工厂方法的升级,用于创建一组相互关联或相互依赖的对象。

在此需要了解一下产品等级和产品族的关系。假如有一个汽车制造商,它只生产低配版的汽车产品(至于为什么,我猜是低配版更亲民,销量更高吧,哈哈),其中就包括低配宝马和低配奔驰。还有一个汽车制造商只生产高配版的汽车(没什么原因,就是钱多任性,高端大气上档次),如高配宝马和高配奔驰。

我们就把高配制造商或者低配制造商称为一个产品族。而其中的低配宝马和低配奔驰属于同一个产品等级,高配宝马和高配奔驰属于同一个产品等级。

代码如下:

//工厂接口,包含两个方法,创建宝马和创建奔驰
public interface IFactory {
    Car produceBMW();
    Car produceBenz();
}
//-------- 高配车和工厂实现类 -------//
public class HighBMW implements Car {
    @Override
    public void getCar() {
        System.out.println("高配宝马车");
    }
}
public class HighBenz implements Car {
    @Override
    public void getCar() {
        System.out.println("高配奔驰车");
    }
}
public class HighFactory implements IFactory {
    @Override
    public Car produceBMW() {
        return new HighBMW();
    }

    @Override
    public Car produceBenz() {
        return new HighBenz();
    }
}
//-------- 低配车和工厂实现类 ----------//
public class LowBMW implements Car {
    @Override
    public void getCar() {
        System.out.println("低配宝马车");
    }
}
public class LowBenz implements Car {
    @Override
    public void getCar() {
        System.out.printf("低配奔驰车");
    }
}
public class LowFactory implements IFactory {
    @Override
    public Car produceBMW() {
        return new LowBMW();
    }

    @Override
    public Car produceBenz() {
        return new LowBenz();
    }
}

public class AbsTest {
    public static void main(String[] args) {
        HighFactory highFactory = new HighFactory();
        highFactory.produceBMW().getCar();  //高配宝马车
        highFactory.produceBenz().getCar();  //高配奔驰车

        LowFactory lowFactory = new LowFactory();
        lowFactory.produceBMW().getCar();  //低配宝马车
        lowFactory.produceBenz().getCar();  //低配奔驰车
    }
}

乍一看,抽象工厂和工厂方法特别的相似,其实这里边就是多了一个产品族的概念,它强调一个产品族的对象应该放到同一个工厂类里边。比如,我再需要一个中配版或者豪华版的汽车制造商,只需要实现它的具体工厂类和相应的各同等级的汽车类。

总结:

  1. 简单工厂顾明思议,实现比较简单,只需要传入一个特定参数即可,不用知道具体的工厂实现类名,缺点就是违背了开闭原则。
  2. 工厂方法和抽象工厂,遵守开闭原则,解耦了类关系。但是,扩展比较复杂,需要增加一系列的类。
  3. 需要注意,工厂方法和抽象工厂的区别就在于,抽象工厂关注于某一个产品族,当产品对象之间是有关联关系的一个产品族时用这种方式,而工厂方法没有产品族的概念。