工厂设计模式

 

                简单的工厂设计模式
    
 例子: 任意定制交通工具的类型和生产过程
 
 首先定义一个接口，或者抽象类：
 
 1. 用来描述工具的类，所有子类的父类：
 
   public interface Moveable {
      public abstract void run();
   }
   
 2.  定义一个接口或抽象类，用来产生交通工具；
 
   public abstract class VehicleFactory {
      abstract Moveable create();
    }
  
    3.  定义一个交通工具：描述该交通工具的行为；
 
   public class Car implements Moveable{
    public void run(){
     System.out.println("车冒着烟......");
    }
   }
 
    4.  定义一个工厂，用来生产car的
    public class CarFactory extends VehicleFactory{
     @Override
     Moveable create() {
      return new Car();
     }
    }
 
 5.  最后使用： 同面向对象的多态，父类对象指向子类引用。
 
    VehicleFactory factory = new CarFactory();
    Moveable moveable = factory.create();
    moveable.run();
    
   简单工厂设计模式：
     1. 定义一个，一个类型的子类的父类，比如定义一个具体交通工具的父类。
                 抽取子类共有的方法：
    2. 定义一个抽象类，用来产生，接口的子类对象：
  
    3. 定义一个具体的交通工具，实现接口。
   
    4. 定义一个具体的工厂，实现抽象类。
   
    5.使用多态，先得到工厂产生对象，然后调用对象的方法：
   
   
   
    优点：
        1.良好的封装性，代码结构清晰：
    
        如果一个调用者需要具体的一个产品对象，只要知道这个产品的类名就可以了，
       不用知道创建对象的艰苦过程，降低了模块间的耦合性。
    
    
    2. 工厂方法模式的扩展性非常优秀：
   
        如果要添加，一个具体产品，只需要添加这个产品的类，然后去实现抽象方法，
       在抽象类中添加一个共有方法也很容易的：
       维护性：好对共有部分进行维护，很方便：
   
   
    缺点：

             产生产品系列的时候，会出现产品工厂患难；
             产生产品品种的时候，要改变太多。
        

                                                 抽象工厂设计模式
  
  定义： 抽象工厂生产了一系列产品，如果你想换掉一些列产品的时候
         或者想对这一系列产品基础之上扩展，想产生新的系列产品，
   以及想对这一系列的产品的生产过程进行控制，用抽象工厂.
   
    1.抽取这一系列的每一个具体产品的父类，作为抽象类，抽取公共的方法作为抽象方法。
   
    public abstract class Food {
     public abstract void eatting();
     }
     public abstract class Vehicle {
      public abstract void run();
                 }
                public abstract  class Weapon {
     public abstract void shooting();
    }
    
    2.抽取产生一系列产品的工厂的父类，作为抽象类，产生系列产品的共有方法作为抽象方法
   
          public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWanpon();
    public abstract Food createFood();
   }
   
    3.具体的每一个产品去继承共有的抽象类，实现共有的抽象方法：
      
   第一个系列的产品：
   
    public class AK47 extends Weapon{
    @Override
    public void shooting() {
     System.out.println("嗒嗒.....");
      }
   }
   
   public class Apple extends Food {
    @Override
    public void eatting() {
     System.out.println("apple.....");
    }
   }
   
   public class Car extends Vehicle {
    public void run(){
     System.out.println("冒着烟前进.....");
    }
   }
  
      第二个系列的产品：
   
   public class Broom extends Vehicle  {
    @Override
    public void run() {
     System.out.println("一路沙尘暴飞奔而来....");
    }
   }
   
      public class MagicStick extends Weapon{
    @Override
    public void shooting() {
     System.out.println("shoting hu hu hu ......");
    }
   }
   
   public class MushRoom extends Food{
    @Override
    public void eatting() {
     System.out.println("mushroom......");
    }
   }
          4. 具体的一个系列实现抽象抽象工厂类，实现抽象方法：

      第一种系列的工厂：
   
    
     public class DefaultFactory extends AbstractFactory{
     @Override
     public Food createFood() {
      return new Apple();
     }
     @Override
     public Vehicle createVehicle() {
      return new Car();
     }
     @Override
     public Weapon createWanpon() {
      return new AK47();
     }
    }
   
    第二种系列的产品工厂类：
   
    public  class MagicFactory extends AbstractFactory{
    @Override
    public Food createFood() {
     return new MushRoom();
    }
    @Override
    public Vehicle createVehicle() {
     return new Broom();
    }
    @Override
    public Weapon createWanpon() {
     return new MagicStick();
    }
   }
   
    5. 使用：
   
    第一种系列：
   
  public static void main(String [] args){
   AbstractFactory df = new  MagicFactory();
   Food food = df.createFood();
   food.eatting();
   Vehicle vehicle = df.createVehicle();
   vehicle.run();
   Weapon wanpon = df.createWanpon();
   wanpon.shooting();
 }
 
 
    第二种系列：
 public static void main(String [] args){
   AbstractFactory df = new  MagicFactory();
   Food food = df.createFood();
   food.eatting();
   Vehicle vehicle = df.createVehicle();
   vehicle.run();
   Weapon wanpon = df.createWanpon();
   wanpon.shooting();
 }  
 
    优点：
       1.只要改变工厂，就能改变所有的产品
    2. 很方便在原产品上的扩展，只要分别在每一个抽象类中添加，共有的方法，就能
           很容易的改变产品：
    例子: 比如手机的显示风格：只要改变一种风格，布局显示的背景等都改变了，这就用到
          了抽象工厂设计模式：