工厂模式和抽象工厂

概要

• 工厂模式属于创建者类型

  简单工厂

• 工厂类根据传入的参数，判断生产不同的实例对象。

• 简单工厂每新增一个新的实例类型时，都要修改工厂方法。会使工厂类越来越复杂。

• 违背了开闭原则(拓展开放，内容封闭)

class Animal {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class Factory {
    public static Animal creatAnimal(String type) {
        Animal animal = null;
        switch (type) {
            case "cat":
                animal = new Cat();
                break;
            case "dog":
                animal = new Dog();
                break;
            default:
        }
        return animal;
    }
}
class Dog extends Animal {
    public Dog() {
        setName("dog");
    }
}
class Cat extends Animal {
    public Cat() {
        setName("cat");
    }
}
public class SimpleFactoryDesign {
    public static void main(String[] args) {
        Animal animal = Factory.creatAnimal("cat");
        System.out.println(animal.getName());
        animal = Factory.creatAnimal("dog");
        System.out.println(animal.getName());
    }
}

工厂方法

• 将工厂类的创建延迟到子类(解决了增加子类直接修改工厂方法)

class Animal {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class Dog extends Animal {
    public Dog() {
        setName("dog");
    }
}
class Cat extends Animal {
    public Cat() {
        setName("cat");
    }
}
abstract class AbstractFactory {
    abstract Animal creatAnimal();
    public void getName() {
        System.out.println(creatAnimal().getName());
    }
}
class DogFactory extends AbstractFactory {
    @Override
    Animal creatAnimal() {
        return new Dog();
    }
}
class CatFactory extends AbstractFactory {
    @Override
    Animal creatAnimal() {
        return new Cat();
    }
}
public class FactoryMethodDesign {
    public static void main(String[] args) {
        AbstractFactory catFactory = new CatFactory();
        AbstractFactory dogFactory = new DogFactory();
        catFactory.getName();
        dogFactory.getName();
    }
}

抽象工厂

• 工厂生产多类产品
• 新增产品，要创建对应的工厂

abstract class Animal {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
abstract class Plant  {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class Dog extends Animal {
    public Dog() {
        setName("dog");
    }
}
class Cat extends Animal {
    public Cat() {
        setName("cat");
    }
}
class Pine extends Plant {
    public Pine() {
        setName("pine");
    }
}
class Cypress extends Plant {
    public Cypress() {
        setName("cypress");
    }
}
abstract class Factory {
    abstract Animal creatAnimal();
    abstract Plant creatPlant();
}
class Factory1 extends Factory {
    @Override
    Animal creatAnimal() {
        return new Dog();
    }
    @Override
    Plant creatPlant() {
        return new Pine();
    }
}
class Factory2 extends Factory {
    @Override
    Animal creatAnimal() {
        return new Cat();
    }
    @Override
    Plant creatPlant() {
        return new Cypress();
    }
}
public class AbstractFactoryDesign {
    public static void main(String[] args) {
        Factory factory1 = new Factory1();
        System.out.println(factory1.creatAnimal().getName());
        System.out.println(factory1.creatPlant().getName());
        Factory factory2 = new Factory2();
        System.out.println(factory2.creatAnimal().getName());
        System.out.println(factory2.creatPlant().getName());
    }
}

总结

• 首先从简单工厂进化到工厂方法，是因为工厂方法弥补了简单工厂对修改开放的弊端，即简单工厂违背了开闭原则。
• 从工厂方法进化到抽象工厂，是因为抽象工厂弥补了工厂方法只能创造一个系列的产品的弊端。