设计模式详解---工厂模式

2023-12-15 04:59:38

1. 简介

????????工厂模式(Factory Pattern)是一种常见的创建型设计模式,用于创建对象的过程中封装对象的实例化逻辑。工厂模式通过定义一个共同的接口来创建对象,而不暴露具体的创建逻辑给客户端。这样可以提高代码的灵活性、可维护性和可扩展性。

2. 工厂模式的优点

  • 封装了对象的创建过程,客户端只需要关心接口而无需关心具体的实现细节。
  • 提供了一种可扩展的方式来创建对象,可以轻松添加新的具体产品类。
  • 通过工厂方法可以集中管理对象的创建,提高代码的可维护性和重用性。

3.三种工厂模式概念以及对比

工厂模式可以分为三种主要的变体:

  1. 简单工厂模式(Simple Factory Pattern):简单工厂模式通过一个工厂类来创建对象,客户端通过传递不同的参数给工厂类来获取不同类型的对象。工厂类根据参数的不同,内部选择实例化哪个具体的产品类。这种模式隐藏了对象的创建逻辑,但违背了开闭原则,因为每次新增产品类型时都需要修改工厂类。

  2. 工厂方法模式(Factory Method Pattern):工厂方法模式将对象的创建委托给具体的工厂类。每个具体的工厂类都实现了一个工厂接口或抽象类,负责创建一类具体的产品对象。客户端通过调用工厂方法来获取所需的产品对象。工厂方法模式符合开闭原则,因为增加新的产品类型只需要添加对应的具体工厂类即可。

  3. 抽象工厂模式(Abstract Factory Pattern):是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

这些变体都属于工厂模式,目的是为了封装对象的创建过程,提供一种简单、灵活、可扩展的方式来创建对象。选择哪种变体取决于具体的应用需求和设计考虑。

4. 案例及代码

我们以创建Product产品为例,设计一下简单工厂模式、工厂方法模式和抽象工厂模式

4.1.简单工厂模式

你只需要告诉工厂需要啥产品,他就给你生产出来,这种设计的弊端就是不遵守开闭原则,当新增了一个产品,需要修改工厂的代码:

具体代码:

/**
 * @Author: stukk
 * @Description: 产品接口
 * @DateTime: 2023-12-14 21:52
 **/
public interface Product {
    void getProductName();
}

/**
 * @Author: stukk
 * @Description: 产品1类
 * @DateTime: 2023-12-14 21:55
 **/
public class Product1 implements Product {

    @Override
    public void getProductName() {
        System.out.println("这是产品1");
    }
}
/**
 * @Author: stukk
 * @Description: 产品2类
 * @DateTime: 2023-12-14 21:55
 **/
public class Product2 implements Product {

    @Override
    public void getProductName() {
        System.out.println("这是产品2");
    }
}
/**
 * @Author: stukk
 * @Description: 产品3类
 * @DateTime: 2023-12-14 21:55
 **/
public class Product3 implements Product {

    @Override
    public void getProductName() {
        System.out.println("这是产品3");
    }
}

/**
 * @Author: stukk
 * @Description: 简单工厂类
 * @DateTime: 2023-12-14 22:10
 **/
public class Factory {
    public static Product createProduct(String type){
        if(type.equalsIgnoreCase("product1")){
            return new Product1();
        }else if(type.equalsIgnoreCase("product2")){
            return new Product2();
        }else if(type.equalsIgnoreCase("product3")){
            return new Product3();
        }else{
            throw new IllegalArgumentException("Invalid product type");
        }
    }
}


/**
 * @Author: stukk
 * @Description: 客户端代码示例
 * @DateTime: 2023-12-14 21:51
 **/
public class FactoryModeExample {
    public static void main(String[] args) {
        Product product = Factory.createProduct("product1");
        product.getProductName();
        product = Factory.createProduct("product2");
        product.getProductName();
        product = Factory.createProduct("product4");
    }
}

运行效果:

4.2.工厂方法模式

定义多个具体工厂类,用户需要哪个产品就去调用哪个产品的工厂的方法,比如你需要华为手机,你就去华为手机的工厂要:

具体代码:

/**
 * @Author: stukk
 * @Description: 产品接口
 * @DateTime: 2023-12-14 21:52
 **/
public interface Product {
    void getProductName();
}

/**
 * @Author: stukk
 * @Description: 产品1类
 * @DateTime: 2023-12-14 21:55
 **/
public class Product1 implements Product {

    @Override
    public void getProductName() {
        System.out.println("这是产品1");
    }
}
/**
 * @Author: stukk
 * @Description: 产品2类
 * @DateTime: 2023-12-14 21:55
 **/
public class Product2 implements Product {

    @Override
    public void getProductName() {
        System.out.println("这是产品2");
    }
}
/**
 * @Author: stukk
 * @Description: 产品3类
 * @DateTime: 2023-12-14 21:55
 **/
public class Product3 implements Product {

    @Override
    public void getProductName() {
        System.out.println("这是产品3");
    }
}

/**
 * @Author: stukk
 * @Description: 工厂接口
 * @DateTime: 2023-12-14 22:10
 **/
public interface Factory {
      Product createProduct();
}


/**
 * @Author: stukk
 * @Description: 产品1的工厂类
 * @DateTime: 2023-12-14 23:02
 **/
public class Product1Factory implements Factory {

    @Override
    public Product createProduct() {
        return new Product1();
    }
}


/**
 * @Author: stukk
 * @Description: 产品2的工厂类
 * @DateTime: 2023-12-14 23:02
 **/
public class Product2Factory implements Factory {

    @Override
    public Product createProduct() {
        return new Product2();
    }
}


/**
 * @Author: stukk
 * @Description: 产品3的工厂类
 * @DateTime: 2023-12-14 23:02
 **/
public class Product3Factory implements Factory {

    @Override
    public Product createProduct() {
        return new Product3();
    }
}


/**
 * @Author: stukk
 * @Description: 客户端代码示例
 * @DateTime: 2023-12-14 21:51
 **/
public class FactoryMethodExample {
    public static void main(String[] args) {
//        需要产品1:
        Factory factory = new Product1Factory();
        Product product = factory.createProduct();
        product.getProductName();

//        产品2
        factory = new Product2Factory();
        product = factory.createProduct();
        product.getProductName();
    }
}



运行结果:?

4.3.抽象工厂模式

现在太晚了,抽象工厂模式明天再写

文章来源:https://blog.csdn.net/m0_54409739/article/details/135004939
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。