简单工厂模式,工厂方法模式与抽象工厂模式学习总结

最新推荐文章于 2023-04-21 08:55:49 发布
最新推荐文章于 2023-04-21 08:55:49 发布
阅读量2.1k 收藏 9
点赞数 2
分类专栏： # 设计模式 文章标签： 设计模式 简单工厂模式 工厂方法模式 抽象工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaofengcanyuelong/article/details/78945527
版权

一、概念及类图

1、简单工厂模式(静态工厂模式)
在简单工厂模式中,工厂类可以根据参数的不同返回不同的类的实例。
这里写图片描述
2、工厂方法模式(多态模式)
这里写图片描述
工厂方法模式的核心是抽象工厂类Factory,各种具体工厂类继承抽象工厂类并实现在抽象工厂类中定义的工厂方法,从而让客户只关心抽象产品和抽象工厂,不用管具体返回的是哪一种具体产品,也不用关心它是如何被具体工厂创建的。
3、抽象工厂模式
该模式提供了一个创建一系列相关或相互依赖对象的接口。
这里写图片描述

二、简单工厂模式与工厂方法模式实例

1、简单工厂模式—简单计算器

//抽象运算类---
public abstract class Operation {
    private double numberA=0;
    private double numberB=0;

    public double getNumberA() {
        return numberA;
    }
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }
    public double getNumberB() {
        return numberB;
    }
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public abstract double GetResult();

}

//加法类
public class OperationAdd extends Operation{

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        double result=0;
        result=getNumberA()+getNumberB();
        return result;
    }
}

//除法类
public class OperationDiv extends Operation{

    @Override
    public double GetResult() {
        double result=0;
        result=getNumberA()/getNumberB();
        return result;
    }


}
//乘法类
public class OperationMul extends Operation{

    @Override
    public double GetResult() {
        double result=0;
        result=getNumberA()*getNumberB();
        return result;
    }

}

//减法类
public class OperationSub extends Operation{

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        double result=0;
        result=getNumberA()-getNumberB();
        return result;
    }

}

/**
 * 运算工厂类---根据运算符的不同来创建不同实例对象
 *
 */
public class OperationFactory {
    public static Operation createOperation(String operate){
        Operation operation=null;
        switch (operate) {
        case "+":
            operation=new OperationAdd();
            break;
        case "-":
            operation=new OperationSub();
            break;
        case "*":
            operation=new OperationMul();
            break;
        case "/":
            operation=new OperationDiv();
            break;
        }
        return operation;
    }

}

//客户端
public class Show {
    public static void main(String[] args) {
        System.out.println("请输入数字A:");
        Scanner sc=new Scanner(System.in);
        String strNumberA=sc.nextLine();
        System.out.println("请输入运算符(+,-,*,/):");
        String strOperate=sc.nextLine();
        System.out.println("请输入数字B:");
        String strNumberB=sc.nextLine();
        Operation operation = OperationFactory.createOperation(strOperate);
        operation.setNumberA(Double.parseDouble(strNumberA));
        operation.setNumberB(Double.parseDouble(strNumberB));
        double result = operation.GetResult();
        System.out.println("结果为:"+result);
        sc.close();
    }
}

2、工厂方法模式—简单计算器

/*
 * 工厂接口
 */
public interface IFactory {
    Operation CreateOperation();
}

/*
 * 加法类工厂
 */
public class AddFactory implements IFactory{

    @Override
    public Operation CreateOperation() {
        return new OperationAdd();
    }

}
/*
 * 除法类工厂
 */
public class DivFactory implements IFactory{

    @Override
    public Operation CreateOperation() {
        return new OperationDiv();
    }
}

/*
 * 乘法类工厂
 */
public class MulFactory implements IFactory{

    @Override
    public Operation CreateOperation() {
        return new OperationMul();
    }

}
/*
 * 减法类工厂
 */
public class SubFactory implements IFactory{

    @Override
    public Operation CreateOperation() {
        return new OperationSub();
    }

}

//运算类
public abstract class Operation {
    private double numberA=0;
    private double numberB=0;

    public double getNumberA() {
        return numberA;
    }
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }
    public double getNumberB() {
        return numberB;
    }
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public abstract double GetResult();

}

