【工厂模式】工厂方法模式、抽象工厂模式-简单例子

工厂方法模式、抽象工厂模式-简单例子

水w

2225人浏览 · 2024-04-19 14:53:35

水w · 2024-04-19 14:53:35 发布

简单工厂模式，请跳转到我的另一篇博客【工厂模式】简单工厂模式-简单例子-CSDN博客

四、工厂方法模式

（1）这部分还是不变，创建一个Car接口，和两个实现类。

public interface Car {
   void name();
}

public class WuLing implements Car{
  @Override
  public void name() {
    System.out.println("五菱");
  }
}

public class Tesla implements Car{
  @Override
  public void name() {
    System.out.println("特斯拉");
  }
}

（2）把车工厂提取成一个接口，

public interface CarFactory {
  Car getCar();
}

public class TeslaFactory implements CarFactory{
  @Override
  public Car getCar() {
    return new Tesla();
  }
}


public class WuLingFactory implements CarFactory{
  @Override
  public Car getCar(){
    return new WuLing();
  }
}

（3）这样的话，我再新增一种新车的时候就很方便了。

public class Mobai implements Car {
  @Override
  public void name(){
    System.out.println("mobai");
  }
}

public class MobaiFactory implements CarFactory{
  @Override
  public Car getCar() {
    return new Mobai();
  }
}

（4）创建一个Customer类，

public class Customer {
  public static void main(String[] args) {
    Car car1 = new WuLingFactory().getCar();
    Car car2 = new TeslaFactory().getCar();
    car1.name();
    car2.name();
    Car car3 = new MobaiFactory().getCar();
    car3.name();
  }
}

这样的话，原来的类我们是没有动的，并且随时可以动态扩展，满足开闭原则。

但是实现起来反而是非常麻烦的，因为从下图的目录结构中我们也可以看出，需要创建的类变多了。

画个流程图分析一下，

总结

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它通过定义一个用于创建对象的接口，但是让子类决定实例化哪个类。这样，工厂方法模式允许一个类的实例化延迟到其子类。

在工厂方法模式中，通常会有一个抽象的工厂类，该工厂类定义了一个抽象的方法，用于创建产品对象。具体的产品创建逻辑由子类实现，每个子类负责实例化特定类型的产品。这样，客户端代码可以通过调用工厂方法来创建所需的产品，而无需关心具体的实现细节。

工厂方法模式通常包括以下角色：

抽象工厂类（Abstract Factory Class）：定义了一个抽象的工厂方法，用于创建产品对象。通常是一个接口或抽象类。
具体工厂类（Concrete Factory Class）：实现了抽象工厂类，负责实际创建产品对象的逻辑。每个具体工厂类对应一种产品类型。
抽象产品类（Abstract Product Class）：定义了产品对象的接口或抽象类，描述了产品的公共属性和方法。
具体产品类（Concrete Product Class）：实现了抽象产品类定义的接口或抽象类，是真正被创建的产品对象。

工厂方法模式的优点在于可以将对象的创建逻辑移到子类中，使得主要的工厂类更加通用，而具体的产品实现则可以灵活地扩展和变化。同时，它也遵循了开闭原则，对扩展开放，对修改关闭。

总的来说，工厂方法模式提供了一种更加灵活的对象创建方式，适用于需要根据不同情况创建不同类型对象的场景。

简单工厂模式和工厂方法模式的对比

简单工厂模式（Simple Factory Pattern）和工厂方法模式（Factory Method Pattern）是两种不同的创建型设计模式，它们在对象创建的方式和角色分配上有一些不同之处。

