简单工厂模式：定一个工厂类，可以根据不同的参数，返回不同的类的实例，这些类通常有共同的父类

    优点：
    高内聚，松耦合。使用工厂类时，只需要传入正确的参数，就可以获取需要的对象，无需知道其实现过程。

    实现：
    业务场景：例如我需要创建一个咖啡店，当客户需要某种咖啡并且店内可以提供的时候，我就为其提供一杯咖啡。这时候，这家咖啡店就可以当作一个咖啡工厂，生产出来的咖啡可以被当作产品，咖啡名称可以当作参数。工厂可以根据不同的参数，返回不同的产品，这就是简单工厂模式。

    1、咖啡类（产品）

    1. /**
    2.  * 咖啡类（父类）
    3.  */
    4. public abstract class Coffee {
    6.     /**
    7.      * 制作咖啡
    8.      */
    9.     public abstract void makeCoffee();
    11. }
    13. /**
    14.  * 蓝山咖啡
    15.  */
    16. public class CoffeeLanshan extends Coffee{
    18.     public void makeCoffee(){
    19.         System.out.println("制作了一杯蓝山咖啡");
    20.     }
    21. }
    23. /**
    24.  * 猫屎咖啡
    25.  */
    26. public class CoffeeMaoShi extends Coffee{
    28.     public void makeCoffee(){
    29.         System.out.println("制作了一杯猫屎咖啡");
    30.     }
    31. }

    2、咖啡工厂类

    1. /**
    2.  * 咖啡工厂类
    3.  */
    4. public class CoffeeFactory {
    5.     public static Coffee getCoffee(String name){
    6.         Coffee coffee = null;
    7.         switch (name){
    8.             case "蓝山咖啡":
    9.                 coffee = new CoffeeLanshan();
    10.                 break;
    11.             case "猫屎咖啡":
    12.                 coffee = new CoffeeMaoShi();
    13.                 break;
    14.             default:
    15.                 System.out.println("抱歉，店内没有该咖啡");
    16.                 break;
    17.         }
    18.         if (coffee != null){
    19.             coffee.makeCoffee();
    20.         }
    21.         return coffee;
    22.     }
    23. }

    3、测试

    1. /**
    2.  * 简单工厂测试类
    3.  */
    4. public class TestSimpleFactory {
    6.     public static void main(String [] args){
    7.         Coffee coffeeLanshan = CoffeeFactory.getCoffee("蓝山咖啡");
    8.         Coffee coffeeMaoshi = CoffeeFactory.getCoffee("猫屎咖啡");
    9.         Coffee coffeeWuming = CoffeeFactory.getCoffee("无名咖啡");
    10.     }
    11. }

    测试结果：
    image.png

    同时，可优化工厂类，添加一个菜单，用户直接从菜单选择

    1. /**
    2.  * 咖啡工厂类
    3.  */
    4. public class CoffeeFactory {
    5.     /**
    6.      * 菜单
    7.      */
    8.     public static final class menu {
    9.         public static final String LAN_SHAN = "蓝山咖啡";
    10.         public static final String MAO_SHI = "猫屎咖啡";
    11.     }
    13.     public static Coffee getCoffee(String name){
    14.         Coffee coffee = null;
    15.         switch (name){
    16.             case menu.LAN_SHAN:
    17.                 coffee = new CoffeeLanshan();
    18.                 break;
    19.             case menu.MAO_SHI:
    20.                 coffee = new CoffeeMaoShi();
    21.                 break;
    22.             default:
    23.                 System.out.println("抱歉，店内没有该咖啡");
    24.                 break;
    25.         }
    26.         if (coffee != null){
    27.             coffee.makeCoffee();
    28.         }
    29.         return coffee;
    30.     }
    31. }
    33. /**
    34.  * 简单工厂测试类
    35.  */
    36. public class TestSimpleFactory {
    38.     public static void main(String [] args){
    39.         Coffee coffeeLanshan = CoffeeFactory.getCoffee(CoffeeFactory.menu.LAN_SHAN);
    40.         Coffee coffeeMaoshi = CoffeeFactory.getCoffee(CoffeeFactory.menu.MAO_SHI);
    41.         Coffee coffeeWuming = CoffeeFactory.getCoffee("无名咖啡");
    42.     }
    43. }