三种工厂模式学习

　　工厂模式为什么要使用工厂模式
　　先看下面一段代码 public class SendMessageContrller {  //    @Autowired //    private Producer producer;      public void sendMsg(String msg) throws Exception {         Producer producer = new Producer();         producer.sendByExchange(＂hi＂);     } }
　　我们常规的创建对象的方 new关键字 反射机制创建对象
　　那么这么做的 缺点 是什么呢? 对象创建和对象使用使用的职责耦合在一起,违反单一 原则； 当业务扩展时，必须修改代业务代码，违反了开闭原则；
　　我们可以使用工厂模式来创建对象,那么 工厂模式 有什么 优点 把对象的创建和使用的过程分开，对象创建和对象使用使用的职责解耦； 如果创建对象的过程很复杂，创建过程统一到工厂里管理，既减少了重复代码，也方 便以后对创建过程的修改维护； 当业务扩展时，只需要增加工厂子类，符合开闭原则；
　　工厂模式分为三种 简单工厂 工厂模式 抽象工厂 简单工厂
　　首先我们要生产的产品: public interface Fruit {      int price();     void draw();      }  public class Banana implements Fruit {     private int price = 60;     @Override     public int price() {         return price;     }      @Override     public void draw() {         System.out.print(＂仙人蕉＂);     }      public void setPrice(int price) {         this.price = price;     } }
　　简单工厂类: /**  * @Author: jimmy  * @Date: 2021/9/15 14:45  * @Description:  *   简单工厂 - 静态工厂模式  */ public class StaticFactory {          // 产品标志     public static final int TYPE_APPLE = 1;     public static final int TYPE_ORANGE = 2;     public static final int TYPE_BANANA = 3;      public static Fruit getFruit(int type){         if(TYPE_APPLE == type){             return  new Apple();         } else if(TYPE_ORANGE == type){             return new Orange(＂Peter＂,80);         } else if(TYPE_BANANA == type){             return new Banana();         }         return null;     }      /**      * 多方法工厂      * @return      */     public static Fruit getFruitApple(){         return new Apple();     }      public static Fruit getFruitOrange(){         return new Orange(＂Peter＂,80);     }      public static Fruit getFruitBanana(){         return new Banana();     } }
　　工厂测试类: public class FactoryTestClient {      public static void main(String[] args) {          System.out.println(＂--- 简单工厂模式 ---＂);         // 传入香蕉的标志,获取香蕉实例         Fruit fruit = StaticFactory.getFruit(StaticFactory.TYPE_BANANA);         fruit.draw();         System.out.println( fruit.price());     } }
　　输出结果:
　　--- 简单工厂模式 --- 仙人蕉60
　　可以看到简单工厂有 3个角色 Factory：工厂类，简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。 IProduct：抽象产品类，简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。 Product：具体产品类，是简单工厂模式的创建目标。
　　简单工厂模式的优缺点
　　优点: 客户端无需知道具体的创建产品逻辑,只需要知道具体参数即可通过简单工程获取实例 实现了创建和应用的解耦
　　缺点: 所有的产品都集中在一个工厂中,一旦不能正常工作，整个系统都要受到影响 系统的扩展相对困难,一旦添加新的产品需要修改工厂的逻辑来解决新产品,这就破坏了开闭原则.产品较多的时候也容易造成混乱 使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构 工厂模式
　　工厂方法模式属于类的创建型模式又被称为多态工厂模式。工厂方法模式的意义在于定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，仅负责声明具体工厂子类必须实现的接口。这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
　　先上代码:
　　工厂类: // 工厂父类(接口) public interface FruitFactory {     public Fruit getFruit(); }  // 具体产品对应的工厂 public class AppleFactory implements FruitFactory{     @Override     public Fruit getFruit(){         return new Apple();     } }
　　产品类(父类Fruit上面已经展示了) public class Apple implements Fruit {     private int price = 100;      public Apple(){}      public Apple(int price){         this.price = price;     }      @Override     public int price() {         return price;     }      @Override     public void draw() {         System.out.print(＂苹果红富士＂);     }      public void setPrice(int price) {         this.price = price;     } }
　　测试类 public class FactoryTestClient {      public static void main(String[] args) {                  System.out.println(＂--- 工厂模式 ---＂);         FruitFactory fruitFactory = new AppleFactory();         Fruit f = fruitFactory.getFruit();         f.draw();         System.out.println(f.price());      } }
　　输出结果:
　　--- 工厂模式 --- 苹果红富士100
　　工厂模式角色 IFactory（Creator）：抽象工厂类，描述了工厂的公共方法 Facotry（Concrete Creator）: 具体创建者 IProduct（Product）：抽象产品类，简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。 Product（Concrete Product）：具体产品类，是简单工厂模式的创建目标。
　　优缺点
　　优点: 更加符合开闭原则,新增产品的时候只需要增加相应的产品和工厂类即可 符合单一职责,每个工厂仅负责创建单一产品 不再使用静态方式,这样可以使用继承等结构
　　缺点: 扩展需新增的内容较多,产品和工厂都要增加会增加系统的类数量 抽象工厂
　　不废话直接上代码 public abstract class AbstractFactory {     // 获取水果     public abstract Fruit getFruit();     // 打包水果     public abstract Bag getBag(); }  public class OrangeFactory extends AbstractFactory{     @Override     public Fruit getFruit() {         return new Orange(＂非鸽传书＂, 5);     }      @Override     public Bag getBag() {         return new OrangeBag();     } }  /**  * 包装接口  */ public interface Bag {     void pack(); }  /**  * 桔子包装  */ public class OrangeBag implements Bag {     @Override     public void pack() {         System.out.print(＂--桔子使用网兜包装＂);     } }
　　Test public class FactoryTestClient {      public static void main(String[] args) {          AbstractFactory factory = new OrangeFactory();         Fruit of = factory.getFruit();         of.draw();         Bag bag = factory.getBag();         bag.pack();     } }
　　输出:
　　--- 抽象工厂模式 --- 砂糖桔--桔子使用网兜包装
　　抽象工厂角色 AbstractProduct（抽象产品类）：需要创建的产品的抽象类。 ConcreteProduct（具体产品类）：为实现抽象产品的某个具体产品类。 AbstractFactory（抽象工厂类）：工厂模式方法核心，创建一系列产品对象。 ConcreteFactory（具体工厂类）：实现抽象工厂中定义的创建产品的方法。
　　抽象工厂在针对产品簇的时候比较常用,与工厂模式区别在于将抽象工厂定义为抽象类而不是接口,这样就规范了具体产品类的基本制造产品流程. 三种模式简单对比
　　类型
　　定义
　　用法
　　使用方式
　　简单工厂模式
　　一个用于创建对象的接口，让子类决定实例化那个类
　　生成一个复杂对象
　　工厂参数传递类型获取对应产品
　　工厂模式
　　一个用于创建对象的接口，让子类决定实例化那个类
　　生成一个复杂对象
　　使用对应产品的类型的工厂创建产品
　　抽象工厂模式
　　它为创建一组相关或者是相互依赖的对象提供一个接口
　　生成一组复杂对象
　　使用对应工厂创建一组产品