【设计模式系列】--简单工厂模式

简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。简单来说,通过专门定义一个类来辅助创建其他类的实例,被创建的实例通常都具有共同的父类,今天这篇博文,小编主要简单的介绍一下简单工程模式,通过简单的demo一步一步进行讲解,希望对有需要的小伙伴有帮助,还请小伙伴们多多指教。首先,我们来看一下简单工厂的uml图,如下所示:

接着,小编结合一个简单的demo,来更好的帮助小伙伴们理解简单工厂模式,首先我们新建一个java项目,取名为SimpleFactory,新建三个类Apple、Banana、MainClass,代码分别如下所示:

Apple类的代码:

public class Apple {
	/**
	 * 采集
	 */
	public void get(){
		System.out.println("采集苹果");
	}

}

Banana类的代码:

public class Banana {
	/**
	 * 采集
	 */
	public void get(){
		System.out.println("采集香蕉");
	}

}

编写MainClass里面的代码,如下所示:

public class MainClass {

	public static void main(String[] args){
		//实例化一个Apple
		Apple apple = new Apple();
		//实例化一个Banana
		Banana banana = new Banana();

		apple.get();
		banana.get();

	}
}

运行,效果如下所示:

我们的代码是否还可以进行优化呢?通过Apple类和Banana类我们可以发现,她们都具有get方法,更重要的是,她们都属于水果,所以这个时候,我们可以抽象出来一个接口,so,我们创建一个接口,代码如下所示:

public interface Fruit {
	/**
	 * 采集
	 */
	public void get();

}

Apple类和Banana类分别实现接口Fruit,注释掉之前MainClass里面的代码,重新编写,这样,我们这里就用到了多态,代码如下所示:

public class MainClass {

	public static void main(String[] args){
//		//实例化一个Apple
//		Apple apple = new Apple();
//		//实例化一个Banana
//		Banana banana = new Banana();
//
//		apple.get();
//		banana.get();

		//实例化一个Aplle和Banana,用到了多态
		Fruit apple = new Apple();
		Fruit banana = new Banana();
		apple.get();
		banana.get();

	}
}

运行,效果如下所示:


接着,我们回过头来看一下简单工厂模式的概念,通过专门定义一个类来辅助辅助创建其她类的实例,被创建的实例通常都具有共同的父类,从上面的demo中,我们可以看出来,Apple类和Banana类具有一个共同的父类,那就是Fruit,这个时候,我们需要专门定义一个类来辅助创建其她类的实例,接着,我们再来进行优化,创建一个类FruitFactory,代码如下所示:

public class FruitFactory {
	/**
	 * 获得Apple类的实例
	 */

	public static Fruit getApple(){
		return new Apple();
	}

	/**
	 * 获得Banana类的实例
	 */
	public static Fruit getBanana(){
		return new Banana();
	}
}

编写main里面的代码,如下所示:

public class MainClass {

	public static void main(String[] args){
//		//实例化一个Apple
//		Apple apple = new Apple();
//		//实例化一个Banana
//		Banana banana = new Banana();
//
//		apple.get();
//		banana.get();

//		//实例化一个Aplle和Banana,用到了多态
//		Fruit apple = new Apple();
//		Fruit banana = new Banana();
//		apple.get();
//		banana.get();

		//实例化一个Apple
		Fruit apple = FruitFactory.getApple();
		Fruit banana = FruitFactory.getBanana();
		apple.get();
		banana.get();

	}
}

运行一下,效果如下所示:

这样,我们实现了专门定义一个类来辅助创建其她类的实例,那我们还能不能进一步进行优化呢?答案是肯定的,我们可以把这些方法写成一个静态的方法,我们直接可以通过类名类进行引用,不需要创建工程类的实例,我们来看一下模式中包含的角色及其职责。

a、工厂角色---Creator

简单工厂模式的核心,她负责实现创建所有实例的内部逻辑,工厂类可以被外界直接调用,创建所需要的产品对象。

b、抽象角色--Product

简单工厂模式所创建的所有对象的父类,她负责描述所有实例所共有的公共接口。

c、具体产品角色--Concrete Product

简单工厂模式所创建的具体实例对象

那么,工厂还能否进行进一步的优化呢?yes,我们发现工厂里面分别单独getApple和getBanana,我们是否能写一个公共的getFruit的方法呢?进行优化,编写FruitFactory里面的代码,如下所示:

public class FruitFactory {
//	/**
//	 * 获得Apple类的实例
//	 */
//
//	public static Fruit getApple(){
//		return new Apple();
//	}
//
//	/**
//	 * 获得Banana类的实例
//	 */
//	public static Fruit getBanana(){
//		return new Banana();
//	}
	/**
	 * get方法,获得所有产品对象
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 */
	public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException {
		if(type.equalsIgnoreCase("apple")) {
			return Apple.class.newInstance();
		}else if(type.equalsIgnoreCase("banana")){
			return Banana.class.newInstance();
		}else{
			System.out.println("找不到相关实例化类");
			return null;

		}
	}

}

编写MainClass的代码,如下所示:

public class MainClass {

