创建型模式01：简单工厂模式、工厂方法模式、抽象工厂模式

简单工厂模式

产品类：设置一个产品抽象类，写几个具体产品
工厂类：使用case语句来选择要生产的产品
客户类：创建工厂，生产具体产品

package creationalpattern.factorymethod.simple;
/**
 * 客户类
 * @author heinika
 *简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。 
      先来看看它的组成： 
         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。         
         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 


         因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createBMW(int type)方法需要新增case），这显然是违背开闭原则的。
        于是工厂方法模式作为救世主出现了！！！！！！！
 */
public class Customer {

    public static void main(String[] args) {
        Factory factory = new Factory();
        factory.creatBMW(320);
        factory.creatBMW(325);
    }
}

/**
 * 简单工厂类
 * @author heinika
 *
 */
public class Factory {
    public BMW creatBMW(int type){
        switch(type){
        case 320:
            return new BMW320();
        case 325:
            return new BMW325();
        default:
            break;
        }
        return null;
    }
}

/**
 * 产品抽象类
 */
abstract class BMW {

}

public class BMW320 extends BMW{
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}

public class BMW325 extends BMW{
    public BMW325() {  
        System.out.println("制造-->BMW325");  
    }  
}

工厂方法模式

产品类：设置一个产品抽象类，写几个具体产品（同简单工厂）
工厂类：设置一个工厂接口，不同的多个工厂制造不同的车
客户类：创建具体工厂，生产具体产品

/**
 *  工厂方法模式仿佛已经很完美的对对象的创建进行了包装，
 *  使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。
 *  当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。
 * @author heinika
 *
 */
public class Customer {

    public static void main(String[] args) {
        Factory factory320 = new BMW320Factory();
        factory320.creatBMW();
        Factory factory325 = new BMW325Factory();
        factory325.creatBMW();
    }

}

/**
 * 工厂类
 * 相较于简单工厂，制造的方法变成抽象的了
 * @author heinika
 *
 */
public interface Factory {
    BMW creatBMW();
}

public class BMW320Factory implements Factory {

    @Override
    public BMW creatBMW() {
        return new BMW320();
    }

}

public class BMW325Factory implements Factory {

    @Override
    public BMW creatBMW() {
        return new BMW325();
    }

}
/**
 * 产品抽象类
 */
abstract class BMW {

}

public class BMW320 extends BMW{
    public BMW320() {  
        System.out.println("制造-->BMW320");  
    }  
}

public class BMW325 extends BMW{
    public BMW325() {  
        System.out.println("制造-->BMW325");  
    }  
}

抽象工厂模式

产品类：设置多个产品抽象类，并对应写几个具体产品
工厂类：设置一个工厂接口抽象不同产品的制造方法，多个工厂制造不同产品的不同类型
客户类：创建具体工厂，生产具体的多个产品

/**
 * 抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。
 * 比如宝马320系列使用空调型号A和发动机型号A，而宝马230系列使用空调型号B和发动机型号B，
 * 那么使用抽象工厂模式，在为320系列生产相关配件时，
 * 就无需制定配件的型号，它会自动根据车型生产对应的配件型号A。
 * @author Administrator
 *
 *
 *无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，
 *在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。
 *在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。
 *经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，
 *加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，
 *它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
 */
public class Customer {

    public static void main(String[] args) {
        FactoryBMW320 factoryBMW320 = new FactoryBMW320();
        factoryBMW320.createAircondition();
        factoryBMW320.createEngine();
        FactoryBMW325 factoryBMW325 = new FactoryBMW325();
        factoryBMW325.createAircondition();
        factoryBMW325.createEngine();
    }

}

/**
 * 工厂类
 * 相较于工厂模式，有多个制造方法。
 * 工厂能实现不同的搭配
 * @author heinika
 *
 */
public interface AbstractFactory {
    //制造发动机  
    public Engine createEngine() ;
    //制造空调   
    public Aircondition createAircondition();
}

//为宝马320系列生产配件    
public class FactoryBMW320 implements AbstractFactory{    

  @Override    
  public Engine createEngine() {      
      return new EngineB();    
  }    
  @Override    
  public Aircondition createAircondition() {    
      return new AirconditionB();  
  }    
}    

//为宝马325系列生产配件    
public class FactoryBMW325 implements AbstractFactory{    

  @Override    
  public Engine createEngine() {      
      return new EngineA();    
  }    
  @Override    
  public Aircondition createAircondition() {    
      return new AirconditionA();  
  }    
}    

/**
 * 产品抽象类
 */
package creationalpattern.factorymethod.abstractfactory;
/**
 * 产品类   空调及其型号
 * @author Administrator
 *
 */
public interface Aircondition {

}

/**
 * 产品类   发动机及其型号
 * @author Administrator
 *
 */
public interface Engine {

}

public class AirconditionA implements Aircondition {
    public AirconditionA(){
        System.out.println("制造-->AirconditionA");
    }
}

public class EngineA implements Engine {
    public EngineA(){
        System.out.println("制造-->EngineA");
    }
}