设计模式—抽象工厂模式

当看到new关键字的时候，就会想到具体，而业务代码中充斥着太多的new关键字，一旦有变化或扩展，就必须重对代码进行修改，通常这样修改过的代码更难以维护和更新，而且更容易犯错。

想想设计模式的SOLID原则

抽象不应该依赖细节；细节应该依赖抽象。针对接口编程，可以隔离以后系统可能发生的一大堆改变。为什么呢？通过多态，可以与任何新类实现该接口。

含义

• 当需要定义一个产品家族的产品时，产品众多，需要一个大的接口，来组合所有的产品。

• new关键字有一定的副作用，虽然new关键字是java的基础部分，使用new不可避免，但是使用工厂模式可以把new对象的过程收集起来。

• 加入新的产品就必须要改变接口，这个将是一份庞大的工作。所以接口需要大一点

模式图

如果我们开发一个平台独立型的便携式软件。 这些平台可能是windows,linux,unix,也可能是数据库。如果我们不去按设计模式处理他们，将会看到到处都是#if #else的语句。创建对象的代码到处乱跑... 如果使用了工厂模式，则可以把创建对象的代码收集起来。
可以用制作汽车来对比。

模式图

案例

抽象工厂的目的是提供一个接口以便创建一个系列的相关对象，而无需指定精确的类。此模式可以在制造产业中找到相似的，一台器械不同的部分由不同的工厂来创建具体的东西。

创建CPU的产品家族

// class CPUabstract class CPU {}// class EmberCPUclass EmberCPU extends CPU {}// class EnginolaCPUclass EnginolaCPU extends CPU {}// class MMUabstract class MMU {}// class EmberMMUclass EmberMMU extends MMU {}// class EnginolaMMUclass EnginolaMMU extends MMU {}// class EmberFactoryclass EmberToolkit extends AbstractFactory {    @Override
    public CPU createCPU() {   
         return new EmberCPU();
    } 
       @Override
    public MMU createMMU() {    
        return new EmberMMU();
    }
}// class EnginolaFactoryclass EnginolaToolkit extends AbstractFactory {    @Override
    public CPU createCPU() {    
        return new EnginolaCPU();
    } 
       @Override
    public MMU createMMU() {    
        return new EnginolaMMU();
    }
}enum Architecture {
    ENGINOLA, EMBER
}
abstract class AbstractFactory { 
   private static final EmberToolkit EMBER_TOOLKIT = new EmberToolkit(); 
   private static final EnginolaToolkit ENGINOLA_TOOLKIT = new EnginolaToolkit();    // Returns a concrete factory object that is an instance of the
    // concrete factory class appropriate for the given architecture.
    static AbstractFactory getFactory(Architecture architecture) {
        AbstractFactory factory = null;        
        switch (architecture) {          
          case ENGINOLA:
                factory = ENGINOLA_TOOLKIT;                
                break;            
                case EMBER:
                factory = EMBER_TOOLKIT;                
                break;
        }        
        return factory;
    }   
     public abstract CPU createCPU();
     public abstract MMU createMMU();
}
public class Client { 
   public static void main(String[] args) {
        AbstractFactory factory = AbstractFactory.getFactory(Architecture.EMBER);
        CPU cpu = factory.createCPU();
    }
}

案例二

image.png

public interface IButton { 
   void paint();
}
public interface IGUIFactory {  
  public IButton createButton();
}
public class WinFactory implements IGUIFactory { 
   @Override
    public IButton createButton() {      
      return new WinButton();
    }
}public class OSXFactory implements IGUIFactory { 
   @Override
    public IButton createButton() {     
       return new OSXButton();
    }
}
public class WinButton implements IButton {  
  @Override
    public void paint() {
        System.out.println("WinButton");
    }
}
public class OSXButton implements IButton {  
  @Override
    public void paint() {
        System.out.println("OSXButton");
    }
}
public class Main { 
           public static void main(final String[] arguments) throws Exception {
        IGUIFactory factory = null;        
        final String appearance = randomAppearance();   // Current operating system

        if (appearance.equals("OSX")) {
            factory = new OSXFactory();
        } else if(appearance.equals("Windows")) {
            factory = new WinFactory();
        } else {         
           throw new Exception("No such operating system");
        }        
        final IButton button = factory.createButton();

        button.paint();
    }    
    /**
     * This is just for the sake of testing this program, and doesn't have to do
     * with Abstract Factory pattern.
     * @return
     */
    public static String randomAppearance() {        
          final String[] appearanceArray = new String[3];

        appearanceArray[0] = "OSX";
        appearanceArray[1] = "Windows";
        appearanceArray[2] = "error";        
        final java.util.Random random = new java.util.Random();        
        final int randomNumber = random.nextInt(3);        
        return appearanceArray[randomNumber];
    }
}

最后

整理了一下抽象工厂方法的定义与通常显现的形式，想要探索其中更多的奥秘，还要亲自去实践。