自学内容网 自学内容网

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)!