设计模式之--抽象工厂模式

啥是抽象工厂模式？

之前我们介绍过 工厂模式，那么什么是抽象工厂模式呢？其实抽象工厂模式就等于是一个超级大集团，大集团负责管理很多工厂，然后每个工厂负责生产不同的产品。

上代码

首先我们创建一个大集团(抽象工厂，负责管理其他工厂)

public abstract class AlimamaAbstractFactory {
   public abstract Animal getAnimal(String animal);
   public abstract Fruit getFruit(String fruit) ;
}

创建第一个工厂（水果工厂）

首先创建一个接口（理解为工厂的产品类型）

public interface Fruit{
   void draw();
}

接下来创建接口的实现类（理解为产品）

public class Apple implements Fruit{
 
   @Override
   public void draw() {
      System.out.println("这里是苹果的draw方法");
   }
}

public class Banana implements Fruit{
 
   @Override
   public void draw() {
      System.out.println("这里是香蕉的draw方法");
   }
}

public class Strawberry implements Fruit{
 
   @Override
   public void draw() {
      System.out.println("这里是草莓的draw方法");
   }
}

然后就开始创建工厂类

//继承大集团
public class FruitFactory extends AlimamaAbstractFactory {
    
   //使用 getFruit方法获取形状类型的对象
   @Override
   public Fruit getFruit(String fruitType){
   //当然在方法里面也可以定义其他不同的更加复杂的业务逻辑，然后返回对于的对象
      if(fruitType== null){
         return null;
      }        
      if(fruitType.equalsIgnoreCase("Apple")){
         return new Apple();
      } else if(fruitType.equalsIgnoreCase("Banana")){
         return new Banana();
      } else if(fruitType.equalsIgnoreCase("Strawberry")){
         return new Strawberry();
      } 
      return null;
   }
   
   @Override
   public Animal getAnimal(String animal) {
      return null;
   }
}

到这里为止，第一个水果工厂就创建成功了，接下来我们再建一个动物工厂（跟水果工厂同理）；

public interface Animal{
   void draw();
}

public class Dog implements Animal{
 
   @Override
   public void draw() {
      System.out.println("这里是老狗的draw方法");
   }
}

public class Cat implements Animal{
 
   @Override
   public void draw() {
      System.out.println("这里是老猫的draw方法");
   }
}

public class Tiger implements Animal{
 
   @Override
   public void draw() {
      System.out.println("这里是老虎的draw方法");
   }
}

public class AnimalFactory extends AlimamaAbstractFactory {
    
   //使用 getFruit方法获取形状类型的对象
   @Override
   public Animal getAnimal(String animalType){
   //当然在方法里面也可以定义其他不同的更加复杂的业务逻辑，然后返回对于的对象
      if(animalType== null){
         return null;
      }        
      if(animalType.equals("Dog")){
         return new Dog();
      } else if(animalType.equals("Cat")){
         return new Cat();
      } else if(animalType.equals("Tiger")){
         return new Tiger();
      } 
      return null;
   }
   @Override
   public Fruit getFruit(String fruit) {
      return null;
   }
}

那么集团和工厂都建好后，接下来就开始建工厂生成器，用于大集团生成工厂

public class FactoryProducer {
   public static AlimamaAbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("ANIMAL")){
         return new AnimalFactory();
      } else if(choice.equalsIgnoreCase("FRUIT")){
         return new FruitFactory();
      }
      return null;
   }
}

到这里一个集团就创建好了，可以使用了：

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //这里调用工厂生成器的方法，创建了一个动物工厂对象
      AlimamaAbstractFactory alimama = FactoryProducer.getFactory("ANIMAL");
 
      //然后通过这个动物工厂可以创建对应的动物对象
      Animal dog = alimama.getAnimal("Dog");
	  //获取到dog对象后就可以使用对应的draw方法了
	  dog.draw();
      
   }
}