设计模式之--工厂方法和抽象工厂

/*
工厂模式概念：实例化对象，用工厂方法代替new操作
包括工厂方法模式和抽象工厂模式，其中，抽象方法是工厂方法的扩展
工厂模式意图：定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化
工厂方法把实例化的工作推迟到子类中实现
什么情况下适合工厂模式：
1：有一组类似的对象需要创建
2：在编码时不能预见需要创建哪种类的实例
3：系统需要考虑拓展性，不应依赖于产品类实例如何被创建、组合和表达的细节
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。（一个abstract或者一个interface）   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   (至少两个abstract或abstract)
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。   
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
简单工厂模式：
客户不去创建宝马车，客户去和工厂要，工厂去创建这个车
工厂方法模式（包含简单工厂模式）：
宝马车系列越来越多，一个工厂无法创建所有的宝马车，分出来许多具体的工厂，每个具体的工厂只能创建一个产品，但是宝马工厂还是个抽象
抽象工厂模式：
宝马车必须配置空调，工厂开始生产宝马车和空调

简单工厂模式：
1：产品类
abstract class BMW {
public BMW(){

}
}

public class BMW320 extends BMW {
public BMW320() {
System.out.println("制造-->BMW320");
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println("制造-->BMW523");
}
}
2：工厂类
public class Factory {
public BMW createBMW(int type) {
switch (type) {
case 320:
return new BMW320();

case 523:
return new BMW523();

default:
break;
}
return null;
}
}
3：客户类
public class Customer {
public static void main(String[] args) {
Factory factory = new Factory();
BMW bmw320 = factory.createBMW(320);
BMW bmw523 = factory.createBMW(523);
}
}
工厂方法模式：
1：产品类
abstract class BMW {
public BMW(){

}
}
public class BMW320 extends BMW {
public BMW320() {
System.out.println("制造-->BMW320");
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println("制造-->BMW523");
}
}
2：工厂类：
interface FactoryBMW {
BMW createBMW();
}

public class FactoryBMW320 implements FactoryBMW{

@Override
public BMW320 createBMW() {

return new BMW320();
}

}
public class FactoryBMW523 implements FactoryBMW {
@Override
public BMW523 createBMW() {

return new BMW523();
}
}
3：客户类
public class Customer {  
   public static void main(String[] args) {  
       FactoryBMW320 factoryBMW320 = new FactoryBMW320();  
       BMW320 bmw320 = factoryBMW320.createBMW();  
 
       FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
       BMW523 bmw523 = factoryBMW523.createBMW();  
   }  
} 
抽象工厂模式：
1：产品类
//发动机以及型号  
public interface Engine {  

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

//空调以及型号  
public interface Aircondition {  

}  
public class AirconditionA extends Aircondition{  
   public AirconditionA(){  
       System.out.println("制造-->AirconditionA");  
   }  
}  
public class AirconditionB extends Aircondition{  
   public AirconditionB(){  
       System.out.println("制造-->AirconditionB");  
   }  
} 
2：工厂类
//创建工厂的接口  
public interface AbstractFactory {  
   //制造发动机
   public Engine createEngine();
   //制造空调 
   public Aircondition createAircondition(); 
}  

//为宝马320系列生产配件  
public class FactoryBMW320 implements AbstractFactory{  
     
   @Override  
   public Engine createEngine() {    
       return new EngineA();  
   }  
   @Override  
   public Aircondition createAircondition() {  
       return new AirconditionA();  
   }  
}  
//宝马523系列
public class FactoryBMW523 implements AbstractFactory {  
 
    @Override  
   public Engine createEngine() {    
       return new EngineB();  
   }  
   @Override  
   public Aircondition createAircondition() {  
       return new AirconditionB();  
   }  
} 
3：用户类
public class Customer {  
   public static void main(String[] args){  
       //生产宝马320系列配件
       FactoryBMW320 factoryBMW320 = new FactoryBMW320();  
       factoryBMW320.createEngine();
       factoryBMW320.createAircondition();
         
       //生产宝马523系列配件  
       FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
       factoryBMW320.createEngine();
       factoryBMW320.createAircondition();
   }  
}

 */