//加法类
public class OperationAdd extends Operation{

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        double result=0;
        result=getNumberA()+getNumberB();
        return result;
    }
}

//除法类
public class OperationDiv extends Operation{

    @Override
    public double GetResult() {
        double result=0;
        result=getNumberA()/getNumberB();
        return result;
    }


}

//乘法类
public class OperationMul extends Operation{

    @Override
    public double GetResult() {
        double result=0;
        result=getNumberA()*getNumberB();
        return result;
    }

}

//减法类
public class OperationSub extends Operation{

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        double result=0;
        result=getNumberA()-getNumberB();
        return result;
    }

}

/*
 * 客户端展示----工厂方法模式实现简单计算器
 */
public class Show {
    public static void main(String[] args) {
        IFactory iFactory=new AddFactory();
        Operation operation=iFactory.CreateOperation();
        operation.setNumberA(1);
        operation.setNumberB(2);
        double result=operation.GetResult();
        System.out.println("结果: "+result);
    }

}

三、抽象工厂模式实例之数据库访问程序

(1)、版本1

//客户端
public class Client {
    public static void main(String[] args) {
        User user=new User();
        SqlserverUser sqlserverUser=new SqlserverUser();
        sqlserverUser.Insert(user);
        sqlserverUser.GetUser(1);

    }

}
//sql Server数据库操作user
public class SqlserverUser {
    public void Insert(User user){
        System.out.println("SQL Server中給User表添加一條記錄");
    }
    public User GetUser(int id){
        System.out.println("SQL Server中根據id得到User表中的一條記錄");
        return null;
    }

}
//用户对象
public class User {
    private int _id;
    private String _name;
    public int get_id() {
        return _id;
    }
    public void set_id(int _id) {
        this._id = _id;
    }
    public String get_name() {
        return _name;
    }
    public void set_name(String _name) {
        this._name = _name;
    }


}
分析:这里因为SqlserverUser sqlserverUser=new SqlserverUser();这行代码写死在SqlServer了,即没有灵活性,如果这里具有灵活性(多态),那么在执行sqlserverUser.Insert(user);sqlserverUser.GetUser(1);这两句代码时就不用考虑是哪个数据库了。

(2)、版本二—>使用抽象工厂模式。

//用户接口--->抽象产品A
public interface IUser {
    void InsertUser(User user);
    User GetUser(int id);

}
//部门接口--->抽象产品B
public interface IDepartment {
    void Insert(Department department);

    Department GetDeparment(int id);

}
//抽象工厂
public interface IFactory {
    IUser CreateUser();

    IDepartment createDepartment();

}
//Access数据库访问--->具体工厂1
public class AccessFactory implements IFactory{

    @Override
    public IUser CreateUser() {
        return new AccessUser();//类的实例化放在子类中,封装new AccessUser()所造成的变化
    }

    @Override
    public IDepartment createDepartment() {
        return new AccessDepartment();
    }

}
//SqlServer数据库--->具体工厂2
public class SqlServerFactory implements IFactory{

    @Override
    public IUser CreateUser() {
        return new SqlserverUser();
    }

    @Override
    public IDepartment createDepartment() {
        return new SqlserverDepartment();
    }

}

//具体产品类A
public class SqlserverUser implements IUser{

    @Override
    public void InsertUser(User user) {
        System.out.println("SQL Server中給User表添加一條記錄");

    }

    @Override
    public User GetUser(int id) {
        System.out.println("SQL Server中根據id得到User表中的一條記錄");
        return null;
    }

}
//具体产品类A
public class AccessUser implements IUser{

    @Override
    public void InsertUser(User user) {
        System.out.println("在Access中給User表添加一條記錄");
    }

    @Override
    public User GetUser(int id) {
        System.out.println("在Access中根據id查找User表的一條記錄");
        return null;
    }

}

//具体产品类B
public class SqlserverDepartment implements IDepartment{

    @Override
    public void Insert(Department department) {
        System.out.println("在SQL Server中給department表新增一條記錄");
    }

    @Override
    public Department GetDeparment(int id) {
        System.out.println("在SQL Server中根據id從department表中取出一條記錄");
        return null;
    }


}
//具体产品类B
public class AccessDepartment implements IDepartment{

    @Override
    public void Insert(Department department) {
        System.out.println("在Access中給Department表新增一條記錄");

    }