	public static void main(String[] args) throws InstantiationException, IllegalAccessException{
//		//实例化一个Apple
//		Apple apple = new Apple();
//		//实例化一个Banana
//		Banana banana = new Banana();
//
//		apple.get();
//		banana.get();

//		//实例化一个Aplle和Banana,用到了多态
//		Fruit apple = new Apple();
//		Fruit banana = new Banana();
//		apple.get();
//		banana.get();

//		//实例化一个Apple
//		Fruit apple = FruitFactory.getApple();
//		Fruit banana = FruitFactory.getBanana();
//		apple.get();
//		banana.get();

		Fruit apple = FruitFactory.getFruit("apple");
		Fruit banana = FruitFactory.getFruit("banana");
		apple.get();
		banana.get();

	}
}

运行,效果如下所示:

我们知道,每一种模式都是经过不断的改进,最后达到业内都能接受的一种规范,so,我们还可以进行优化,编写FruitFactory的内容,如下所示:

public class FruitFactory {
//	/**
//	 * 获得Apple类的实例
//	 */
//
//	public static Fruit getApple(){
//		return new Apple();
//	}
//
//	/**
//	 * 获得Banana类的实例
//	 */
//	public static Fruit getBanana(){
//		return new Banana();
//	}
	/**
	 * get方法,获得所有产品对象
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 * @throws ClassNotFoundException
	 */
	public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
//		if(type.equalsIgnoreCase("apple")) {
//			return Apple.class.newInstance();
//		}else if(type.equalsIgnoreCase("banana")){
//			return Banana.class.newInstance();
//		}else{
//			System.out.println("找不到相关实例化类");
//			return null;
//
//		}
		Class fruit = Class.forName(type);
		return (Fruit) fruit.newInstance();
	}

}

编写MainClass的代码,如下所示:

public class MainClass {

	public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
//		//实例化一个Apple
//		Apple apple = new Apple();
//		//实例化一个Banana
//		Banana banana = new Banana();
//
//		apple.get();
//		banana.get();

//		//实例化一个Aplle和Banana,用到了多态
//		Fruit apple = new Apple();
//		Fruit banana = new Banana();
//		apple.get();
//		banana.get();

//		//实例化一个Apple
//		Fruit apple = FruitFactory.getApple();
//		Fruit banana = FruitFactory.getBanana();
//		apple.get();
//		banana.get();

		Fruit apple = FruitFactory.getFruit("Apple");
		Fruit banana = FruitFactory.getFruit("Banana");
		apple.get();
		banana.get();

	}
}

运行一下,效果如下所示:


接着,我们来看一下简单工厂模式的优缺点:

在这个模式中,工厂类是整个模式的关键所在,她包含的必要的判断楼哦机,能够根据外界给定的信息,决定究竟应该创建哪个具体类的对象,用户在使用时可以直接根据工厂类去创建所需的实例,而无需了解这些对象是如何创建以及如何组织的,有利于整个廉体系结构的优化。

不难发现,简单工厂模式的确定也正体现在其工厂类上,由于工厂类几种了所有实例的创建逻辑,所以“高内聚”方面做的并不好,另外,当系统中的具体产品类不断增多时,可能会出现要求工厂类也要做相应的修改,扩展性不是很好,如下代码:

public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
		if(type.equalsIgnoreCase("apple")) {
			return Apple.class.newInstance();
		}else if(type.equalsIgnoreCase("banana")){
			return Banana.class.newInstance();
		}else{
			System.out.println("找不到相关实例化类");
			return null;

		}
		Class fruit = Class.forName(type);
		return (Fruit) fruit.newInstance();
	}

如果这个时候再添加一个橙子,so我们需要添加一个else if来进行判断,下面那种方法会解决我们的问题,但是也不能从根本上解决问题,我们调用的时候会比较麻烦,因为这个类你必须知道,对于客户而言,是比较麻烦的,一般我们会受用第二种,不用考虑大小写,虽然第三种扩展性好,但是适用性较差。

小编寄语:该博文,小编主要简单的介绍了简单工厂模式,通过一个简单的demo进行讲解,简单工厂模式是属于创建型模式,又叫做静态工厂方法模式,但不属于二十三中GOF设计模式之一,简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例,简单工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一种特殊实现,想起那句话,编程是一门技术,更是一门艺术,在编写代码的过程中,要牢记可复用、易维护、好扩展,这样,自己才能有所提高,才是真正的软件工程师。

时间: 2016-09-16

【设计模式系列】--简单工厂模式的相关文章

C#设计模式(2)——简单工厂模式

原文:C#设计模式(2)--简单工厂模式 一.引言 这个系列也是自己对设计模式的一些学习笔记,希望对一些初学设计模式的人有所帮助的,在上一个专题中介绍了单例模式,在这个专题中继续为大家介绍一个比较容易理解的模式--简单工厂模式. 二.简单工厂模式的介绍 说到简单工厂,自然的第一个疑问当然就是什么是简单工厂模式了? 在现实生活中工厂是负责生产产品的,同样在设计模式中,简单工厂模式我们也可以理解为负责生产对象的一个类, 我们平常编程中,当使用"new"关键字创建一个对象时,此时该类就依赖与

