【简单工厂模式】
    在介绍工厂方法模式之前，先来认识一下简单工厂模式。它是属于创建型模式，但不属于23种设计模式之一。主要是因为其不符合6大设计原则中的总原则 - 开闭原则：就是说对扩展开放，对修改关闭。

    简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

    • 优点：比较好理解，简单易操作
    • 缺点：违反了设计模式的开闭原则，即对扩展开放，对修改关闭。当我们需要增加一个类型时，都需要修改工厂类 ```java /**
      • 球类 */ public interface Ball { void play(); }
    1. ```java
    2. /**
    3.  * 篮球
    4.  */
    5. public class BasketBall implements Ball {
    6.     @Override
    7.     public void play() {
    8.         System.out.println("打篮球");
    9.     }
    10. }
    1. /**
    2.  * 足球
    3.  */
    4. public class FootBall implements Ball {
    5.     @Override
    6.     public void play() {
    7.         System.out.println("踢足球");
    8.     }
    9. }
    1. /**
    2.  * 球类工厂类
    3.  */
    4. public class BallFactory {
    5.     public static Ball createBall(String type) {
    6.          if ("football".equals(type)) {
    7.              return new FootBall();
    8.          } else if ("basketball".equals(type)) {
    9.              return new BasketBall();
    10.          } else {
    11.              return null;
    12.          }
    13.     }
    14. }
    1. public class SimpleFactoryTest {
    2.     public static void main(String[] args) {
    3.         Ball footBall = BallFactory.createBall("football");
    4.         footBall.play();
    6.         Ball basketball = BallFactory.createBall("basketball");
    7.         basketball.play();
    8.     }
    9. }
    10. -----输出----
    11. 踢足球
    12. 打篮球

    【工厂方法模式】
    定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

    • 优点：
      • 降低了代码耦合度，对象的生成交给子类去完成
      • 实现了开放封闭原则 - 每次添加子产品 不需要修改原有代码

    • 缺点：

      • 增加了代码量，每个具体产品都需要一个具体工厂

      • 当增加抽象产品，也就是添加一个其他产品族，需要修改工厂，违背OCP（开闭原则）

        1. /**
        2. * 生产球类的工厂接口
        3. */
        4. public interface BallFactory {
        5. Ball createBall();
        6. }
        1. /**
        2. * 篮球工厂类
        3. */
        4. public class BasketBallFactory implements BallFactory {
        5. @Override
        6. public Ball createBall() {
        7.    return new BasketBall();
        8. }
        9. }
        /**
* 足球工厂类
*/
public class FootBallFactory implements BallFactory {
@Override
public Ball createBall() {
   return new FootBall();
}
}

        public class FactoryMethodTest {
public static void main(String[] args) {
   // 足球工厂
   FootBallFactory footBallFactory = new FootBallFactory();
   Ball footBall = footBallFactory.createBall();
   footBall.play();

   // 篮球工厂
   BasketBallFactory basketBallFactory = new BasketBallFactory();
   Ball basketBall = basketBallFactory.createBall();
   basketBall.play();
}
}
-----输出----
踢足球
打篮球