    @Override
    public Department GetDeparment(int id) {
        System.out.println("在Access中根據id得到department表中的一條記錄");
        return null;
    }

}


//用户类
public class User {
    private int _id;
    private String _name;
    public int get_id() {
        return _id;
    }
    public void set_id(int _id) {
        this._id = _id;
    }
    public String get_name() {
        return _name;
    }
    public void set_name(String _name) {
        this._name = _name;
    }


}
//客户端
public class Client {
    public static void main(String[] args) {
        User user=new User();
        IFactory factory=new SqlServerFactory();
        IUser iUser=factory.CreateUser();
        iUser.InsertUser(user);
        iUser.GetUser(1);

        Department department=new Department();
        IDepartment iDepartment=factory.createDepartment();
        iDepartment.Insert(department);
        iDepartment.GetDeparment(1);
    }

}

分析:
1、在使用了抽象工厂模式后,通过IFactory factory=new SqlServerFactory();这行代码来实现数据库的切换。
2、如果要新增一个表对象(抽象产品),则需要大量的改动。

(3)、版本三—>借助简单工厂改进抽象工厂
去掉原有的IFactory抽象工厂即两个具体工厂,用下面的DataAccess类来代替。


public class DataAccess {
    private static String db="Sqlserver";
//  private static String db="Access";

    /*
     * 根据db来决定实例化不同的类
     */
    public static IUser CreateUser(){
        IUser result=null;
        switch (db) {
        case "Sqlserver":
            result=new SqlserverUser();
            break;
        case "Access":
            result=new AccessUser();
            break;
        }
        return result;
    }

    public static IDepartment CreateDepartment(){
        IDepartment result=null;
        switch (db) {
        case "Sqlserver":
            result=new SqlserverDepartment();
            break;
        case "Access":
            result=new AccessDepartment();
            break;
        }
        return result;
    }

}
public class Client {
    public static void main(String[] args) {
        User user=new User();
        Department department=new Department();
        IUser iUser=DataAccess.CreateUser();//直接通过DataAccess获得想要的表对象
        iUser.InsertUser(user);
        iUser.GetUser(1);

        IDepartment iDepartment=DataAccess.CreateDepartment();
        iDepartment.Insert(department);
        iDepartment.GetDeparment(1);
    }

}

分析:这样把表对象的创建放入DataAccess中,在DataAccess中通过db来判断此时是哪一个数据库,从而实例化相应的表对象,当需要修改数据库时,只需要改动db即可。另外,在DataAccess中有大量的分支判断,代码可以通过反射进一步优化,让db变量的值在客户端被指定,而不是事前就在DataAccess中写出。

    // 数据库名称
    private static String db = "Sqlserver";
    // 包名----》改成SqlserverDepartment等类所在的包名
    private static String AssemblyName = "com.hwj.www.model15.version4.";

    /*
     * 根据db来决定实例化不同的类
     */
    public static IUser CreateUser() throws Exception {
        IUser result = null;
        //通过反射来实例化相应
        result = (IUser) Class.forName(AssemblyName + db + "User").newInstance();//SqlserverUser AccessUser
        return result;
    }

    public static IDepartment CreateDepartment() throws Exception {
        IDepartment result = null;
        result = (IDepartment) Class.forName(AssemblyName + db + "Department").newInstance();//SqlserverDepartment AccessDepartment
        return result;
    }

}

三、总结

1、简单工厂模式中,工厂Factory类集中了所有产品创建的逻辑,一旦要拓展新产品时,就不得不修改工厂类,这就违反了开闭原则(对拓展开放,对修改封闭),并且会造成工厂的逻辑过于复杂。
2、工厂方法模式中,在新增一个新产品时,就要新增一个具体工厂和一个具体产品类,这样程序的拓展性就有了提高,符合了开闭原则,避免了简单工厂模式的缺点,但是呢,新增产品时需要新增两个类,会增加代码量,可谓是有舍有得,具体如何要结合具体情况来使用。
3、抽象工厂模式是所有工厂模式的一般形式,当抽象工厂模式退化到只有一个产品登级结构时,就变成了工厂方法模式。当工厂方法模式的工厂类只有一个时,且工厂方法为静态方法时,则又变成了简单工厂模式。与工厂方法模式相似,抽象工厂模式隔离了具体类的生成,让客户端不清楚具体什么样的对象被创建。

