简单工厂模式

简单工厂模式又称为静态工厂方法模式，是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式就是通过一个"全能类"，根据外界传递的信息来决定创建哪个具体类的对象。

创建一个抽象类Animal：

public abstract class Animal {

    public abstract void eat();

}

分别创建一个Dog和Cat类，继承Animal：

public class Dog extends Animal {

    public void eat() {
        System.out.println("狗吃肉");
    }
}

public class Cat extends Animal {

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

没有工厂之前，通过具体类实例化对象：

public class Test {

    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        Cat c = new Cat();
        c.eat();
    }
}

现在创建一个工厂，通过工厂的静态方法创建Dog和Cat：

public class AnimalFactory {

    private AnimalFactory() {
    }

    public static Dog createDog() {
        return new Dog();
    }

    public static Cat createCat() {
        return new Cat();
    }

}

public class Test {

    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        Cat c = new Cat();
        c.eat();

        System.out.println("=====================");

        // 有了工厂后，通过工厂造对象
        Dog dd = AnimalFactory.createDog();
        Cat cc = AnimalFactory.createCat();
        dd.eat();
        cc.eat();
    }
}

如果有若干个类，那么需要写若干个静态方法。改进：通过参数判断创建哪个类的对象：

public class AnimalFactory {

    private AnimalFactory() {
    }

   /* public static Dog createDog() {
        return new Dog();
    }

    public static Cat createCat() {
        return new Cat();
    }*/

    public static Animal createAnimal(String type) {
        if ("dog".equals(type)) {
            return new Dog();
        } else if ("cat".equals(type)) {
            return new Cat();
        }
        return null;
    }

}

public class Test {

    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        Cat c = new Cat();
        c.eat();

        System.out.println("=====================");

        // 有了工厂后，通过工厂造对象
        /*Dog dd = AnimalFactory.createDog();
        Cat cc = AnimalFactory.createCat();
        dd.eat();
        cc.eat();*/

        // 工厂改进后
        Animal a = AnimalFactory.createAnimal("dog");
        a.eat();
        a = AnimalFactory.createAnimal("cat");
        a.eat();
    }
}

通过简单工厂模式，客户端不需要再负责对象的创建，从而明确了各个类的职责。但是一旦有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，严重违背了开闭原则，不利于后期维护。

工厂方法模式

工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

优点：客户端不再负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码（符合开闭原则），后期维护容易，增强了系统的可扩展性。

缺点：需要额外编写代码，增加了工作量。

创建一个Animal抽象类：

public abstract class Animal {

    public abstract void eat();

}

创建一个Dog类继承Animal：

public class Dog extends Animal {

    public void eat() {
        System.out.println("狗吃肉");
    }
}

创建一个工厂接口，该接口只定义创建对象的接口，不负责具体对象的创建：

public interface Factory {

    Animal createAnimal();

}

如果要创建Dog类的对象，需要创建一个具体的工厂类DogFactory，该类需要实现Factory接口，并负责具体Dog对象的创建：

public class DogFactory implements Factory {

    public Animal createAnimal() {
        return new Dog();
    }
}

public class Test {

    public static void main(String[] args) {
        Factory f = new DogFactory();
        Animal a = f.createAnimal();
        a.eat();
    }
}

同样的，如果需要创建Cat类的实例，需要创建一个CatFactory，在CatFactory中完成Cat的创建。

可见，对于工厂方法模式，如果有新的类，就需要增加新的工厂类，增加了代码量。

Factory工厂模式

简单工厂模式

工厂方法模式

抽象工厂模式

猜你喜欢