设计模式: 简单工厂模式

引入: 在我们的思维中,会有一种习惯,当遇到某种问题时,会直接考虑用最直接的语言去去实现它,而往往忽略了整个程序的可维护性.可扩展性. 比如,我们写一个基本的计算器功能,要求能计算四则运算,大家或许会直接写: public class ProgramDemo{ public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(

php设计模式之简单工厂模式详解_php技巧

本文以实例形式较为详细的介绍了PHP设计模式的简单工厂模式,对于进行PHP程序设计来说有很好的借鉴作用.具体如下: 一.概念 简单工厂模式 [静态工厂方法模式](Static Factory Method) 是类的创建模式 工厂模式的几种形态: 1.简单工厂模式(Simple Factory)又叫做 静态工厂方法模式(Static Factory Method) 2.工厂方法模式(Factory Method)又叫做 多态性工厂模式(Polymorphic Factory) 3.抽象工厂模式(A

java设计模式之简单工厂模式

在编写一个计算器程序时,可以将业务逻辑和显示分离,业务逻辑封装为一个类(封装):如果要新添加一种运算,可以先创建一个Operation的基类,然后各种运算从Operation类继承,并实现GetResult()虚函数,这时添加新的运算只需要派生一个新的类,即不需要之前的运算参与编译.如何让计算器知道我是希望使用哪种运算呢?应该考虑单独的类来做这个创造实例的过程,这就是工厂.创建一个OperationFactory类,传入参数,函数createOperate就可以实例化出合适的对象. Java代码

设计模式-简单工厂模式(SimpleFactory-C#)

设计 <java与模式> 上面那本书上的例子举的是园丁和果园的例子,学习设计模式最好在生活中自己找个例子 实践一下,下面是我自己的一个例子,是讲快餐店的例子,快餐店提供很多食物,比如 面条,米饭,面包.首先定义了一个Food接口,然后这些食物都从它来继承,定义了一个大厨 他包办所有食物的制作工作,这就是我所理解的简单工厂模式的概念,下面是源代码: using System; namespace SimpleFactoryPattern{ /// <summary> /// 简单工厂

设计模式之简单工厂模式

设计模式,六大设计原则,类的特性 总纲 http://blog.csdn.net/fenglailea/article/details/52733435 风.fox 简单工厂模式(Simple Factory) 简单工厂模式就是工厂方法模式的缩小版 通用类图 组成 1.工厂类:这是本模式的核心,含有一定的商业逻辑和判断逻辑.在java中它往往由一个具体类实现. 2.抽象产品:它一般是具体产品继承的父类或者实现的接口.在java中由接口或者抽象类来实现. 3.具体产品:工厂类所创建的对象就是此角色

大话设计模式之简单工厂模式

       从设计模式的类型来说,简单工厂模式是属于创建性模式,又叫做静态工厂方法模式,但不属于23中GOF设计模式之一,简单的工厂模式是由一个工厂对象决定创建出哪一种产品类的实例,简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现.         那么到底什么是简单工厂模式?我们中午在中快食堂吃饭,中快食堂满足了我们的需求,这里的中快食堂就是一个简单的工厂,在现实生活中工厂是负责生产产品的,,同样在设计模式中,简单工厂模式我们也可以理解为负责生产对象的一个

java设计模式之简单工厂模式_java

在编写一个计算器程序时,可以将业务逻辑和显示分离,业务逻辑封装为一个类(封装):如果要新添加一种运算,可以先创建一个Operation的基类,然后各种运算从Operation类继承,并实现GetResult()虚函数,这时添加新的运算只需要派生一个新的类,即不需要之前的运算参与编译.如何让计算器知道我是希望使用哪种运算呢?应该考虑单独的类来做这个创造实例的过程,这就是工厂.创建一个OperationFactory类,传入参数,函数createOperate就可以实例化出合适的对象. Java代码

设计模式之简单工厂模式(Simple Factory Pattern)

设计 工厂模式 THE FACTORY PATTERN 在面向对象(OO)程序中,我们经常看到的一种模式就是简单工厂模式(Simple Factory Pattern).简单工厂模式根据提供给它的数据,返回几个可能类中的一个类的实例.通常它返回的类都有一个共同的父类和共同的方法,但每个方法执行的认为不同,而且根据不同的数据进行了优化.简单工厂模式实际上不属于23个GOF模式,但它可以作为工厂方法模式(FACTORY Method)的一个引导. 工厂模式如何工作 为了便于理解简单工厂模式,可以看下

.Net设计模式之简单工厂模式(Simple Factory Pattern)

一.简单工厂模式简介(Bref Introduction) 简单工厂模式(Simple Factory Pattern)的优点是,工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖 二.解决的问题(What To Solve) 客户实例化对象时不需要关心该对象是由哪个子类实例化的. 三.简单工厂模式分析(Analysis) 1.简单工厂模式结构 IProduct接口:抽象产品类 ConcreteProduct类:产品类的具体实现 Simp