工厂模式详解

什么是工厂模式

工厂模式是用来创建对象，不过与一般使用new关键字直接实例化一个对象不同，这种方法是通过创建一个工厂类并实现一个公共的接口，然后通过调用这个接口来实现对象的创建。将对象的创建过程封装起来，以此达到解耦合的效果。

就比如线程池的创建过程就是利用了工厂模式。

ExecutorService pool = Executors.newFixedThreadPool(10);
pool.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});

工厂模式一般会涉及以下几个部分

• 抽象产品：工厂可以创建的产品的类型，一般是一个接口或者抽象类。
• 具体产品：实现抽象产品的具体对象，每个具体工厂都负责创建特定的具体产品
• 抽象工厂：一个用来创建对象的接口，内部包含一个或多个实现对象的方法(工厂可以生产的产品类别)，但没有具体的实现的过程，一般为接口或者抽象类。
• 具体工厂：实现了创建对象(生产产品)的具体过程，每个具体工厂都负责创建特定的具体产品

工厂模式的种类

这里我举一个快餐厅的例子来讲解下面三种模式

1.简单工厂模式(Simple Factory Pattern)

简单工厂模式是根据传入的参数，决定创建那种具体产品类。
简单工厂模式就好比是我们常见的一些快餐店，只有一个店面和一个厨房，这个厨房负责顾客所有的需求
具体实现方法：
首先定义一个公共接口(抽象产品)，然后定义3个具体实现类(具体产品),实现这个接口Hamburger，Friedchicken，Chips最后实现具体工厂Factory

//抽象食物接口
public interface Food {
    void cook();
}
//汉堡
public class Hamburger implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个汉堡");
    }
}
//炸鸡
public class Friedchicken implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个炸鸡");
    }
}
//薯条
public class Chips implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个薯条");
    }
}
//简单工厂类
public class Factory {
    public static Food product(String s){
        if(s.equals("汉堡")){
            return new Hamburger();
        } else if (s.equals("炸鸡")) {
            return new Friedchicken();
        } else if (s.equals("薯条")) {
            return new Chips();
        }else {
            System.out.println("没有这个食物");
            return null;
        }
    }
}
//客户端
public class Client {
    public static void main(String[] args) {
        Food hamburger = Factory.product("汉堡");
        hamburger.cook();
        Food friedchicken = Factory.product("炸鸡");
        friedchicken.cook();
        Food chips = Factory.product("薯条");
        chips.cook();
    }
}

运行结果

优点：

• 用户不需要知道创建对象的具体类和过程，只需知道工厂类和产品类的接口即可
• 简单方便实现

缺点：

• 违法开发封闭原则： 每当增加一种产品时，都要修改工厂类的代码，增加了维护的成本
• 工厂类责任太重： 工厂类负责创建所有不同的产品，导致如果后期添加的产品太多，会使工厂类代码变得复杂难以维护

2.工厂方法模式(Factory Method Pattern)

现在我们为了提高生产效率，将厨房分成了几个区域，每个区域只负责一种食物
定义一个创建对象的接口，但是让子类决定实例化哪一个类。

//抽象工厂类
public interface Factory {
    Food product();
}
//抽象食物接口
public interface Food {
    void cook();
}
//薯条
public class Chips implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个薯条");
    }
}
//炸鸡
public class Friedchicken implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个炸鸡");
    }
}
//汉堡
public class Hamburger implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个汉堡");
    }
}
//薯条工厂
public class ChipsFactory implements Factory{
    @Override
    public Food product() {
        return new Chips();
    }
}
//炸鸡工厂
public class FriedchickenFactory implements Factory{
    @Override
    public Food product() {
        return new Friedchicken();
    }
}
//汉堡工厂
public class HamburgerFactory implements Factory{
    @Override
    public Food product() {
        return new Hamburger();
    }
}
//客户端
public class Client {
    public static void main(String[] args) {
        //创建一个汉堡工厂
        Factory factory1 = new HamburgerFactory();
        Food hamburger = factory1.product();
        hamburger.cook();
        //创建一个炸鸡工厂
        Factory factory2 = new FriedchickenFactory();
        Food friedChick = factory2.product();
        friedChick.cook();
        //创建一个薯条工厂
        Factory factory3 = new ChipsFactory();
        Food chips = factory3.product();
        chips.cook();
    }
}

