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

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.抽象工厂模式

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