抽象工厂模式

Posted on June 8, 2018 本文总阅读量次

1. 设计模式之抽象工厂模式

在学习抽象工厂模式前要先了解一下工厂模式，而抽象工厂模式主要就是为了弥补工厂模式的缺点的，抽象~遵循了开闭原则

设计原则之开闭原则（Open Close Principle，缩写OCP）
类、模块、函数等对于拓展是开放的，但是对于修改是封闭的，当软件需要变化时，应该尽量通过拓展的方式来实现变化，而不是通过修改已有的代码来实现。（接口）
附上链接

简单工厂模式中没有抽象，直接创建一一对应就不符合开闭原则

而工厂模式已经引入了抽象，工厂方法模式组成：

1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 
工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！

1.  abstract class BMW {  
2.  public BMW(){  

4.  }  
5.  }  
6.  public class BMW320 extends BMW {  
7.  public BMW320() {  
8.  System.out.println("制造-->BMW320");  
9.  }  
10.  }  
11.  public class BMW523 extends BMW{  
12.  public BMW523(){  
13.  System.out.println("制造-->BMW523");  
14.  }  
15.  }  

创建工厂类：

1.  interface FactoryBMW {  
2.  BMW createBMW();  
3.  }  

5.  public class FactoryBMW320 implements FactoryBMW{  

7.  @Override  
8.  public BMW320 createBMW() {  

10.  return new BMW320();  
11.  }  

13.  }  
14.  public class FactoryBMW523 implements FactoryBMW {  
15.  @Override  
16.  public BMW523 createBMW() {  

18.  return new BMW523();  
19.  }  
20.  }

最后是抽象工厂模式，他工厂模式有些相似，但是他的特点：
抽象工厂模式是工厂方法模式的升级版本，他用来创建 一组相关或者相互依赖的对象。
比如宝马320系列使用空调型号A和发动机型号A，而宝马230系列使用空调型号B和发动机型号B，那么使用抽象工厂模式，在为320系列生产相关配件时，就无需制定配件的型号，它会自动根据车型生产对应的配件型号A。

 //发动机以及型号    
  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");    
  }    
 }   

创建工厂类：
  //创建工厂的接口    
  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();    
  }    
  }

参考https://blog.csdn.net/jason0539/article/details/44976775

2.android设计模式之策略模式

策略模式跟上面工厂模式也有相似，都是利用调用方法是传入不同的接口对象

一般的做法是在一个类里写不同的方法，然后根据实际情况用一连串的if-else或switch来选择对应的方法。这种方法多了后，这个类会变得臃肿，难以修改。(类似于简单工厂模式)

所以如果把不同的策略抽象出来，提供一个统一的接口，为每一个策略写一个实现类，这样客户端就能通过调用接口的不同的实现类来动态替换策略。这就是策略模式

//定义一类的策略接口
interface ComputerStrategy{
      int computer(int num);
}

//定义一些不同的类实现接口
public class ComputerA implement ComputerStrategy{
      public int computer(int mun){
        ....
 }
}
public class ComputerB implement ComputerStrategy{
    ....
}

//定义一个方法，引用该接口（可以创一个类在封装一下这个方法）
  public  int  Computer（ComputerStrategy computers）{
      computers.computer（..）;
}

更好的代码参考：https://blog.csdn.net/qq_25806863/article/details/68623134