精华内容
下载资源
问答
  • 本文实例讲述了Python设计模式之简单工厂模式。分享给大家供大家参考,具体如下: 简单工厂模式(Simple Factory Pattern):是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类. 下面使用...
  • 简单工厂模式实例 C++

    2019-03-19 11:04:27
    代码完整地描述了简单工厂模式,包括工厂实例、产品抽象类、具体产品。已经过测试,编译没有问题。非常适合初学者使用。
  • 主要介绍了C++设计模式之简单工厂模式实例,工厂模式有一种非常形象的描述,建立对象的类就如一个工厂,而需要被建立的对象就是一个个产品,需要的朋友可以参考下
  • 主要介绍了JavaScript设计模式--简单工厂模式,结合实例形式分析了JavaScript设计模式中简单工厂模式原理与XHR工厂应用案例,需要的朋友可以参考下
  • 本文实例讲述了JavaScript设计模式–简单工厂模式。分享给大家供大家参考,具体如下: 第一步,Ajax操作接口(目的是起一个接口检测作用) (1)引入接口文件 //定义一个静态方法来实现接口与实现类的直接检验 //...
  • 简单工厂模式实例学习(一)

    千次阅读 2018-05-31 14:59:49
    一、简单工厂模式简单工厂模式最直接的目的就是为了解耦,把对象的创建和使用的过程分开。用工厂方法来代替new操作的一种模式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的...

    文章参考了网上诸多大神的博客写的,仅作为学习和参考。有错误的地方希望能指出改进。

    一、简单工厂模式

    简单工厂模式最直接的目的就是为了解耦,把对象的创建和使用的过程分开。用工厂方法代替new操作的一种模式在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

    需求:在没有引入工厂模式之前,假定我们需要组装一台电脑(这边以显示器和主机为例)。

    显示器的属性包括:型号(三星(Samsung),戴尔(Dell));长度(22英寸,24英寸)。 主机的属性包括:主板(联想(Lenovo),华硕(Asus));cpuAMDIntel)。

    定义两个实体类,通过getOwners方法返回产品信息

    显示器实体类:

    package SimpleFactoryPattern.bean;
    
    /**
     * 显示器
     * @author you
     *
     */
    public class DisplayDevice {
    	
    	//产品型号
    	private String productModel;
    	
    	//显示器长度
    	private double size;
    	
    	/**
    	 * 构造方法
    	 * @param productModel 产品型号
    	 * @param size 显示器长度
    	 */
    	public DisplayDevice(String productModel,double size) {
    		// TODO Auto-generated constructor stub
    		
    		this.productModel = productModel;
    		this.size = size;
    		
    	}
    	
    	public String getOwners()
    	{
    		return "显示器型号:"+this.productModel+";长度:"+this.size+"英寸";
    	}
    	
    }

    主机实体类:

    package SimpleFactoryPattern.bean;
    
    /**
     * 主机
     * @author you
     *
     */
    public class Computer {
    	
    	//主板型号
    	private String mainBoardModel;
    	
    	//cpu型号
    	private String cpuModel;
    	
    	/**
    	 * 构造方法
    	 * @param mainBoardModel 主板型号
    	 * @param cpuModel cpu型号
    	 */
    	public Computer(String mainBoardModel,String cpuModel) {
    		// TODO Auto-generated constructor stub
    		this.mainBoardModel = mainBoardModel;
    		this.cpuModel = cpuModel;
    	}
    	
    	public String getOwners()
    	{
    		return "主机主板型号:"+this.mainBoardModel+";cpu型号:"+this.cpuModel ;
    	}
    
    }

    假定客户需要一台22英寸三星显示器,带有Intel CPU,华硕主板的主机,和一台24英寸戴尔显示器,带有AMD CPU,联想主板的主机。客户端代码:

    package SimpleFactoryPattern.clientmain;
    
    import SimpleFactoryPattern.bean.Computer;
    import SimpleFactoryPattern.bean.DisplayDevice;
    
    /**
     * 无模式客户端实现类
     * @author you
     *
     */
    public class MakeComputerClient {
    
    	public static void main(String[] args) {
    		
    		/* 假定客户需要一台22英寸三星显示器,带有Intel CPU,华硕主板的主机
    		和一台24英寸戴尔显示器,带有AMD CPU,联想主板的主机。*/
    		DisplayDevice displayDevice = new DisplayDevice("Samsung", 22);
    		Computer computer = new Computer("Asus","Intel");
    		
    		DisplayDevice displayDevice2 = new DisplayDevice("Dell", 24);
    		Computer computer2 = new Computer("Lenovo","AMD");
    		
    		System.out.println("客户得到第一台电脑:"+displayDevice.getOwners()
    				+";"+computer.getOwners());
    		
    		System.out.println("客户得到第二台电脑:"+displayDevice2.getOwners()
    				+";"+computer2.getOwners());
    
    	}
    }

    运行结果:

     

    引入简单工厂模式,新建一个工厂类,通过getOwners方法返回产品信息。:

    package SimpleFactoryPattern.factory;
    
    import SimpleFactoryPattern.bean.Computer;
    import SimpleFactoryPattern.bean.DisplayDevice;
    
    /**
     * 电脑工厂
     * @author you
     *
     */
    public class ComputerFactory {
    
    	//主机信息
    	private static Computer computer;
    
    	//显示器信息
    	private static DisplayDevice displayDevice;
    
    	/**
    	 * 创建电脑
    	 * @param type 创建电脑的类型
    	 */
    	public static String createComputer(int type)
    	{
    		switch (type) {
    		case 1:
    		{
    			//22英寸三星显示器,带有Intel CPU,华硕主板的主机
    			displayDevice = new DisplayDevice("Samsung", 22);
    			computer = new Computer("Asus","Intel");
    			return getOwners();
    		}
    		case 2:	
    		{
    			//一台24英寸戴尔显示器,带有AMD CPU,联想主板的主机。
    			displayDevice = new DisplayDevice("Dell", 24);
    			computer = new Computer("Lenovo","AMD");
    			return getOwners();
    		}
    		default:
    
    			return "";
    		}
    	}
    
    	public static String getOwners()
    	{
    		return displayDevice.getOwners()+";"+computer.getOwners();
    	}
    
    
    
    }

    此时客户端代码修改为:

    package SimpleFactoryPattern.clientmain;
    
    import SimpleFactoryPattern.factory.ComputerFactory;
    
    /**
     * 简单工厂模式客户端实现类
     * @author you
     *
     */
    public class SimpleFactoryClient {
    
    	public static void main(String[] args) {
    		
    		/* 假定客户需要一台22英寸三星显示器,带有Intel CPU,华硕主板的主机
    		和一台24英寸戴尔显示器,带有AMD CPU,联想主板的主机。*/
    	
    		System.out.println("客户得到第一台电脑:"+ComputerFactory.createComputer(1));
    		
    		System.out.println("客户得到第二台电脑:"+ComputerFactory.createComputer(2));
    
    	}
    }

    运行结果:

     

    优点:工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的.明确了各自的职责和权利,有利于整个软件体系结构的优化。

     

    缺点:由于工厂类集中了所有实例的创建逻辑,违反了高内聚责任分配原则,将全部创建逻辑集中到了一个工厂类中;它所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了。

    当系统中的具体产品类不断增多时候,可能会出现要求工厂类根据不同条件创建不同实例的需求.这种对条件的判断和对具体产品类型的判断交错在一起,很难避免模块功能的蔓延,对系统的维护和扩展非常不利;

    这些缺点在工厂方法模式中得到了一定的克服。

    展开全文
  • 主要介绍了js简单工厂模式用法,实例分析了javascript工厂模式的实现原理,需要的朋友可以参考下
  • IOS简单工厂模式实例

    2014-02-21 10:12:17
    IOS简单工厂模式实例 IOS 设计模式 简单 工厂 模式
  • java简单工厂模式源码实例,可用于java简单工厂模式学习!
  • 简单工厂模式

    2018-01-13 14:44:19
    设计模式课程资料——简单工厂模式,使用Java实现,在eclipse进行编译
  • java-简单工厂模式实例及讲解

    千次阅读 2019-05-15 18:55:40
    简单工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且...

    简单工厂模式

    工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

    介绍

    意图:定义一个创建对象的接口或者抽象类,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。

    主要解决:主要解决接口选择的问题。

    何时使用:我们明确地计划不同条件下创建不同实例时。

    如何解决:让其子类实现工厂接口,返回的也是一个抽象的产品。

    关键代码:创建过程在其子类执行。

    优点: 1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类  就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。

    缺点:每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统  的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。

    使用场景: 1、日志记录器:记录可能记录到本地硬盘、系统事件、远程服务器等,用户可以选择记录日志到什么地方。 2、数  据库访问,当用户不知道最后系统采用哪一类数据库,以及数据库可能有变化时。 3、设计一个连接服务器的框架,需要三个协议,"POP3"、"IMAP"、"HTTP",可以把这三个作为产品类,共同实现一个接口。

    注意事项:作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用工厂方法模式。有一点需要注意的地方就是复杂  对象适合使用工厂模式,而简单对象,特别是只需要通过 new 就可以完成创建的对象,无需使用工厂模式。如果使用工厂模式,就需要引入一个工厂类,会增加系统的复杂度。

     

    实例场景:开发一个类似计算器的JAVA程序。

    1.抽象类或者接口:Operator.java

    abstract class Operator {
    
    	private double number1;
    	private double number2;
    	
           //用于四则运算类进行实现
    	public abstract double getResult();
    	
    	public double getNumber1() {
    		return number1;
    	}
    	public void setNumber1(double number1) {
    		this.number1 = number1;
    	}
    	public double getNumber2() {
    		return number2;
    	}
    	public void setNumber2(double number2) {
    		this.number2 = number2;
    	}
    	
    }
    

        2.实现类(各种运算的处理类)

    /**
     * 加法运算
    **/
    public class OperatorAdd extends Operator {
    
    	@Override
    	public double getResult() {
    		return getNumber1() + getNumber2();
    	}
    
    }
    
    /**
     * 减法运算
    **/
    
    public class OperatorSub extends Operator {
    
    	@Override
    	public double getResult() {
    		return getNumber1() - getNumber2();
    	}
    }
    
    /**
     * 乘法运算
    **/
    public class OperatorMul extends Operator {
    
    	@Override
    	public double getResult() {
    		return getNumber1()*getNumber2();
    	}
    }
    
    /**
     * 除法运算
    **/
    public class OperatorDiv extends Operator {
    
    	@Override
    	public double getResult() {
    		if(getNumber2()==0) {
    			try {
    				throw new Exception("除数不能为0");
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    		return getNumber1()/getNumber2();
    	}
    }

       3.创建实例的工厂类:OperatorFactory.java

    public class OperatorFactory {
    	
    	public Operator createOperator(String op) {
    		Operator operator = null;
    		switch(op) {
    			case "+" : operator = new OperatorAdd();break; 
    			case "-" : operator = new OperatorSub();break;
    			case "*" : operator = new OperatorMul();break;
    			case "/" : operator = new OperatorDiv();break;
    		}
    		return operator;
    	}
    }

    4.测试(Junit)

    import org.junit.Test;
    
    public class TestMain {
    	@Test
    	public void test() {
    		OperatorFactory factory = new OperatorFactory();
    		Operator operator = factory.createOperator("*");
    		operator.setNumber1(10.2);
    		operator.setNumber2(5.2);
    		double result = operator.getResult();
    		System.out.println(result);
    	}
    }

     

    当我们有新的运算规则需要添加时,添加新的计算逻辑类以及在工厂类(OperatorFactory)中新增规则就可以。

    展开全文
  • 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了于具体产品的依赖
  • 工厂模式在一些设计模式的书中分为简单工厂模式,工厂方法模式和抽象工厂模式三类。也有把工厂方法模式划分到抽象工厂模式的,认为工厂方法是抽象工厂模式的特例的一种,就是只有一个要实现的产品接口。
  • C#中简单工厂模式实例(设计模式-创建型模式)
  • 工厂模式是创建型模式的一种,分为简单工厂模式,工厂模式,抽象工厂模式,简单工厂可以称之为工厂模式的一个特例 先用一段简单的代码说明一下,现在假设我们是顾客,需要苹果味饮料和香蕉味饮料 <?php class ...
  • 设计模式之简单工厂模式案例
  • 简单工厂模式(Simple Factory Pattern) .net简单工厂模式实例源代码
  • 转自:java 工厂方法模式简单实例 介绍 在简单工厂模式中,我们...的问题,我们在简单工厂模式中,将实例化对象的工作推迟到了专门负责创建对象的工厂类中,这样,在我们事先预知的情况下,可以根据我们的需要动...

    转自:java 工厂方法模式简单实例

    介绍
    在简单工厂模式中,我们提到,工厂方法模式是简单工厂模式的一个延伸,它属于Gof23中设计模式的创建型设计模式。它解决的仍然是软件设计中与创建对象有关的问题。它可以更好的处理客户的需求变化。

    引入
    我们继续来说"new"的问题,我们在简单工厂模式中,将实例化对象的工作推迟到了专门负责创建对象的工厂类中,这样,在我们事先预知的情况下,可以根据我们的需要动态创建产品类。但是,我们的预知是有限的,客户的变化可能是无限的。所以,就出现了问题,一旦客户的变化超越了我们的预知,我们就必须修改我们的源代码了。这是设计模式所不允许的,怎么办呢?工厂方法模式正是解决此类问题的。
    问题:具体工厂类的创建工作不能满足我们的要求了,创建的工作变化了
    解决思路:哪里变化,封装哪里。把具体工厂封装起来。

    定义
    工厂方法模式又称为工厂模式,也叫虚拟构造器(Virtual Constructor)模式或者多态工厂模式(Polymorphic Factory),在工厂方法模式中,父类负责定义创建对象的公共接口,而子类则负责生成具体的对象,这样做的目的是将类的实例化操作延迟到子类中完成,即由子类来决定究竟应该实例化(创建)哪一个类。
    工厂方式法模式(Factory Method),定义了一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。

    意图
    定义一个用户创建对象的接口,让子类决定实例化哪一个类,工厂方法模式使一个类的实例化延迟到其子类。

    参与者
    抽象产品角色(Product):定义产品的接口
    具体产品角色(ConcreteProduct) :实现接口Product的具体产品类
    抽象工厂角色(Creator) :声明工厂方法(FactoryMethod),返回一个产品
    真实的工厂(ConcreteCreator):实现FactoryMethod工厂方法,由客户调用,返回一个产品的实例
    工厂方法模式UML图

    现实生活中的例子
    为了方便大家理解,我仍然举穿衣服方面的一个例子。这个例子与简单工厂模式中的那个例子有些不同。
    据说清朝有个皇帝穿衣非常的奢侈,每种衣服(具体产品类)由一宫女(具体工厂类)专门负责,这样一来,每增加一种衣服(具体产品类),就要多出一个宫女(具体工厂类),但是他们各负其责,互不影响。皇帝之所以这样做,是因为针对穿衣服这件事来说,可扩展性是非常强的。

    分析
    实现的功能:可以根据皇帝的要求,动态的创建(由宫女去拿)已存在的具体产品(衣服),如果皇帝的要求太苛刻,这种衣服还没有,只需要增加一个宫女,一个衣服就能够满足他的要求了。每个宫女只负责一种衣服(高内聚),要增加一种衣服,对于以前的所有宫女与衣服来说,都不会受到影响(设计模式中所期望的)。说到这里,是不是明白了工厂方法模式所能解决的问题及其应用了?呵呵。。你一定在想,比简单工厂模式灵活性高吧。
    体系结构

    ICoat.cs

    复制代码

    namespace FactoryMethod
    {
        /// <summary>
        /// 抽象产品类
        /// </summary>
        public interface ICoat
        {
            void ShowCoat();
        }
    }

    复制代码

    IFactory.cs

    复制代码

    namespace FactoryMethod
    {
        /// <summary>
        /// 抽象工厂类,定义产品的接口
        /// </summary>
        public interface IFactory
        {
            ICoat CreateCoat();
        }
    }

    复制代码

    FashionCoat.cs

    复制代码

    using System;
    
    namespace FactoryMethod
    {
        /// <summary>
        /// 具体产品类,时尚上衣类
        /// </summary>
        public class FashionCoat :ICoat
        {
            public void ShowCoat()
            {
                Console.WriteLine("这件是时尚上衣");
            }
        }
    }

    复制代码

    BusinessCoat.cs

    复制代码

    using System;
    
    namespace FactoryMethod
    {
        /// <summary>
        /// 具体产品类,商务上衣类
        /// </summary>
        public class BusinessCoat :ICoat
        {
            public void ShowCoat()
            {
                Console.WriteLine("这件是商务上衣");
            }
        }
    }

    复制代码

    FashionFactory.cs

    复制代码

    namespace FactoryMethod
    {
        /// <summary>
        /// 具体工厂类,用于创建时尚上衣
        /// </summary>
        public class FashionFactory :IFactory
        {
            public ICoat CreateCoat()
            {
                return new FashionCoat();
            }
        }
    }

    复制代码

    BusinessFactory.cs

    复制代码

    namespace FactoryMethod
    {
        /// <summary>
        /// 具体工厂类:用于创建商务上衣类
        /// </summary>
        public class BusinessFactory : IFactory
        {
            public ICoat CreateCoat()
            {
                return new BusinessCoat();
            }
        }
    }

    复制代码

    App.config

    复制代码

    <?xml version="1.0" encoding="utf-8" ?>
    <configuration>
        <appSettings>
            <add key="FactoryName" value="FashionFactory"/>
        </appSettings>
    </configuration>

    复制代码

    Program.cs

    复制代码

    using System;
    using System.Configuration;
    using System.Reflection;
    
    namespace FactoryMethod
    {
        class Client
        {
            static void Main(string[] args)
            {
                //BusinessFactory factory = new BusinessFactory();
                //为了方便以后修改,将工厂类的类名写在应用程序配置文件中
                string factoryName = ConfigurationManager.AppSettings["FactoryName"];
                IFactory factory = (IFactory)Assembly.Load("FactoryMethod").CreateInstance("FactoryMethod." + factoryName);
                
                ICoat coat = factory.CreateCoat();
                //显示你要的上衣
                coat.ShowCoat();
                Console.ReadLine();
            }
        }
    }

    复制代码

    客户端代码需要注意的两个地方:
    1、把具体工厂类类名称写在了应用程序配置文件中,方便修改;
    2、用到了反射,利用.NET提供的反射可以根据类名来创建它的实例,非常方便。

    工厂方法模式的优点
    在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需产品对应的工厂,无须关心创建细节,甚至无须知道具体产品类的类名。
    基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象,而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式,是因为所有的具体工厂类都具有同一抽象父类。
    使用工厂方法模式的另一个优点是在系统中加入新产品时,无须修改抽象工厂和抽象产品提供的接口,无须修改客户端,也无须修改其他的具体工厂和具体产品,而只要添加一个具体工厂和具体产品就可以了。这样,系统的可扩展性也就变得非常好,完全符合“开闭原则”。

    工厂方法模式的缺点
    在添加新产品时,需要编写新的具体产品类,而且还要提供与之对应的具体工厂类,系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,有更多的类需要编译和运行,会给系统带来一些额外的开销。
    由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度,且在实现时可能需要用到DOM、反射等技术,增加了系统的实现难度。

    模式适用环境
    在以下情况下可以使用工厂方法模式:
    一个类不知道它所需要的对象的类:在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体的产品对象由具体工厂类创建;客户端需要知道创建具体产品的工厂类。
    一个类通过其子类来指定创建哪个对象:在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时,子类对象将覆盖父类对象,从而使得系统更容易扩展。
    将创建对象的任务委托给多个工厂子类中的某一个,客户端在使用时可以无须关心是哪一个工厂子类创建产品子类,需要时再动态指定,可将具体工厂类的类名存储在配置文件或数据库中。

    小结
    工厂方法模式又称为工厂模式,它属于类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
    工厂方法模式包含四个角色:抽象产品是定义产品的接口,是工厂方法模式所创建对象的超类型,即产品对象的共同父类或接口;具体产品实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,它们之间往往一一对应;抽象工厂中声明了工厂方法,用于返回一个产品,它是工厂方法模式的核心,任何在模式中创建对象的工厂类都必须实现该接口;具体工厂是抽象工厂类的子类,实现了抽象工厂中定义的工厂方法,并可由客户调用,返回一个具体产品类的实例。 
    工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。在工厂方法模式中,核心的工厂类不再负责所有产品的创建,而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口,而不负责产品类被实例化这种细节,这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。 
    工厂方法模式的主要优点是增加新的产品类时无须修改现有系统,并封装了产品对象的创建细节,系统具有良好的灵活性和可扩展性;其缺点在于增加新产品的同时需要增加新的工厂,导致系统类的个数成对增加,在一定程度上增加了系统的复杂性。 
    工厂方法模式适用情况包括:一个类不知道它所需要的对象的类;一个类通过其子类来指定创建哪个对象;将创建对象的任务委托给多个工厂子类中的某一个,客户端在使用时可以无须关心是哪一个工厂子类创建产品子类,需要时再动态指定。

    展开全文
  • 简单工厂模式 简单例子

    万次阅读 2018-08-29 21:07:42
    简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。 -------------来自百度百科 优点 工厂类是整个模式的关键...

    一、概述

    简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。 -------------来自百度百科

    优点

    工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的.明确了各自的职责和权利,有利于整个软件体系结构的优化。

    缺点

    由于工厂类集中了所有实例的创建逻辑,违反了高内聚责任分配原则,将全部创建逻辑集中到了一个工厂类中;它所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了。

    当系统中的具体产品类不断增多时候,可能会出现要求工厂类根据不同条件创建不同实例的需求.这种对条件的判断和对具体产品类型的判断交错在一起,很难避免模块功能的蔓延,对系统的维护和扩展非常不利;

    这些缺点在工厂方法模式中得到了一定的克服。

    使用场景

    工厂类负责创建的对象比较少;

    客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心;

    由于简单工厂很容易违反高内聚责任分配原则,因此一般只在很简单的情况下应用。

     

    二、java代码实现

    • 问题描述:设计一个用于加减乘除运算的工厂,并提供一个静态方法给客户端运算时使用。
    • UML图:

    首先是所有运算类的父类Operation,然后是四个最简单的计算类:

    package cn.smileyan.design.easyfactory;
    /**
     * @title 计算类
     * @author Smileyan
     * @time: 2018/08/29
     * @description 计算类,作为父类 
     */
    public class Operation {
    	private double num1;
    	private double num2;
    	public double getNum1() {
    		return num1;
    	}
    	public void setNum1(double num1) {
    		this.num1 = num1;
    	}
    	public double getNum2() {
    		return num2;
    	}
    	public void setNum2(double num2) {
    		this.num2 = num2;
    	}
    	// 返回运算结果
    	public double getResult() {
    		return 0;
    	}
    }
    
    package cn.smileyan.design.easyfactory;
    /**
     * @title 加法类
     * @author Smileyan
     * @time: 2018/08/29
     * @description 计算类,加法运算 
     */
    public class OperationAdd extends Operation {
    	// 重写父类方法
    	@Override
    	public double getResult() {
    		return this.getNum1()+this.getNum2();
    	}
    }
    
    package cn.smileyan.design.easyfactory;
    /**
     * @title 除法类
     * @author Smileyan
     * @time: 2018/08/29
     * @description 计算类,除法运算 
     */
    public class OperationDiv extends Operation {
    
    	@Override
    	public double getResult() {
    		if(this.getNum2()==0) {
    			System.out.println("除数不能为0");
    			return 0;
    		}
    		return this.getNum1()/this.getNum2();
    	}
    
    }
    
    package cn.smileyan.design.easyfactory;
    /**
     * @title 乘法类
     * @author Smileyan
     * @time: 2018/08/29
     * @description 计算类,乘法运算 
     */
    public class OperationMul extends Operation {
    	@Override
    	public double getResult() {
    		return this.getNum1()*this.getNum2();
    	}
    }
    
    package cn.smileyan.design.easyfactory;
    /**
     * @title 减法类
     * @author Smileyan
     * @time: 2018/08/29
     * @description 计算类,减法运算 
     */
    public class OperationSub extends Operation {
    	// 重写父类方法
    	@Override
    	public double getResult() {
    		return this.getNum1()-this.getNum2();
    	}
    }
    

    其次是工厂类:

    package cn.smileyan.design.easyfactory;
    /**
     * @title OperationFactory
     * @author Smileyan
     * @description 工厂类,直接与客户打交道的类
     */
    public class OperationFactory {
    	public static Operation createOperation(String op) {
    		Operation operation=null;
    		// 判断并且确认将返回的对象
    		switch (op) {
    		case "+":
    			operation=new OperationAdd();
    			break;
    		case "-":
    			operation=new OperationSub();
    			break;
    		case "*":
    			operation=new OperationMul();
    			break;
    		case "/":
    			operation=new OperationDiv();
    			break;
    		default:
    			break;
    		}
    		return operation;
    	}
    }
    

    最后是我们的客户端,也就是使用这个简单工厂的类,或者说是测试类吧。

    package cn.smileyan.design.easyfactory;
    
    
    /**
     * @title User 
     * @author Smileyan
     * @description 客户端,即简单工厂的使用者
     */
    public class User {
    	public static void main(String[] args) {
    		Operation operation=null;
    		// 此处可以更改为其他运算符 而其他地方可以保持不变
    		String op="-"; 
    		operation = OperationFactory.createOperation(op);
    		operation.setNum1(99);
    		operation.setNum2(97);
    		System.out.println(operation.getResult());
    	}
    }
    

    最终的运行结果可想而知:我们修改main方法中的op变量,而其他地方不需要修改,即可进行各项运算并返回结果。

    三、总结

    简单工厂模式相对于23种GOF设计模式来说要简单一些,在我们不知不觉中可能已经用过很多次简单工厂模式——尽管我们当初并不知道自己写的代码也算是“模式”。

    展开全文
  • 简单工厂模式(Simple Factory Pattern) .net简单工厂模式实例源代码
  • 主要介绍了Java简单工厂模式定义与用法,结合实例形式分析了java简单工厂模式的相关定义与使用技巧,并给出了原理类图进行总结,需要的朋友可以参考下
  • 简单工厂模式中专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。它又称为静态工厂方法模式,属于类的创建型模式。 简单工厂模式的UML类图 简单工厂模式的程序通过封装继承来降低程序的...
  • 主要介绍了Java设计模式编程中简单工厂与抽象工厂模式的使用实例,简单工厂与抽象工厂都可以归类于设计模式中的创建型模式,需要的朋友可以参考下
  • 简单工厂模式是由一个工厂对象决定创建出那一种产品类的实例。 1.工厂模式的几种形态 工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化,不必事先知道每次要实例化哪一个类。工厂...
  • 主要介绍了C#设计模式编程中简单工厂模式的使用,文中也举了在.NET框架下简单工厂模式的实现例子,需要的朋友可以参考下
  • 简单工厂模式实例 题目:实现计算器的输入2个数和运算符,得到结果 工程结构: (1)头文件 COperationFactory.h(运算符工厂类) (2)源文件 SimpleFactory.cpp(客户端应用类,主函数所在) (3)运算类 COperation.cpp...
  • 主要介绍了PHP设计模式之抽象工厂模式,结合实例形式分析了php抽象工厂模式的概念、原理、使用方法及相关操作注意事项,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,497
精华内容 56,598
关键字:

简单工厂模式实例