记录学习 Java 设计模式（二）

记录学习 Java 设计模式（二）

属于建造模式的工厂模式 与 抽象工厂模式

我认为可以这样去理解，即 产品—— 需求 ——>工厂—— 建造 ——>产品，就以这种模式来看一下这两种建造模式。

• 工厂模式

  举个栗子：

当我们需要一辆车时，我们可以理解为：汽车工厂制造了汽车，而我们就可以使用这辆汽车了。

public interface Car{

}

public interface Factory{
    public Car make();
}

这是我们需要的车，均接入了Car接口：

public class Suv implements Car{

    public Suv() {      
        System.out.println("Hello SUV");        
    }
}

public class Limousine implements Car{

    public Limousine() {        
        System.out.println("Hello Limousine");      
    }
}

这是我们用到的工厂，均接入了Factory接口，实现 make() 方法：

public class SuvFactory implements Factory {

    @Override
    public Car make() {     
        return new Suv();
    }
}

public class LimousineFactory implements Factory{

    @Override
    public Car make() {     
        return new Limousine();
    }
}

现在 我们需求一辆车，工厂会帮我们制造出来：

        Car SUV;  //产品需求
        Factory factory = new SuvFactory();  //工厂制造
        SUV = factory.make();  //拿到产品

        Car Limousine;
        Factory factory2 = new LimousineFactory();      
        Limousine = factory2.make();

但是，当我们的需求上升，单一的工厂制造产品不能满足我们的需求，这时便有了抽象工厂模式。

• 抽象工厂模式
  举个栗子：

当用户的需求更加多样时，例如：国产车、进口车、不同级别的车，单一的工厂不能满足用户的需求，那么我们可以建造更多的工厂，制造更多的产品。

首先我们要构建 产品 与 工厂：

public interface AClass {

}
public interface BClass {

}
public interface MercedesFactory {

    public AClass makeAClass();
    public BClass makeBClass();
}

接着将产品接入：

//A级
public class AClassCN implements AClass {

    public AClassCN() {     
        System.out.println("这是一辆中国产的A级奔驰.....");        
    }
}
public class AClassGermany implements AClass {

    public AClassGermany() {    
        System.out.println("这是一辆德国产的A级奔驰.....");    
    }
}
//B级
public class BClassCN implements BClass {

    public BClassCN() { 
        System.out.println("这是一辆中国产的B级奔驰.....");    
    }
}
public class BClassGermany implements BClass {

    public BClassGermany() {    
        System.out.println("这是一辆德国产的B级奔驰.....");        
    }
}

接着构造工厂：

//中国工厂
public class MercedesFactoryCN implements MercedesFactory {

    @Override
    public AClass makeAClass() {        
        return new AClassCN();
    }

    @Override
    public BClass makeBClass() {
        return new BClassCN();
    }
}
//德国工厂
public class MercedesFactoryGermany implements MercedesFactory {

    @Override
    public AClass makeAClass() {        
        return new AClassGermany();
    }

    @Override
    public BClass makeBClass() {
        return new BClassGermany();
    }
}

下面就可以根据用户的要求生产汽车：

        AClass a ;//要求
        //工厂制造
        MercedesFactory factory1 = new MercedesFactoryCN();
        a = factory1.makeAClass();//得到

        AClass aG;
        MercedesFactory factory2 = new MercedesFactoryGermany();
        aG = factory2.makeAClass();

        BClass b;
        MercedesFactory factory3 = new MercedesFactoryCN();
        b = factory3.makeBClass();

        BClass bG;
        MercedesFactory factory4 = new MercedesFactoryGermany();
        bG = factory4.makeBClass();

从上面就可以看出，所谓工厂模式 与 抽象工厂模式 万变不离其衷都是 产品—— 需求 ——>工厂—— 建造 ——>产品 这样的套路，都是应对各种需求产生的。