Java设计模式——简单工厂模式（完整详解，附有代码+案例）

5.2简单工厂模式

5.2.1 概述

简单工厂不是一种设计模式，反而比较像是一种编程习惯。

不属于GOF的23种经典设计模式

5.2.2 结构

简单工厂包含下角色：

• 抽象产品：定义了产品的规范，描述了产品的主要特性和功能
• 具体产品：实现或者继承抽象产品的子类
• 具体工厂：提供了创建具体产品的方法，调用者通过该方法获取产品对象

5.2.3 实现

对5.1 中案列进行修改

// 咖啡工厂
public class SimpleFactory {
    //提供方法,创建具体咖啡
    public Coffee createCoffee(String type){
        Coffee coffee = null;
        if ("american".equals(type)){
            coffee = new AmericanCoffee(); //多态
        }else if ("latte".equals(type)){
            coffee = new LatteCoffee(); //多态
        }else {
            throw new RuntimeException("没有这种咖啡！");
        }
      
        return coffee;
    }
}
=========================================================
  // 咖啡类(父类)--抽象类
public abstract class Coffee {
  
  //每个咖啡都有名字，所以抽取到父类，定义为抽象方法
    public abstract String getName();

    public void addMilk(){
        System.out.println("加奶...");
    }

    public void addSugar(){
        System.out.println("加糖...");
    }
}
==========================================================
  // 美式咖啡类 继承 咖啡类
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }

    public void show(){
        System.out.println("我是美式咖啡....");
    }
}
==========================================================
  // 拿铁咖啡类 继承 咖啡类
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
==========================================================
 // 咖啡店类
public class CoffeeStore {
    public Coffee orderCoffee(String type){
        //此处解除了咖啡店类和具体的咖啡类的依赖，降低了耦合

        // 创建工厂对象目的是创建具体的咖啡
       SimpleFactory sf = new SimpleFactory();
       // 创建咖啡，返回具体的咖啡对象
        Coffee coffee = sf.createCoffee(type);

        coffee.addSugar();
        coffee.addMilk();

        // 将具体的咖啡对象返回
        return coffee;
    }
}
=========================================================
  public class Test {
    public static void main(String[] args) {

        // 创建咖啡店对象，进行点咖啡
        CoffeeStore store = new CoffeeStore();
        //隐含了多态，在工厂里
        Coffee coffee = store.orderCoffee("american");

        String name = coffee.getName();
        System.out.println(name);
       //输出：加奶...  加糖...  美式咖啡
    }
}

工厂处理创建对象的细节，一旦有了SimpleCoffeeFactory类，CoffeeStore类中的orderCoffee就变成了SimpleCoffeeFactory类的客户，后期如果需要Coffee对象直接从工厂获取即可。这样解除了具体咖啡类和Coffee类的耦合，同时又产生了新的耦合，如：CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，工厂对象和具体咖啡对象的耦合。

后期如果再加新品种的咖啡，我们势必要需求修改SimpleCoffeeFactory的代码，违反了开闭原则。但是工厂类的客户端可能有很多，比如创建美团外卖等，这样只需要修改工厂类的代码，省去其他的修改操作。

5.2.4 优缺点

优点：

封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

缺点：

增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

5.2.5 扩展—静态工厂

将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式中的。代码如下：

// 咖啡工厂-----静态工厂
public class SimpleFactory {
    // 工厂类中的创建对象的功能定义为静态，就是静态工厂模式，
    public static Coffee createCoffee(String type){
        Coffee coffee = null;
        if ("american".equals(type)){
            //多态
            coffee = new AmericanCoffee();
        }else if ("latte".equals(type)){
            //多态
            coffee = new LatteCoffee();
        }else {
            throw new RuntimeException("没有这种咖啡！");
        }
        return coffee;
    }
}
=======================================================
  // 咖啡类(父类)
public abstract class Coffee {
    public abstract String getName();

    public void addMilk(){
        System.out.println("加奶...");
    }

    public void addSugar(){
        System.out.println("加糖...");
    }
}
====================================================
  // 美式咖啡类
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }

    public void show(){
        System.out.println("我是美式咖啡....");
    }
}
=========================================================
  // 拿铁咖啡类
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
=======================================================
  // 咖啡店类
public class CoffeeStore {
    public Coffee orderCoffee(String type){
        //此处解除了咖啡店类和具体的咖啡类的依赖，降低了耦合

       //  // 创创建工厂对象目的是创建具体的咖啡
       // SimpleFactory sf = new SimpleFactory();
       // // 创建咖啡，返回具体的咖啡对象
       //  Coffee coffee = sf.createCoffee(type);

        // 用静态工厂模式，就不用创建工厂对象
        //直接用工厂类名调用里面的创建具体咖啡对象的静态方法即可
        Coffee coffee = SimpleFactory.createCoffee(type);

        coffee.addSugar();
        coffee.addMilk();

        // 将具体的咖啡对象返回
        return coffee;
    }
}
=========================================================
  public class Test {
    public static void main(String[] args) {

        // 创建咖啡店对象，进行点咖啡
        CoffeeStore store = new CoffeeStore();
        //隐含了多态，在工厂里
        Coffee coffee = store.orderCoffee("american");

        String name = coffee.getName();
        System.out.println(name);
    }
}

原文地址：https://blog.csdn.net/weixin_54555405/article/details/142389819

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！