常用的设计模式（一）—工厂与抽象工厂模式

一、工厂模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类，该模式使其创建过程延迟到子类进行。通俗地说就是让工厂类来new所需的对象，然后通过工厂类来获取所需的对象。

优点：（1）一个调用者想创建一个对象，只要知道其名称就可以了。

　　   （2）扩展性高，如果想增加一个产品，只需扩展一个工厂类就可以了。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

1.先创建一个接口

public interface Animal{
    void eat();
}

2.其实现类

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

public class Dog implements Animal{
    @Override
    public void eat(){
        System.out.println("Dog eat bone");
    }
}

3.创建一个工厂类

public class AnimalFactory{
    public Animal getAnimal(String AnimalName){
        if(AnimalName==null){
            return null;
        }else if(AnimalName.equalsIgnoreCase("cat")){//忽略大小写
            return new Cat();
        }else if(AnimalName.equalsIgnoreCase("dog")){
            return new Dog();
        }
        return null;
    }
}

4.测试类

public class FactoryPatternDemo{
    public static void main(String[] args){
        AnimalFactory animalFactory=new AnimalFactory();
        //从工厂获取对象，并调用其方法
        Animal animal1= animalFactory. getAnimal("cat");
        animal1.eat();
        Animal animal2= animalFactory. getAnimal("dog");
        animal2.eat();
    }
}

二、抽象工厂

 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。就是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

根据如上的例子基础上再添加些类和接口。

public interface Color{
     void fill();
}

其实现类

public Class White implements Color{
    @Override
    public void fill(){
        System.out.println("white");
    }
}

public Class White implements Color{
    @Override
    public void fill(){
        System.out.println("white");
    }
}

创建一个抽象工厂

public abstract class AbstractFactory{
    abstract Animal getAnimal(String AnimalName);
    abstract Color  getColor(String color);
}

然后AnimalFactory和ColorFactory再分别继承该抽象工厂类，实现其抽象方法

public class AnimalFactory extends AbstactFactory{
    @Override
    public Animal getAnimal(String AnimalName){
        if(AnimalName==null){
            return null;
        }else if(AnimalName.equalsIgnoreCase("cat")){//忽略大小写
            return new Cat();
        }else if(AnimalName.equalsIgnoreCase("dog")){
            return new Dog();
        }
        return null;
    }

    @Override
    public Color getColor(String color){
         return null;
    }
}
//ColorFactory同理

创建一个生产工厂类的工厂

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("animal")){
         return new AnimalFactory();
      } else if(choice.equalsIgnoreCase("color")){
         return new ColorFactory();
      }
      return null;
   }
}

测试

public class AbstactFactoryPatternDemo{
    public static void main(String[] args){
         //获取animal工厂
         AbstractFactory animalFactory=FactoryProducer.getFactory("animal");
        //从工厂获取对象，并调用其方法
        Animal animal1= animalFactory. getAnimal("cat");
        animal1.eat();
        //获取color工厂
      AbstractFactory colorFactory=FactoryProducer.getFactory("COLOR");
      Color color1 = colorFactory.getColor("black");
      color1.fill();
    }
}