Java Factory概念学习第二课 （一般factory）

任意定制交通工具

上篇说到了实例化的控制，即控制对象的实例化个数，单例和多例。接下来慢慢过渡到工厂的概念。

先来考虑一下新的需求：Test类不仅仅需要汽车，还需要火车、飞机甚至宇宙飞船，那么怎么来方便的添加呢？

这个好说，写一个新的类Train:

class Train(){  
  
  public void run(){  
    
     System.out.println("火车呜呜呜地跑"); 
    
  }  
}

之前的Car类：

public class Car{
    public void run(){
       System.out.println("汽车突突突地跑");
    }
}

Test类：

public class Test{
  
     public static void main(String[] args){

          Car car = new Car();
          car.run();     
          Train train = new Train();       
          train.run();

     }

}

这时候我们只考虑添加一种交通工具的情况，但假如要添加很多种呢？假如不止run()一个方法，还有addOil()等，假如要替换一中交通工具，那么就要把Car car = new Car（）；全改了，这样会很麻烦。

这里考虑多态，把run抽象为接口：

public interface Moveable{
   void run();
}

Car和Train分别实现Moveable接口：

public class Car implements Moveable{
    @Override
    public void run(){
      
       System.out.println("汽车突突突地跑");
      
    }
}

public class Train implements Moveable{
    @Override
    public void run(){
      
       System.out.println("火车呜呜呜地跑");
      
    }
}

这时Test实例化Car和Train：

public class Test{
  
     public static void main(String[] args){

          Moveable car = new Car();
          car.run();     
          Moveable train = new Train();       
          train.run();

     }

}

此时的结构，假如想要增加或修改交通工具，只需要增加一个类实现Moveable如：

public class Plane implements Moveable{
    @Override
    public void run(){
      
       System.out.println("飞机嗖嗖的飞");
      
    }
}

修改的话只需从Moveable car = new Car();到Moveable car = new Plane();

以上内容基本是java典型的多态的应用，接下来引入工厂。

生产过程

回想上一篇的内容，使用new方法来实例化对象必然不会经过权限检查、对象数量限制等过程。

此时我们对汽车或者火车的生产过程添加一个中间过程，即工厂：

public class CarFactory{
  public Car getCar(){
    return new Car();
  }
}

这时的Test想要实例化汽车：

public class Test{
  
     public static void main(String[] args){

          CarFactory cf = new CarFactory();
          Moveable car = cf.getCar();
          car.run(); 

     }
}

这就完成了汽车生产的限制，当然，CarFactory里面可以加入任何的限制。

但是，如果我要生产另一种交通工具该怎么办？我们首先要加入TrainFactory类：

public class TrainFactory{
  public Train getTrain(){
    return new Train();
  }
}

然后在Test里面修改：

public class Test{
  
     public static void main(String[] args){

          TrainFactory cf = new TrainFactory();
          Moveable car = cf.getTrain();
          car.run(); 

     }

}

这样很麻烦。于是我们参考上面的思路，不妨再次使用多态的方法，将get交通工具的方法抽象出来：

public abstract class VehicleFactory{
  public abstract Moveable getVehicle();
}

我们把这个VehicleFactory当做父类，让CarFactory和TrainFactory来继承并实现它的getVehicle()方法：

public class CarFactory extends VehicleFactory{
  
  @Override
  public Moveable getCar(){
    return new Car();
  }
}

public class TrainFactory extends VehicleFactory{
    
  @Override
  public Moveable getTrain(){
    return new Train();
  }
}

此时，Test里面的实现：

public class Test{
  
     public static void main(String[] args){

          VehicleFactory cf = new TrainFactory();
          Moveable tar = cf.getVehicle();
          tar.run(); 

     }

}

此时只需将VehicleFactory cf = new TrainFactory();替换为VehicleFactory cf = new CarFactory();

此时同理，要想加入其他交通工具如扫把broom，首先要加入类Broom：

public class Broom implements Moveable{
    @Override
    public void run(){
      
       System.out.println("扫把咻咻咻地飞");
      
    }
}

再加入BroomFactory：

public class BroomFactory extends VehicleFactory{
    
  @Override
  public Moveable getBroom(){
    return new Broom();
  }
}

之后的工作就在Test里面自由实现了。
一般的工厂概念就这些，下一篇说一下更深一层的抽象工厂概念。

上一篇：单例、多例
下一篇：抽象factory