玩转工厂模式

下面再写一个工厂模式的例子

 

[java][/java] view plaincopy

  1. package go.derek;
  2. //这是一个抽象工厂类
  3. public abstract class CarFactory{
  4.     abstract void brand();
  5.     abstract Car create(String type);
  6. }
  7. //宝马工厂,继承了抽象工厂类
  8. class BmwFactory extends CarFactory{
  9.     public void brand(){
  10.         System.out.println(“这是宝马工厂,采用 宝马 指定配件与制造工艺”);
  11.     }
  12.     //宝马的工厂方法
  13.     public Car create(String type) {
  14.         if(type.equals(“745Li”)){
  15.             return new Bmw_745Li();
  16.         }
  17.         else if(type.equals(“765Li”)){
  18.             return new Bmw_765Li();
  19.         }
  20.         else
  21.             return null;
  22.     }
  23. }
  24. //奥迪工厂,继承了抽象工厂类
  25. class AudiFactory extends CarFactory{
  26.     public void brand(){
  27.         System.out.println(“这是奥迪工厂,采用 奥迪 指定配件与制造工艺”);
  28.     }
  29.     //奥迪的工厂方法
  30.     public Car create(String type) {
  31.         if(type.equals(“A8L”)){
  32.             return new Audi_A8L();
  33.         }
  34.         else if(type.equals(“A6L”)){
  35.             return new Audi_A6L();
  36.         }
  37.         else
  38.             return null;
  39.     }
  40. }
  41. //小汽车的抽象类
  42. abstract class Car{
  43.     abstract void intro();
  44. }
  45. //宝马745Li
  46. class Bmw_745Li extends Car{
  47.     private String type=”Bmw_745Li”;
  48.     public void intro(){
  49.         System.out.println(“这辆宝马的型号是”+type+””);
  50.     }
  51. }
  52. //宝马765Li
  53. class Bmw_765Li extends Car{
  54.     private String type=”Bmw_765Li”;
  55.     public void intro(){
  56.         System.out.println(“这辆宝马的型号是”+type+””);
  57.     }
  58. }
  59. //奥迪A8L
  60. class Audi_A8L extends Car{
  61.     private String type=”A8L”;
  62.     public void intro(){
  63.         System.out.println(“这辆奥迪的型号是”+type+””);
  64.     }
  65. }
  66. //奥迪A6L
  67. class Audi_A6L extends Car{
  68.     private String type=”A6L”;
  69.     public void intro(){
  70.         System.out.println(“这辆奥迪的型号是”+type+””);
  71.     }
  72. }
[java][/java] view plaincopy

  1. package go.derek;
  2. //测试类,模拟客户端调用
  3. public class FactoryTest{
  4.     public static void main(String[] args){
  5.         //创建宝马工厂对象
  6.         CarFactory bmw=new BmwFactory();
  7.         //执行宝马工厂的流程
  8.         bmw.brand();
  9.         //获得指定型号的宝马车
  10.         Car car1=bmw.create(“745Li”);
  11.         car1.intro();
  12.         Car car2=bmw.create(“765Li”);
  13.         car2.intro();
  14.         //创建奥迪工厂对象
  15.         CarFactory audi=new AudiFactory();
  16.         //执行奥迪工程的流程
  17.         audi.brand();
  18.         //获得指定型号的奥迪车
  19.         Car car3=audi.create(“A6L”);
  20.         car3.intro();
  21.         Car car4=audi.create(“A8L”);
  22.         car4.intro();
  23.     }
  24. }

运行结果如下

 

这是宝马工厂,采用 宝马 指定配件与制造工艺
这辆宝马的型号是Bmw_745Li
这辆宝马的型号是Bmw_765Li
这是奥迪工厂,采用 奥迪 指定配件与制造工艺
这辆奥迪的型号是A6L
这辆奥迪的型号是A8L

对比上一篇简单工厂设计模式,可以看出,产品Car基本一致,只不过工厂类有了区别,简单工厂是一个工厂生产所有汽车,工厂模式则是一个工厂只生产一种品牌的车。显然如果有很多品牌,很多型号的车的话,依赖关系要比简单模式简单的多,扩展起来也方便的多。

标签