【知了堂学习笔记】——设计模式之工厂模式-优快云博客

本文链接：https://blog.youkuaiyun.com/TANGLHUI/article/details/79155402

本文详细介绍了三种工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。通过实例代码讲解了每种模式的应用场景、优缺点及其实现方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

工厂模式分为三类：简单工厂模式、工厂方法模式、抽象工厂模式

工厂方法模式：
- 一个抽象产品类，可以派生多个具体的产品类
- 一个抽象工厂类，可以派生出多个具体的工厂类
- 每一个具体工厂类只能创建一个具体产品类的实例
抽象工厂模式：
- 多个抽象产品类，可以派生多个具体的产品类
- 一个抽象工厂类，可以派生出多个具体的工厂类
- 每一个具体工厂类可以创建多个具体的产品类
区别:
1.工厂方法模式只有一个抽象的产品类，而抽象工厂模式有多个抽1象产品类。
2.工厂方法模式具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

1.简单工厂模式

具有一个静态方法，用来接收参数，并根据参数来决定返回实现同一个接口的不同类的实现。

package factory;

/**
 * 定义简单工厂类
 * @author Administrator
 *
 */
public class SimpleFactory {
    public static void main(String[] args) {
        try {
            SimpleFactory.factory("erha");
            SimpleFactory.factory("jinmao");
            SimpleFactory.factory("samoye");
            SimpleFactory.factory("haha");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
    public static Product factory(String productName) throws Exception{
        if(productName.equals("erha")){
            return new Erha();
        }else if(productName.equals("jinmao")){
            return new Jinmao();
        }else if(productName.equals("samoye")){
            return new Samoye();
        }else{
            throw new Exception("没有该产品");
        }

    }
}

class Erha implements Product{
    public Erha(){
        System.out.println("二哈玩具被生产出来了");
    }
}

class Jinmao implements Product{
    public Jinmao(){
        System.out.println("金毛玩具被生产出来了");
    }
}

class Samoye implements Product{
    public Samoye(){
        System.out.println("萨摩耶玩具被生产出来了");
    }
}

简单工厂模式的核心就是一个SimpleFactory类，拥有必要的逻辑判断和产品的生产的方法，只需要交付订单，就能得到相应的产品。

缺点：
1.每次新增都需要修改SimpleFactory类的源码，当产品之间关系复杂的时候，相应的SimpleFactory类的逻辑判断也非常的复杂
2.整个系统都依赖SimpleFactory类，只要SimpleFactory类一出问题，就进入不能工作的状态

2.工厂方法

为工厂类定义了接口，用多态削弱了工厂类的职能

public interface Factory {
    public Product create();    
}

定义一个产品接口

public interface Product {}

实现了产品接口的产品类

class Erha implements Product{
    public Erha(){
        System.out.println("二哈玩具被生产出来了");
    }
}

class Jinmao implements Product{
    public Jinmao(){
        System.out.println("金毛玩具被生产出来了");
    }
}

class Samoye implements Product{
    public Samoye(){
        System.out.println("萨摩耶玩具被生产出来了");
    }
}

具体创建产品对象的具体工厂类

package factory;

//创建二哈的工厂
public class CreateErha implements Factory{
    public Product create() {
        return new Erha();
    }
}

//创建金毛的工厂
class CreateJinmao implements Factory{
    public Product create() {
        return new Jinmao();
    }

}

//创建萨摩耶的工厂
class CreateSamoye implements Factory{
    public Product create() {
        return new Samoye();
    }
}

工厂方法是把创建的产品放到实现了工厂接口的不同工厂类里面，不会因为一个工厂类出现问题而全部出现问题。

缺点：产品负责的等级结构的时候，就会形成复杂的产品树，不易维护。

3.抽象工厂（创建一系列互相关联和互相依赖的对象）
工厂方法是用来创建一个产品，没有分类的概念，而抽象工厂就是创建一系列产品，重点就在于产品的分类

可以二哈和金毛分别定义两个产品接口，以对他们进行分类

//二哈接口
public interface ErhaInterface {}

//金毛接口
public interface JinmaoInterface {}

分别创建这两个接口的具体产品

package factory;

public class ErhaA implements ErhaInterface{
    public ErhaA(){
        System.out.println("二哈-A被生产出来了");
    }
}

class ErhaB implements ErhaInterface{
    public ErhaB(){
        System.out.println("二哈-B被生产出来了");
    }
}

class JinmaoA implements JinmaoInterface{
    public JinmaoA(){
        System.out.println("金毛-A被生产出来了");
    }
}

class JinmaoB implements JinmaoInterface{
    public JinmaoB(){
        System.out.println("金毛-B被生产出来了");
    }
}

产品部分我们准备好了，接下来我们来处理工厂部分，我们先来定义工厂行为接口

package factory;

public interface AbstractFactory {
    public ErhaInterface creatErhaInterface();

    public JinmaoInterface creatJinmaoInterface();
}

接下来我创造具体的工厂类，我们根据上面产品的接口，把型号A的产品分为一类，由一个工厂来管理，把型号为B的产品有另一个工厂管理，根据这个分类，我们可以实现如下的两个具体工厂类

package factory;

//创建型号为A的工厂
public class EahaFactoryA implements ErhaInterface{
    //创建二哈-A
    public ErhaA createErhaA(){
        return new ErhaA();
    }
    public JinmaoA createJinmaoA(){
        return new JinmaoA();
    }
}
//创建型号为B的工厂
class EahaFactoryB implements ErhaInterface{
    //创建二哈-B
    public ErhaB createErhaB(){
        return new ErhaB();
    }
    public JinmaoB createJinmaoB(){
        return new JinmaoB();
    }
}