简单工厂模式&工厂方法模式&抽象工厂模式
简单工厂模式
先来看一个问题，我们要给手机买一个手机壳，因为各种手机形状不一致，所以手机壳有很多种类，下面用代码的形式处理这个问题
String phoneName = "xxx";
// 所有的shell都是继承自PhoneShell，这里偷个懒就不写了。
PhoneShell shell = null;
if("Iphone".equals(phoneName)){
shell = new IphoneShell();
}else if("huawei".equals(phoneName)){
shell = new HuaweiShell();
}....
在这个例子的代码实现里，我们用到了很多的if else，不是说不能用if else 但是过多的if else堆砌会显得代码不是那么的简洁，这时我们把这些判断逻辑封装起来
public class PhoneShellFactory{
public static PhoneShell getPhoneShell(String phoneName){
if("Iphone".equals(phoneName)){
return new IphoneShell();
}else if("huawei".equals(phoneName)){
return new HuaweiShell();
}...
}
}
再次编写解决这个问题的代码，代码就成了下面这个样子
String phoneName = "xxx";
PhoneShell shell = PhoneShellFactory.getPhoneShell(phoneName);
代码就变得十分简洁了，但是还是有问题，虽然原本的if else没了，但是我们在编写PhoneShellFactory这个类的时候还是写了if else啊，这不是自欺欺人吗？复杂度不会消失，只会转移，所以我们把根据手机类型获得手机壳的过程封装在一个类之中，这像不像你去手机店买手机壳，只需要告诉店家你的手机类型，店家就会给你找来合适的手机壳，而不是你自己挨个去找，这就是简单工厂模式，也叫做静态工厂模式，因为只有一个获得商品的静态方法，所以没必要每次都实例化工厂对象，简单工厂模式是有违开闭原则的，开闭原则简单来说就是，允许对代码进行扩展，但是不允许对原有的代码进行修改，所以如果我们要增加商店提供的手机壳的种类就要修改PhoneShellFactory的代码，这就有违开闭原则。简单工厂模式也并不是每次都要创建新的对象，也可以在代码逻辑里加入缓存，这里就不作赘述。
工厂方法模式
前面说的简单工厂方法是有违开闭原则的，相反的，工厂方法模式是不违背开闭原则的，但是工厂方法并不是简单工厂的进阶版本，他俩的着重点是有区别的，首先我们定义一个ShellFactory接口
public interface ShellFactory {
public PhoneShell getShell();
}
接下来我们定义两个实现ShellFactory的类
public class IphoneShellFactory extends ShellFactory {
@Override
public PhoneShell getShell() {
return new IphoneShell();
}
}
public class HuaweiShellFactory extends ShellFactory {
@Override
public PhoneShell getShell() {
return new HuaweiShell();
}
}
下面我们编写购买手机壳的代码
ShellFactory sf = new IphoneShellFactory();
PhoneShell shell = sf.getShell();
类图如下
工厂模式满足了开闭原则，如果我们需要增加一个手机壳的种类，只需要编写一个实现ShellFactory的类即可，但是如果想要根据传入的手机类型创建手机壳工厂，还是需要if else逻辑判断，所以前面说工厂方法并不是简单工厂的进阶版本，他俩的着重点是有区别的，看完上面的代码可能会有一个疑问，既然都知道是要iphone的手机壳那我们直接new 一个IphoneShell不就行了，还用整这么麻烦吗？还要先new 一个IphoneShellFactory然后调用getShell才能得到IphoneShell简直不要太复杂，其实上面的代码只是简单的说明了工厂方法模式满足了开闭原则，工厂方法模式的着重点其实是隐藏创建产品的细节，且不一定每次都会真正创建产品，还是用代码来说，我们来一个实现ShellFactory的类
public class XiaomiShellFactory implements ShellFactory {
@Override
public PhoneShell getShell() {
PhoneShell shell = new XiaomiShell();
shell.rePrint(); // 手机壳重新喷涂颜色；
return shell;
}
}
这里我们在getShell方法里，加了一点细节，在实际的业务中可能创建一个产品对象有很多的细节操作，工厂方法模式的意义就是隐藏这些细节，再举一个简单的例子，比如我们买手机，同一款手机会有很多可变的参数，比如颜色，RAM，ROM，
public class Mi10Blue6$256PhoneFactory implements PhoneFactory {
@Override
public Phone getPhone() {
Phone phone = new Mi10();
phone.printColor("Blue");
phone.setRAM(6);
phone.setROM(256);
return phone
}
}
当然这个例子还是有点单薄，操作比较简单，也可以用构造函数实现，这里只是理解一下思想，不必较真，真实的业务里可能不仅仅是对POJO属性的简单操作。那不一定每次都会真正创建产品又是什么意思呢，还是用代码来说
public class XiaomiShellFactory implements ShellFactory {
static Stack stack = new Stack();
static{
// 柜台上一开始可能就摆放着一些手机壳，可能是热卖的，也可能是拿给别的顾客看，顾客没买的。
// 从仓库取手机壳相当于创建一个新的手机壳， 从柜台获取相当于没有新创建一个
stack.push(new XiaomiShell());
}
@Override
public PhoneShell getShell() {
if(stack.isEmpty()){
return new XiaomiShell();
}else{
return (PhoneShell) stack.pop();
}
}
}
这里对应到实际的业务中可能就是相应的缓存。
抽象工厂
工厂方法模式只是生产一个对象也就是一个产品，有时业务特别复杂，需要一个工厂得到多个产品怎么办？这时候就该抽象工厂出场了，从工厂方法模式来理解，一个工厂能创建一类产品，如果需要创建多类产品，那就是需要创建工厂的工厂，下面上代码，首先创建接口ElectronicsmakersFactory
public interface ElectronicsmakersFactory{
public Phone getPhone();
public Computer getComputer();
}
接着创建实现类
public XiaoMiFactory implements ElectronicsmakersFactory{
@Override
public Phone getPhone() {
return new Mi10PhoneFactory.getPhone();
}
@Override
public Computer getComputer() {
return new MiBookComputerFactory.getComputer();
}
}
public AppleFactory implements ElectronicsmakersFactory{
@Override
public Phone getPhone() {
return new Ip11PhoneFactory.getPhone();
}
@Override
public Computer getComputer() {
return new MacBookProComputerFactory.getComputer();
}
}
调用时的代码
ElectronicsmakersFactory ef = new XiaoMiFactory();
Phone phone = ef.getPhone();
Computer computer = ef.getComputer();
类图如下
总结
简单工厂模式主要注重于隐藏处理逻辑，工厂方法模式注重于隐藏装配类的细节，抽象工厂模式主要是处理复杂的业务逻辑，层级比较多。