运行结果

优点： 遵循开闭原则，可以在不修改原代码的情况下添加新的产品，增强了代码的可维护性
缺点： 增加了代码的复杂性，需要给每一个产品创建一个具体工厂，当产品数量太多时，可能导致工厂类的大量增长

3.抽象工厂模式(Abstract Factory Pattern)

现在这个快餐店为了更好的销售产品，推出了一系列的套餐。
抽象工厂模式提供了一个接口，用于创建一系列相关对象，而不是一个单一的对象。它允许客户端使用抽象接口来创建一整套相关的对象，而不必指定具体类
抽象产品

//抽象食物接口
public interface Food {
    void cook();
}
public interface Drinks {
    void cook();
}

具体产品

//薯条
public class Chips implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个薯条");
    }
}
//炸鸡
public class Friedchicken implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个炸鸡");
    }
}
//汉堡
public class Hamburger implements Food{
    @Override
    public void cook() {
        System.out.println("做了一个汉堡");
    }
}
//可乐
public class Coke implements Drinks{

    @Override
    public void cook() {
        System.out.println("制作一杯可乐");
    }
}
//果汁
public class Juice implements Drinks{

    @Override
    public void cook() {
        System.out.println("制作一杯果汁");
    }
}

抽象工厂

//抽象工厂类
public interface Factory {
    Food createFood();
    Drinks createDrinks();
}

具体工厂

//套餐一工厂
public class Meal1 implements Factory{

    @Override
    public Food createFood() {
        return new Hamburger();
    }

    @Override
    public Drinks createDrinks() {
        return new Coke();
    }
}
//套餐二工厂
public class Meal2 implements Factory{
    @Override
    public Food createFood() {
        return new Friedchicken();
    }

    @Override
    public Drinks createDrinks() {
        return new Juice();
    }
}
//套餐三工厂
public class Meal3 implements Factory{
    @Override
    public Food createFood() {
        return new Chips();
    }

    @Override
    public Drinks createDrinks() {
        return new Juice();
    }
}

客户端

//客户端
public class Client {
    public static void main(String[] args) {
        //套餐一
        Factory meal1 = new Meal1();
       meal1.createFood().cook();
       meal1.createDrinks().cook();
        System.out.println("============");
       //套餐二
       Factory meal2 = new Meal2();
       meal2.createDrinks().cook();
       meal2.createFood().cook();
        System.out.println("============");
       //套餐三
        Factory meal3 = new Meal3();
        meal3.createFood().cook();
        meal3.createDrinks().cook();

    }
}

优点： 分离了具体类的生产，符合开闭原则 不只是创建一个单一的产品，而是创建一系列相关的产品
缺点： 使代码变得更复杂

总结

简单工厂模式：由一个具体工厂实现所有的具体产品

• 定义一个工厂类，这个类里包含创建对象的具体过程，客户端直接调用工厂类的方法，并根据传入的参数决定创建那个对象
• 工厂类承担了全部实例化的过程，如果产品过多，代码会变得复杂
• 不方便添加新的产品，违反开闭原则
• 适用于创建对象的逻辑相对简单，产品较少且不经常发生变化的情况

工厂方法模式：每一个具体产品都有一个具体工厂生产

• 定义一个实例化的接口，将实例化的过程推迟到子类，由子类决定实例化哪个类
• 符合开闭原则，添加新产品时只需添加一个子类
• 适用于系统有多种产品，并且创建产品的过程可以根据环境变化

抽象工厂模式： 可以将不同种类的产品进行搭配生产，每个具体工厂负责生产一种搭配

• 提供一个创建一系列有关联的对象的接口，不需要指定具体的类
• 创建的是一系列相关产品对象(产品族)，而不是单一产品
• 可以更好的处理有复杂依赖关系的产品
• 也遵循开闭原则，添加新产品族时只需添加一个子类，而不是修改现有代码
• 适用于系统需要创建多组相关的产品对象，而这些对象的创建过程比较复杂，而且客户端需要消费这一系列产品的时候

以上就是博主对工厂模式的分享，如果有不懂的或者有其他见解的欢迎在下方评论或者私信博主，也希望多多支持博主之后和博客！！🥰🥰