玩转抽象工厂模式

上一篇介绍了工厂模式，《玩转工厂模式》，下面再写一个例子来加深一下对抽象工厂模式的理解。

 

package go.derek;  
//这是一个抽象工厂类  
public abstract class CarFactory{  
    abstract void brand();  
    abstract Car create(String type);  
}  
//宝马工厂，继承了抽象工厂类  
class BmwFactory extends CarFactory{  
    //将制造地点组合进宝马工厂  
    MakeUpFactory makeUpFactory;  
    BmwFactory(MakeUpFactory mf){  
        this.makeUpFactory=mf;  
    }  
    public void brand(){  
        System.out.println("这是宝马工厂,采用 宝马 指定配件与制造工艺");  
    }  
    //宝马的工厂方法  
    public Car create(String type) {  
        if(type.equals("745Li")){  
            return new Bmw_745Li(makeUpFactory);  
        }  
        else if(type.equals("765Li")){  
            return new Bmw_765Li(makeUpFactory);  
        }  
        else  
            return null;  
    }  
}  
//奥迪工厂，继承了抽象工厂类  
class AudiFactory extends CarFactory{  
    //将制造地点组合进奥迪工厂  
    MakeUpFactory makeUpFactory;  
    AudiFactory(MakeUpFactory mf){  
        this.makeUpFactory=mf;  
    }  
    public void brand(){  
        System.out.println("这是奥迪工厂，采用 奥迪 指定配件与制造工艺");  
    }  
    //奥迪的工厂方法  
    public Car create(String type) {  
        if(type.equals("A8L")){  
            return new Audi_A8L(makeUpFactory);  
        }  
        else if(type.equals("A6L")){  
            return new Audi_A6L(makeUpFactory);  
        }  
        else  
            return null;  
    }  
}  
//定义制造地点的一个借口  
inte易做图ce MakeUpFactory{  
     void make(String type);  
}  
//中国工厂  
class ChinaFactory implements MakeUpFactory{  
    public void make(String type){  
        System.out.println("这辆车在 中国 制造 ，销往东亚地区");  
    }  
}  
//德国工厂  
class GermanyFactory implements MakeUpFactory{  
    public void make(String type){  
        System.out.println("这辆车在 德国 制造，销往欧洲地区 ");  
    }  
}  
//小汽车的抽象类  
abstract class Car{  
    //获得小汽车的同时要指定制造地点  
    MakeUpFactory makeUpFactory;  
    abstract void intro();  
}  
//宝马745Li  
class Bmw_745Li extends Car{  
    public Bmw_745Li(MakeUpFactory mf){  
        this.makeUpFactory=mf;  
    }  
    private String type="Bmw_745Li";  
    public void intro(){  
        System.out.println("这辆宝马的型号是"+type+"");  
        makeUpFactory.make(type);  
    }  
}  
//宝马765Li  
class Bmw_765Li extends Car{  
    public Bmw_765Li(MakeUpFactory mf){  
        this.makeUpFactory=mf;  
    }  
    private String type="Bmw_765Li";  
    public void intro(){  
        System.out.println("这辆宝马的型号是"+type+"");  
        makeUpFactory.make(type);  
    }  
}  
//奥迪A8L  
class Audi_A8L extends Car{  
    public Audi_A8L(MakeUpFactory mf){  
        this.makeUpFactory=mf;  
    }  
    private String type="A8L";  
    public void intro(){  
        System.out.println("这辆奥迪的型号是"+type+"");  
        makeUpFactory.make(type);  
    }  
}  
//奥迪A6L  
class Audi_A6L extends Car{  
    public Audi_A6L(MakeUpFactory mf){  
        this.makeUpFactory=mf;  
    }  
    private String type="A6L";  
    public void intro(){  
        System.out.println("这辆奥迪的型号是"+type+"");  
        makeUpFactory.make(type);  
    }  
}  

 

 

package go.derek;  
//测试类,模拟客户端调用  
public class FactoryTest{  
    public static void main(String[] args){  
        //创建中国工厂，和德国工厂  
        MakeUpFactory china=new ChinaFactory();   
        MakeUpFactory germany=new GermanyFactory();   
        //创建宝马工厂对象，以制造地点为构造参数  
        CarFactory bmw=new BmwFactory(china);  
        //执行宝马工厂的流程  
        bmw.brand();  
        //获得指定型号的宝马车  
        Car car1=bmw.create("745Li");  
        car1.intro();  
        Car car2=bmw.create("765Li");  
        car2.intro();  
        //创建奥迪工厂对象，以制造地点为构造参数  
        CarFactory audi=new AudiFactory(germany);  
        //执行奥迪工程的流程  
        audi.brand();  
        //获得指定型号的奥迪车  
        Car car3=audi.create("A6L");  
        car3.intro();  
        Car car4=audi.create("A8L");  
        car4.intro();  
    }  
}  

 

 

运行结果如下

这是宝马工厂,采用 宝马 指定配件与制造工艺

这辆宝马的型号是Bmw_745Li

这辆车在 中国 制造 ，销往东亚地区

这辆宝马的型号是Bmw_765Li

这辆车在 中国 制造 ，销往东亚地区

这是奥迪工厂，采用 奥迪 指定配件与制造工艺

这辆奥迪的型号是A6L

这辆车在 德国 制造，销往欧洲地区 

这辆奥迪的型号是A8L

这辆车在 德国 制造，销往欧洲地区 

 

由这个例子可见，抽象工厂模式与工厂模式的区别就在与前者是以组合的形式来扩展，而后者是以继承的形式。两者都有特定的应用场景，工厂模式在增加产品方面很在行，但是对扩展非产品的需求则显得力不从心了。抽象设计模式则不然，增加产品不是他的本行，扩展非增加产品的需求时就很给力了。两者都是很重要的设计模式，值得好好去体会~

补充：软件开发 , Java ,