设计模式之工厂模式

最新推荐文章于 2023-09-24 13:05:15 发布

原创最新推荐文章于 2023-09-24 13:05:15 发布 · 263 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #工厂模式

设计模式专栏收录该内容

10 篇文章

订阅专栏

本文详细介绍了简单工厂模式、工厂方法模式及抽象工厂模式的概念、UML图与示例代码，帮助读者理解不同场景下如何选择合适的设计模式。

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

一、简单工厂模式
1.简单抽象工厂模式，又称作静态工厂方法模式，由工厂（使用switch）决定创建具体产品，不符合开放关闭原则。

2.简单工厂模式UML图
这里写图片描述

3.简单工厂模式示例

package cn.sy.edu.factory.simplefactory;

/**
 * 封装一个OPeration类，包含numberA、numberB两个参数
 * 然后加减乘除不同运算方式类继承此类，并用不同行为覆盖getResult方法，进行不同运算
 * ---如果此时在添加运算方式，只要添加一个运算方式类继承OPeration类就行类，不用修改以前的代码
 * ？？？但此时有一个问题，我们客户端应该选择以何种运算方式实例化OPeration类
 * @author shier
 *
 */
public abstract class OPeration {
    protected double numberA;
    protected double numberB;

    public abstract double getResult();     
}

/**
 * 加法类
 * @author shier
 *
 */
class OperationAdd extends OPeration{

    @Override
    public double getResult() {
        return numberA + numberB;
    }
}

/**
 * 减法类
 * @author shier
 *
 */
class OperationSub extends OPeration{

    @Override
    public double getResult() {
        return numberA - numberB;
    }
}

/**
 * 乘法类
 * @author shier
 *
 */
class OperationMul extends OPeration{

    @Override
    public double getResult() {
        return numberA * numberB;
    }
}

/**
 * 除法类
 * @author shier
 *
 */
class OperationDiv extends OPeration{

    @Override
    public double getResult() {
        if(numberB == 0){
            throw new RuntimeException("被除数不可以为0");
        }
        return numberA / numberB;
    }
}


package cn.sy.edu.factory.simplefactory;

/**
 * 提供一个简单工厂类用来实例化运算方式类，同时使用了多态
 * 这样增加运算方式的时候在这里添加一种实例化方式就行了
 * @author shier
 *
 */
public class OperationFactory {

    public static OPeration createOPeration(String operation){
        OPeration oper = null;

        switch (operation) {
        case "+":
            oper = new OperationAdd();
            break;

        case "-":
            oper = new OperationSub();
            break;
        case "*":
            oper = new OperationMul();
            break;
        case "/":
            oper = new OperationDiv();
            break;      
        }

        return oper;
    }
}

/*
 * 计算器类
 */
public class OperationMachine {
    public static void main(String[] args) {
        OPeration  oper = OperationFactory.createOPeration("+");

        oper.numberA = 10.0;
        oper.numberB = 23.0;

        double result = oper.getResult();
        System.out.println(result);

    }
}

二、工厂方法模式
1.工厂方法模式定义：定义一个用于创建对象的接口，让子类决定实例化那一个类。工厂方法使一个类的实例化延迟到其子类。

2.工厂方法的UML图
这里写图片描述

3.工厂方法模式示例

package cn.sy.edu.factory.methodfactory;

/**
 * 雷锋抽象类（或者接口，更好用接口）
 * 提供扫地、洗衣、买米
 * @author shier
 *
 */
public abstract class LeiFen {

    abstract void sweep();

    abstract void wash();

    abstract void buyRice();
}

class StudentLeiFen extends LeiFen{

    @Override
    void sweep() {
        System.out.println("大学生洗地");

    }

    @Override
    void wash() {
        System.out.println("大学生洗衣");

    }

    @Override
    void buyRice() {
        System.out.println("大学生买米");        
    }   
}

class VolunteerLeiFen extends LeiFen{
    @Override
    void sweep() {
        System.out.println("社区工作者洗地");

    }

    @Override
    void wash() {
        System.out.println("社区工作者洗衣");

    }

    @Override
    void buyRice() {
        System.out.println("社区工作者买米");      
    }
}

