设计模式之抽象工厂模式(Java实现)

抽象工厂是一个超级工厂，用来创建其他工厂，又称为工厂的工厂，也就是对各种不同的工厂再次进行抽象。在抽象工厂模式中，接口负责创建相关对象的工厂，每个生成的工厂可以按照工厂模式提供对象。

首先创建两个接口然后实现具体类

//再创建一个接口Plant
interface Plant {
    public void print();
}

//创建一个Cat的类实现Animal接口
class Cat implements Animal {
    public void print() {
        System.out.println("猫");
    }
}

//创建一个Dog的类实现Animal接口
class Dog implements Animal {
    public void print() {
        System.out.println("狗");
    }
}

//创建一个Rabbit的类实现Animal接口
class Rabbit implements Animal {
    public void print() {
        System.out.println("兔子");
    }
}

//创建一个Flower的类实现Plant接口
class Flower implements Plant {
    public void print() {
        System.out.println("花朵");
    }
}

//创建一个Tree的类实现Plant接口
class Tree implements Plant {
    public void print() {
        System.out.println("树木");
    }

接下来重点来了，创建一个抽象的工厂类

//创建一个抽象工厂
abstract class AbstractFactory {
    abstract Animal getAnimal(String animal);
    abstract Plant getPlant(String plant);
}

接着创建具体的工厂，继承自抽象工厂类

//创建具体的工厂AnimalFactory继承自AbstractFactory
class AnimalFactory extends AbstractFactory {
    public Animal getAnimal(String animal) {
        if ("cat".equals(animal)) {
            return new Cat();
        } else if ("dog".equals(animal)) {
            return new Dog();
        } else if ("rabbit".equals(animal)) {
            return new Rabbit();
        } else {
            return null;
        }
    }

    public Plant getPlant(String plant) {
        return null;
    }
}

//创建具体的工厂PlantFactory继承自AbstractFactory
class PlantFactory extends AbstractFactory {
    public Plant getPlant(String plant) {
        if("flower".equals(plant)) {
            return new Flower();
        } else if ("tree".equals(plant)) {
            return new Tree();
        } else {
            return null;
        }
    }

    public Animal getAnimal(String animal) {
        return null;
    }
}

创建一个工厂生成器类，通过区分传递过来的参数生成具体的工厂类

//创建一个工厂生成器类，通过传递的相应参数创建工厂
class FactoryProducer {
    public static AbstractFactory getFactory(String factroyType) {
        if ("animal".equals(factroyType)) {
            return new AnimalFactory();
        } else if ("plant".equals(factroyType)) {
            return new PlantFactory();
        } else {
            return null;
        }
    }
}

使用FactoryProducer抽象工厂生成器类获取具体的工厂，然后通过具体的工厂获取不同的对象

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        //先获取Animal的工厂
        AbstractFactory animalFactory = FactoryProducer.getFactory("animal");
        //通过Animal工厂获取对象
        Animal cat = animalFactory.getAnimal("cat");
        cat.print();
        Animal dog = animalFactory.getAnimal("dog");
        dog.print();
        Animal rabbit = animalFactory.getAnimal("rabbit");
        rabbit.print();
        //先获取Plant的工厂
        AbstractFactory plantFactory = FactoryProducer.getFactory("plant");
        //通过Animal工厂获取对象
        Plant flower = plantFactory.getPlant("flower");
        flower.print();
        Plant tree = plantFactory.getPlant("tree");
        tree.print();
    }
}

设计模式之抽象工厂模式(Java实现)

猜你喜欢