【设计模式02】 抽象工厂模式

抽象工厂模式

定义：
   工厂模式，只有一种工厂，而抽象工厂模式，是在工厂模式的基础上再包装一层，制造一个工厂中心的抽象类，其子类创建多个不同的工厂。


案例代码：
项目目录

|—abstract-factory-pattern
  |—pom.xml
  |—src
      |—main
          |—java
              |—org
                  |—peko
                      |—design
                          |—AnimalFactory.java
                          |—FactoryProduct.java
                          |—PlantFactory.java
                          |—pattern
                              |—abstrct_factory
                                  |—AbstractFactory.java
                              |—animal
                                  |—Animal.java
                                  |—impl
                                      |—Cat.java
                                      |—Dog.java
                              |—plant
                                  |—impl
                                      |—Grass.java
                                      |—Rose.java
                                  |—Plant.java

          |—resources
      |—test
          |—java
              |—org
                  |—peko
                      |—design
                          |—pattren
                              |—Test01.java

Animal.java

public interface Animal {
    void voice();
}

Cat.java

package org.peko.design.pattern.animal.impl;

import org.peko.design.pattern.animal.Animal;

public class Cat implements Animal {

    @Override
    public void voice() {
        System.out.println("miao miao ~");
    }
}

Dog.java

package org.peko.design.pattern.animal.impl;

import org.peko.design.pattern.animal.Animal;

public class Dog implements Animal {
    @Override
    public void voice() {
        System.out.println("wang wang !");
    }
}

Plant.java

public interface Plant {
    void grow();
}

Rose.java

package org.peko.design.pattern.plant.impl;

import org.peko.design.pattern.plant.Plant;

public class Rose implements Plant {
    @Override
    public void grow() {
        System.out.println("rose");
    }
}

Grass.java

package org.peko.design.pattern.plant.impl;

import org.peko.design.pattern.plant.Plant;

public class Grass implements Plant {
    @Override
    public void grow() {
        System.out.println("Glass");
    }
}

AbstractFactory.java

package org.peko.design.pattern.abstrct_factory;

import org.peko.design.pattern.animal.Animal;
import org.peko.design.pattern.plant.Plant;

public abstract class AbstractFactory {
    public abstract Animal getAnimal(String sort);
    public abstract Plant getPlant(String sort);
}

AnimalFactory.java

package org.peko.design;

import org.apache.commons.lang3.StringUtils;
import org.peko.design.pattern.abstrct_factory.AbstractFactory;
import org.peko.design.pattern.animal.Animal;
import org.peko.design.pattern.animal.impl.Cat;
import org.peko.design.pattern.animal.impl.Dog;
import org.peko.design.pattern.plant.Plant;

public class AnimalFactory extends AbstractFactory {
    public Animal getAnimal(String sort){

        if(StringUtils.isBlank(sort)){
            return null;
        }

        if(sort.equalsIgnoreCase("CAT")){
            return new Cat();
        }

        if(sort.equalsIgnoreCase("DOG")){
            return new Dog();
        }

        throw new RuntimeException("不存在该类型");
    }

    @Override
    public Plant getPlant(String sort) {
        return null;
    }
}

PlantFactory.java

package org.peko.design;

import org.apache.commons.lang3.StringUtils;
import org.peko.design.pattern.abstrct_factory.AbstractFactory;
import org.peko.design.pattern.animal.Animal;
import org.peko.design.pattern.plant.Plant;
import org.peko.design.pattern.plant.impl.Grass;
import org.peko.design.pattern.plant.impl.Rose;

public class PlantFactory extends AbstractFactory {
    public Plant getPlant(String sort){
        if(StringUtils.isBlank(sort)){
            return null;
        }

        if(sort.equalsIgnoreCase("ROSE")){
            return new Rose();
        }

        if(sort.equalsIgnoreCase("GRASS")){
            return new Grass();
        }

        throw new RuntimeException("不存在该类型");
    }

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

FactoryProduct.java

package org.peko.design;

import org.peko.design.pattern.abstrct_factory.AbstractFactory;

public class FactoryProduct {
    public static AbstractFactory getFactory(String sort){
        if(sort == null){
            return null;
        }

        if(sort.equalsIgnoreCase(("ANIMAL"))){
            return new AnimalFactory();
        }

        if(sort.equalsIgnoreCase(("PLANT"))){
            return new PlantFactory();
        }

        throw new RuntimeException("不存在此种工厂");
    }
}

Test01.java

package org.peko.design.pattren;

import org.junit.jupiter.api.Test;
import org.peko.design.FactoryProduct;
import org.peko.design.pattern.abstrct_factory.AbstractFactory;

public class Test01 {
    @Test
    public void test01(){
        AbstractFactory animalFactory = FactoryProduct.getFactory("animal");
        animalFactory.getAnimal("cat").voice();
        animalFactory.getAnimal("dog").voice();

        AbstractFactory plantFactory = FactoryProduct.getFactory("plant");
        plantFactory.getPlant("rose").grow();
        plantFactory.getPlant("grass").grow();
    }
}