角色定义：
- 简单工厂模式通常只涉及一个工厂类，该工厂类负责根据客户端的请求创建具体的产品对象。
- 工厂方法模式引入了抽象工厂类和具体工厂类，使得对象的创建逻辑更加灵活。抽象工厂类定义了一个抽象的工厂方法，而具体的产品创建逻辑则由具体工厂类实现。
创建逻辑：
- 在简单工厂模式中，工厂类通常包含一个静态方法，根据不同的参数或条件返回不同类型的产品对象。
- 而在工厂方法模式中，每个具体的产品都有对应的具体工厂类，该类负责创建特定类型的产品对象。这样，对象的创建逻辑被分散到了多个具体工厂类中。
扩展性：
- 简单工厂模式的扩展性相对较差，如果需要添加新的产品类型，则需要修改工厂类的代码，违反了开闭原则。
- 工厂方法模式遵循了开闭原则，因为具体的产品创建逻辑在具体工厂类中，所以可以通过添加新的具体工厂类来扩展系统，而不需要修改已有的代码。
复杂度：
- 简单工厂模式相对于工厂方法模式来说，实现起来较为简单，适用于简单的场景。
- 工厂方法模式的实现相对复杂一些，但提供了更高的灵活性和可扩展性，适用于需要根据不同情况创建不同类型对象的复杂场景。

总的来说，简单工厂模式适用于简单的对象创建场景，而工厂方法模式更适用于复杂的场景，需要更高的灵活性和可扩展性。

五、抽象工厂模式

（1）创建一个产品接口类，和两个实现类。

public interface PhoneProduct {
  void start();
  void shutdown();
  void call();
  void sendMes();
}

public class XiaomiPhone implements PhoneProduct{
  @Override
  public void start() {
    System.out.println("小米手机开机");
  }

  @Override
  public void shutdown() {
    System.out.println("小米手机关机");
  }

  @Override
  public void call() {
    System.out.println("小米手机打电话");
  }

  @Override
  public void sendMes() {
    System.out.println("小米手机发短信");
  }
}

public class HuaWeiPhone implements PhoneProduct{
  @Override
  public void start() {
    System.out.println("华为手机开机");
  }

  @Override
  public void shutdown() {
    System.out.println("华为手机关机");
  }

  @Override
  public void call() {
    System.out.println("华为手机打电话");
  }

  @Override
  public void sendMes() {
    System.out.println("华为手机发短信");
  }
}

（2）创建一个路由器接口类，和两个实现类。

public interface RouteProduct {
  void start();
  void shutdown();
  void setting();
  void openWife();
}

public class XiaomiRoute implements RouteProduct{
  @Override
  public void start() {
    System.out.println("小米路由器开机");
  }

  @Override
  public void shutdown() {
    System.out.println("小米路由器关机");
  }

  @Override
  public void setting() {
    System.out.println("小米路由器设置");
  }

  @Override
  public void openWife() {
    System.out.println("小米路由器打开wife");
  }
}

public class HuaWeiRoute implements RouteProduct{
  @Override
  public void start() {
    System.out.println("华为路由器开机");
  }

  @Override
  public void shutdown() {
    System.out.println("华为路由器关机");
  }

  @Override
  public void setting() {
    System.out.println("华为路由器设置");
  }

  @Override
  public void openWife() {
    System.out.println("华为路由器打开wife");
  }
}

（3）创建一个抽象工厂接口，已经两个系列产品的实现类。

public interface ProductFactory {
  PhoneProduct phoneProduct();

  RouteProduct routeProduct();
}


public class HuaWeiFactory implements ProductFactory{
  @Override
  public PhoneProduct phoneProduct() {
    return new HuaWeiPhone();
  }

  @Override
  public RouteProduct routeProduct() {
    return new HuaWeiRoute();
  }
}

public class XiaomiFactory implements ProductFactory{
  @Override
  public PhoneProduct phoneProduct() {
    return new XiaomiPhone();
  }

  @Override
  public RouteProduct routeProduct() {
    return new XiaomiRoute();
  }
}

（4）创建一个Client类，

public class Client {
  public static void main(String[] args) {
    System.out.println("----小米产品----");
    XiaomiFactory xiaomiFactory = new XiaomiFactory();
    PhoneProduct phoneProduct = xiaomiFactory.phoneProduct();
    RouteProduct routeProduct = xiaomiFactory.routeProduct();
    phoneProduct.call();
    routeProduct.openWife();

    System.out.println("----华为产品----");
    HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
    PhoneProduct phoneProduct1 = huaWeiFactory.phoneProduct();
    RouteProduct routeProduct1 = huaWeiFactory.routeProduct();
    phoneProduct1.call();
    routeProduct1.openWife();
  }
}