Java设计模式之工厂方法模式和抽象工厂模式

        工厂方法模式属于创建型的设计模式，其他四个分别是抽象工厂模式、建造者模式、单例模式、原型模式。本文分享工厂方法模式和抽象工厂模式。话不多说，进入正文。

1. 工厂方法模式

        工厂方法主要是为了解决某个对象在多处使用时，每一处都需要通过new关键字来创建，创建对象过于分散。如果某天需要对创建过程增加逻辑判断，就会导致需要修改的地方很多且过于分散。出现修改遗漏，导致bug的出现。那么工厂方法模式是怎么处理这个问题的呢？我们通过Java代码示例来说明。相应的源码如下

创建一个抽象类

public abstract class Animal {

    private String name;

    private String nickName;

    public Animal() {
    }

    public Animal(String name, String nickName) {
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

在创建两个子类

public class Dog extends Animal {

    public Dog() {
        super("中华田园犬", "田园犬");
    }

    public Dog(String name, String nickName) {
        super(name, nickName);
    }
}

public class Cat extends Animal {

    public Cat() {
        super("波斯猫", "喵咪");
    }

    public Cat(String name, String nickName) {
        super(name, nickName);
    }
}

再创建一个工厂类

public class AnimalFactory {

    public static Animal getAnimal(String animalType) {
        switch (animalType) {
            case "中华田园犬":
                return new Dog();
            case "波斯猫":
                return new Cat();
            default:
                return null;
        }
    }
}

我们通过工厂类的getAnimal()方法可以集中创建我们需要的对象。测试代码如下

public class Main {

    public static void main(String[] args) {
        Animal cat = AnimalFactory.getAnimal("波斯猫");
        System.out.println(cat);
    }
}

上面代码展示的就是使用工厂方法模式创建对象的方式。但是这上面有个问题，如果我们新增一种动物【或者其他类】，我们就得去修改getAnimal()方法。其实这就违反了开闭原则中的闭原则了。实际开发中，如果是修改次数有限。还可以接受。如果需要频繁修改的话，这种对外开放的api这么处理就不太合适了。那么能不能有更好的方式呢？

2. 抽象工厂模式

我们将上面的代码稍作修改，使用抽象工厂模式来处理这个问题。修改后的源码如下

public abstract class AnimalFactory<T extends Animal> {
    //新增一个抽象类
    public abstract T getAnimal();

    public static Animal getAnimal(String animalType) {
        switch (animalType) {
            case "中华田园犬":
                return new Dog();
            case "波斯猫":
                return new Cat();
            default:
                return null;
        }
    }
}

新增两个工厂类，继承AnimalFactory类，源码如下

public class CatFactory extends AnimalFactory<Cat> {

    @Override
    public Cat getAnimal() {
        return new Cat();
    }
}

public class DogFactory extends AnimalFactory<Dog> {

    @Override
    public Dog getAnimal() {
        return new Dog();
    }
}

测试代码如下

public class Main {

    public static void main(String[] args) {
//        Animal cat = AnimalFactory.getAnimal("波斯猫");
//        System.out.println(cat);

        Animal dog = new DogFactory().getAnimal();
        System.out.println(dog);
    }
}

这样的话修改下来的话。我们还是通过getAnimal()方法来获取对象，但是getAnimal()方法我们就不需要修改了。没增加一种动物，我们只需要增加一个工厂类就可以，符合开闭原则。上面两种写法有两个名称，前面那种成为简单工厂模式，后面修改后方式叫做工厂方法模式。工厂方法模式和抽象工厂模式就简单介绍到这里。