package cn.sy.edu.factory.methodfactory;

/**
 * 雷锋工厂抽象类
 * 大学生雷锋工厂、社区工作者雷锋工厂分别产生不同类型的雷锋
 * 这样比简单工厂模式，更近一步，因为简单工厂模式增加一个条件，就要在工厂类中加一个case判断
 * 违反了开放-封闭原则，而工厂方法只是扩展并没有修改
 * 但是工厂方法模式把简单工厂的内部逻辑判断转移到了客户端代码进行，现在要增加功能要修改客户端
 * @author shier
 *
 */
public abstract class LeifenFactory {
    abstract LeiFen createLfiFen();
}

class StudentLeiFenFactory extends LeifenFactory{

    @Override
    LeiFen createLfiFen() {
        return new StudentLeiFen();
    }

}

class VolunteerLeiFenFactory extends LeifenFactory{

    @Override
    LeiFen createLfiFen() {
        return new VolunteerLeiFen();
    }

}

三、抽象工厂模式
1.抽象工厂模式的定义：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

2.抽象工厂模式的UML图
这里写图片描述

3.抽象工厂模式+反射示例

/**
 * 用户接口包含insert、getUser两个方法
 * @author shier
 *
 */
public interface User {
    public void insert(User user);

    public User getUser(int id);

}

/**
 * OracleUser实现User接口
 * @author shier
 *
 */
public class OracleUser implements User{
    @Override
    public void insert(User user) {
        System.out.println("在oracle中给User表增加一条记录");

    }

    @Override
    public User getUser(int id) {
        System.out.println("在oracle中根据id得到User表增加一条记录");
        return null;
    }

}

/**
 * SqlserverUser实现User接口
 * @author shier
 *
 */
public class SqlserverUser implements User{

    @Override
    public void insert(User user) {
        System.out.println("在sqlsever中给User表增加一条记录");

    }

    @Override
    public User getUser(int id) {
        System.out.println("在sqlsever中根据id得到User表增加一条记录");
        return null;
    }

}

/**
 * 部门接口，提供insert、getDepartment两个方法
 * @author shier
 *
 */
public interface Department {
    public void insert(Department Department);

    public Department getDepartment(int id);
}

/**
 * OracleDepartment实现Department
 * @author shier
 *
 */
public class OracleDepartment implements Department{
    @Override
    public void insert(Department Department) {
        System.out.println("在oracle中给Department表增加一条记录");

    }

    @Override
    public Department getDepartment(int id) {
        System.out.println("在oracle中根据id得到Department表增加一条记录");
        return null;
    }
}

/**
 * SqlseverDepartment实现Department
 * @author shier
 *
 */
public class SqlseverDepartment implements Department{

    @Override
    public void insert(Department Department) {
        System.out.println("在sqlsever中给Department表增加一条记录");

    }

    @Override
    public Department getDepartment(int id) {
        System.out.println("在sqlsever中根据id得到Department表增加一条记录");
        return null;
    }
}

/**
 * 工厂接口，提供createUser、createDepartment两个方法
 * @author shier
 *
 */
public interface Factory {
    User createUser();

    Department createDepartment();
}

/**
 * OracleFactory实现Factory接口，覆写createUser、createDepartment分别产生OracleUse类和OracleDepartment类
 * @author shier
 *
 */
public class OracleFactory implements Factory{

    @Override
    public User createUser() {
        return new OracleUser();
    }

    @Override
    public Department createDepartment() {      
        return new OracleDepartment();
    }

}

/**
 * SqlseverFactory实现Factory接口，覆写createUser、createDepartment分别产生SqlserverUser类和SqlseverDepartment类
 * @author shier
 *
 */
public class SqlseverFactory implements Factory{

    @Override
    public User createUser() {
        return new SqlserverUser();
    }

    @Override
    public Department createDepartment() {
        return new SqlseverDepartment();
    }

}

/**
 * 使用抽象工厂模式+反射，解决数据库更换的问题
 * @author shier
 *
 */
public class DataFactory<T> {

    public  static User createUser(String name){
        try {
            return  (User) Class.forName(name).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
    }

    public static Department createDepartment(String name){
        try {
            return (Department) Class.forName(name).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
    }
}