设计模式学习之旅-抽象工厂模式

一、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

二、介绍

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品，通过产品组和产品级别即可定义某一具体产品。

如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里聚合多个同类产品。

三、代码演示

public abstract class AbstractFactory {

    abstract Sex getSex(String sex);

    abstract Animal getAnimal(String animal);
}

public class AnimalFactory extends AbstractFactory {
    @Override
    Sex getSex(String sex) {
        return null;
    }

    @Override
    public Animal getAnimal(String animalKey) {
        if (animalKey == null) {
            return null;
        } else {
            if ("dog".equals(animalKey)) {
                return new Dog();
            }
            if ("cat".equals(animalKey)) {
                return new Cat();
            }
            if ("rabbit".equals(animalKey)) {
                return new Rabbit();
            }
            return null;
        }
    }
}

public class SexFactory extends AbstractFactory {

    @Override
    public Sex getSex(String sex) {
        if (sex == null) {
            return null;
        } else {
            if ("male".equals(sex)) {
                return new Male();
            }
            if ("female".equals(sex)) {
                return new Female();
            }
        }
        return null;
    }

    @Override
    Animal getAnimal(String animal) {
        return null;
    }
}

public class FactoryProducer {
    public static AbstractFactory getFactory(String factory){
        if("sex".equals(factory)){
            return new SexFactory();
        }
        if("animal".equals(factory)){
            return new AnimalFactory();
        }
        return null;
    }
}

public interface Animal {
    void eat();
}

public class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class Rabbit implements Animal {
    @Override
    public void eat() {
        System.out.println("兔子吃胡萝卜");
    }
}

public interface Sex {
    void getSex();
}

public class Male implements Sex {
    @Override
    public void getSex() {
        System.out.println("It's male");
    }
}

public class AbstractFactoryDemo {

    public static void main(String[] args) {
        //获取性别工厂
        AbstractFactory sexFactory = FactoryProducer.getFactory("sex");

        //获取动物工厂
        AbstractFactory animalFactory = FactoryProducer.getFactory("animal");

        //获取雄性
        Sex male = sexFactory.getSex("male");
        male.getSex();

        //获取雌性
        Sex female = sexFactory.getSex("female");
        female.getSex();

        //获取狗狗
        Animal dog = animalFactory.getAnimal("dog");
        dog.eat();

        //获取猫咪
        Animal cat = animalFactory.getAnimal("cat");
        cat.eat();

        //获取兔兔
        Animal rabbit = animalFactory.getAnimal("rabbit");
        rabbit.eat();
    }
}

运行结果

It's male
It's female
狗吃骨头
猫吃鱼
兔子吃胡萝卜