Among thousands of people, you meet those you’ve met. Through thousands of years, with the boundlessness of time, you happen to meet them, neither earlier nor a bit too late.

花开成景花落为诗
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单工厂模式，工厂方法模式，抽象工程模式
菜鸟的成长
05-05 821
一、题目分析 简单工厂模式 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。 工厂方法模式 海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea...
【创建型模式一&二】简单工厂模式、工厂方法模式和抽象工厂模式
buptpxy的博客
04-09 485
简单工厂模式是对封装、继承、多态的一个典型的应用，可以作为理解面向对象的开始。 1. 对一个简单计算器程序的改进 实现一个有整数加减乘除功能的简单计算器： public static int compute(int num1, String operator, int num2) throws Exception { switch (operator) { ...
《设计模式详解》创建型模式 - 工厂模式
萌宅鹿的技术小屋
01-05 1785
《设计模式详解》4.2 工厂模式4.2.1 概述4.2.2 简单工厂模式4.2.2.1 结构4.2.2.2 实现4.2.2.3 优缺点4.2.2.4 扩展 - 静态工厂4.2.3 工厂方法模式4.2.3.1 概念4.2.3.2 结构4.2.3.3 实现4.2.3.4 优缺点4.2.4 抽象工厂模式4.2.4.1 概念4.2.4.2 结构4.2.4.2 实现4.2.4.3 优缺点4.2.4.4 使用场景4.2.5 扩展：简单工厂 + 配置文件4.2.6 JDK源码 - Collection.iterator
小白必备工厂模式总结(简单工厂+工厂方法+抽象工厂)
Code皮皮虾的博客
07-31 535
文章目录介绍一、简单工厂模式简单工厂模式总结二、工厂方法模式工厂方法模式总结三、抽象工厂模式抽象工厂模式总结尾声 介绍 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。 工厂模式可分为三类： 简单工厂模式 工厂方法模式 抽象工厂模式 工厂模式的意义 将实例化的对象的代码提取出
抽象工厂模式、工厂方法模式总结
weixin_34357887的博客
07-27 95
简单工厂模式、工厂方法模式与抽象工厂模式 之前一直没有时间对工厂模式进行总结，这里我梳理一下，我在网络上查看资料，发现每个文章的思路都不一样，这里我对其进行总结。 简单工厂模式 1. 简单工厂模式的定义 简单工厂模式也被称为静态工厂模式;使用简单工厂模式可以将产品的“消费”和生产完全分开，客户端只需要知道自己需要什么产品，如何来使用产品就可以了，具体的产品生产任务由具体的工厂类来实现。工厂类根据传...
23种设计模式笔记第三篇简单工厂模式、工厂方法模式以及抽象工厂模式
qq_44709970的博客
04-24 525
简单工厂模式、工厂方法模式以及抽象工厂模式
简单工厂模式
SnailPace的博客
04-08 160
模式结构： Factory：工厂角色 工厂角色负责实现创建所有实例的内部逻辑 Product：抽象产品角色 抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口 ConcreteProduct：具体产品角色 具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。 优点： 工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做
Java设计模式之工厂模式分析【简单工厂、工厂方法、抽象工厂】
08-27
抽象工厂模式是工厂模式中的一种实现方式，它通过定义一个抽象工厂接口，并让子类来实现该接口，以创建对象实例。例如，在上面的代码中，我们定义了一个AbstractHairFactory抽象工厂接口，并让ConcreteHairFactory类...
C#编程模式之工厂方法模式+抽象工厂模式
最新发布
04-17
本资源主要介绍工厂方法模式和抽象工厂模式。二者都与工厂相关，，但是其本质又大相径庭。这里先来简单介绍下二者的区别，以免混淆。 抽象工厂模式：提供一个接口，用于创建一系列相关的对象，而无需指定具体的类。...
简单工厂模式、工厂模式、抽象工厂模式案例（C++实现）
04-10
在这个压缩包中，包含了三种工厂模式的C++实现：简单工厂模式、工厂方法模式以及抽象工厂模式。让我们一一探讨这些模式。 1. 简单工厂模式： 简单工厂模式是一种静态工厂方法，它提供一个公共的工厂类来创建对象。...
设计模式——工厂模式在开发中的应用（简单计算器）
08-11
这个是http://blog.csdn.net/dawanganban/article/details/9884681博客中java设计模式的源代码。下载前请先看《设计模式——工厂模式在开发中的应用》一文。
抽象工厂模式+工厂方法模式+策略模式+类图实现手机加工厂
12-04
深入浅出设计模式之抽象工厂模式+工厂方法模式+策略模式实现手机加工厂（加类图）
工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式
12-14
工厂模式分为三种主要类型：简单工厂模式、工厂方法模式和抽象工厂模式。 1. **简单工厂模式** 简单工厂模式是最简单的工厂模式实现，它提供一个静态方法或者类来创建对象，这个类通常被称为“工厂”。用户只需要...
基于模板方法与抽象工厂的复合模式
05-06
因此将抽象工厂模式嵌入到模板方法模式形成一个复合模式, 复合模式的设计核心是为每一个延迟到子类的可变的步骤提供一个创建对象的接口, 该接口对一个完整的产品族进行了定义. 复合模式既保证了算法结构的稳定性, ...
设计模式之简单工厂模式，工厂模式，抽象工厂模式学习总结
weixin_38154480的博客
04-06 227
简单从工厂模式（Simple Factory）又称之为静态工厂方法模式； 不利于产生系列产品； 简单工厂模式通过接收的参数的不同来返回不同的对象实例。 这种情况不方便修改，如果需要扩展类，我们需要添加新的类的同事，还要修改代码。 - 组成 1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
（面试）关于简单工厂、工厂、抽象工厂模式学习心得
foreveyking的博客
03-14 3123
前言所谓简单工厂，工厂，抽象工厂。当我一开始看到并学习这个这三个概念的时候就感觉这三个感念很相似，有点混乱，事实证明，确实让我变得很混乱。即使当初学的时候勉强看懂，但是事后便抛诸脑后，统统忘记到九霄云外了。因此当我回过头从新理解概念时，总结了以下心得，加深理解，并且做一个备忘录。工厂类模式设计的核心是：让“生产”和“产品”解耦。简单工厂所谓的简单工厂，我的理解是不用管是什么产品，我们将所有产品的生...
工厂模式-简单工厂、工厂方法、抽象工厂学习总结
Iostream123321的博客
04-21 55
工厂模式其实就是用于帮助我们针对抽象编程，而不是针对具体类编程的一种使用广泛、非常有威力的设计模式。顾名思义，这种设计模式类似于工厂生产产品的过程，故按照工厂生产产品的过程去学习工厂模式将有利于我们理解其过程。
设计模式4-工厂方法模式（FactoryMethod）、抽象工厂模式（AbstractFactory）解析+案例实践+总结
chen
09-26 899
本文是对面向对象设计模式--工厂方法模式（FactoryMethod）和抽象工厂模式（AbstractFactory）的解析，主要分为定义解析、简单工厂方法讲解、工厂方法模式讲解、抽象工厂模式讲解、多案例练习加深对工厂方法模式与抽象工厂模式的理解、最后总结知识要点。 第一篇：定义解析 工厂方法模式和抽象工厂模式是GoF四人帮整理的《设计模式-可复用面向对象软件基础》一书中23种设计模式中归类为...
简单工厂模式&工厂方法模式&抽象工厂模式的区别及优缺点及使用场景
热门推荐
auuea的博客
12-01 4万+
简单工厂模式&工厂方法模式&抽象工厂模式的区别及优缺点及使用场景简单工厂普通简单工厂多方法简单工厂静态方法简单工厂工厂方法模式抽象工厂模式 工厂模式是java设计模式中比较简单的一个设计模式，但很多地方都用到了工厂模式，（如解析xml中，jdbc连接数据库等）利用好工厂模式对程序的设计很有用处。 工厂模式在一些设计模式的书中分为简单工厂模式，工厂方法模式和抽象工厂模式三类。也有把工...
工厂模式详解：简单工厂、抽象工厂与工厂方法
抽象工厂模式更进一步，它提供了创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。抽象工厂模式适用于当系统需要创建的对象属于一个大的族，并且这些对象可能是相互协作的。使用抽象工厂模式可以确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值