`
huntfor
  • 浏览: 201571 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

设计模式(2)——工厂模式

 
阅读更多

合理的模式可以提高代码复用性,可维护性已经灵活性,下面介绍一下设计模式中的工厂模式,简单好用,也是上篇博文——面向接口编程  的更高一层的抽象。

 

面向接口将规范和实现分离,配合多态,使的代码的复用率提高,减少了代码量,比如说,我们不必为每一个对象写doEverything方法了,但是,当50个类中都需要new出person的话,我们还要在50个类中分别new出50个person,这似乎是必须的,但是当我们突然发现不应该new person,而应该new fox的时候,我们就需要到50个类中分别修改代码(这不是开闭原则..),不开心啊。。。。如果我们可以在将new 对象的动作放在一个统一的地方,只要在这个地方改一下,就可以将全局的person变成fox,岂不是大快人心。工厂来了,救星来了——更高一层的抽象。

 

工厂顾名思义,生产货品的地方,java中肯定是生产对象的地方,这里我们可以假设一个厂房有4个button,A,B,C,D分别对应person、cat、dog、fox,当我们发现person需要换成fox,简单,别按按钮A了,按下按钮D,fox就源源不断从流水线上出来了。是的,我们不再自己动手new对象了,而将这个动作托管给了工厂,当我们需要要某个对象的时候,只需要从工厂取就好了。

 

进入正题:

工厂模式分为两类:

1.工厂方法模式;(简单工厂模式是工厂方法模式的一个特例)

2.抽象工厂模式

 

先从最简单的简单工厂模式开始,先将该模式的几个角色定位一下:

1.工厂类角色:是具体产品类角色的构造者;(工厂模式,肯定要有工厂啦)

2.抽象产品角色:被工厂创建的对象;(之所以需要抽象产品,原因在面向接口编程中已经说过了)

3.具体产品角色:调用工厂类产生实例,并利用多态进行相应工作。(有抽象,就必须要有具体的实现类)

4.消费者角色:请求工厂生产实例(有生产就有买卖)

 

用上篇博文中(http://huntfor.iteye.com/admin/blogs/2024611)的例子:

 

package factoryPattern;

import Gof.Runable;

public class FactoryPattern {

	private static void doEverything(Runable runable) {
		System.out.println("now I am ready to run....");
		runable.run();
		System.out.println("I am tired and wanna walk for a while...");
		runable.walk();
		System.out.println("I am totally tired wanna stop....");
		runable.stop();
	}

	public static void main(String[] args) {

		// 将new 对象的工作托管给工厂,工厂实现对对象的统一管理
		Runable product = Factory.getByType('A');
		doEverything(product);
	}

}

class Factory {
	// 这里当然可以用非静态方法
	public static Runable getByType(char type) {
		if (type == 'A') {
			return new Person();
		} else if (type == 'B') {
			return new Cat();
		} else if (type == 'C') {
			return new Dog();
		} else if (type == 'D') {
			return new Fox();
		} else {
			return null;
		}
	}

}

class Person implements Runable {
	@Override
	public void run() {
		System.out.println("people run....");
	}

	@Override
	public void walk() {
		System.out.println("people walk....");
	}

	@Override
	public void stop() {
		System.out.println("people stop....");
	}
....下面的几个都一样
}

 这样,就对实例对象的产生有统一到了一个接口上(不再是狭义的interface),消费者直接与工厂这层接口交互,将new对象的过程又一次进行了封装。

 

 

工厂方法模式是简单工厂模式的衍生,并且解决了很多简单工厂模式存在的问题:

开闭原则要就我们对外可扩展,这里就暴露了简单工厂模式的局限性。现实生活中,一个工厂往往工作单一,比如说可口可乐公司只生产可乐,你可以生产各种汽水,比如雪碧,芬达,酷儿,醒目等等,但是你总不能生产空调吧。夏天即需要空调又需要可乐,怎么办?很简单啊,再建一个空调厂就可以了。问题又来了,这样的话,岂不是又要到处new 空调厂和可乐厂了?如果有必要,我们可以对这两个工厂再做一次工厂模式,建造一个生产工厂的工厂。

插句嘴:工厂方法模式是典型的模板方法模式的应用。后面再讲

 

工厂方法模式的框架

很简单,对每种产品建造响应的工厂。

下面简单实现一下:

产品接口:

package factoryPattern;

public interface IProduct {
	void function();
}

abstract class Cola implements IProduct{

	@Override
	public void function() {
		System.out.println("用於解渴");
	}
	public abstract void getMyBrand();
}

class CocoCola extends Cola{
	@Override
	public void getMyBrand() {
		System.out.println("我是可口可乐");
	}
}

class Sprite extends Cola{
	@Override
	public void getMyBrand() {
		System.out.println("我是雪碧");
	}
}


abstract class AirCondition implements IProduct{

	@Override
	public void function() {
		System.out.println("用于降温");
	}
	public abstract void getMyPower();
}

class Galanz extends AirCondition{
	@Override
	public void getMyPower() {
		System.out.println("我的功率是1P");
	}
}

class Midea extends AirCondition{
	@Override
	public void getMyPower() {
		System.out.println("我的功率是1.5P");
	}
}

 工厂接口:

public interface INormalFactory {
	IProduct produce(String type)throws Exception;
}

 工厂实现类:

package factoryPattern;

public class ColaFactory implements INormalFactory {

	@Override
	public IProduct produce(String type) throws Exception {
		if(type == "A"){
			return new CocoCola();
		}
		else if(type == "B"){
			return new Sprite();
		}else{
			throw new Exception("your type is not fund");
		}
	}
}

class AirConditionFactory implements INormalFactory {

	@Override
	public IProduct produce(String type)throws Exception {
		if(type =="A"){
			return new Galanz();
		}else if(type == "B"){
			return new Midea();
		}else{
			throw new Exception("your type is not fund");
		}
	}
	
	
}

 消费者角色:(我画蛇添足的加了一点反射以及抽象类,如果不是很清楚的,可以先简单看一下反射)

package factoryPattern;

public class NormalFactoryTest {
	
	static void getDetail(IProduct product) throws InstantiationException, IllegalAccessException{
		product.function();
		if(product instanceof Cola){
			if(product.getClass().newInstance() instanceof Cola){
				((Cola)product).getMyBrand();
			}
			
		}else if(product instanceof AirCondition){
			if(product.getClass().newInstance() instanceof Galanz){
				((Galanz)product).getMyPower();
			}else if(product.getClass().newInstance() instanceof Midea){
				((Midea)product).getMyPower();
			}
		}
	}
	
	public static void main(String[] args) throws Exception {
		
		INormalFactory colaFactory = new ColaFactory();
		INormalFactory airContidionFactory = new AirConditionFactory();

		IProduct cocoCola = colaFactory.produce("A");
		IProduct sprite = colaFactory.produce("B");
		IProduct glanze =  airContidionFactory.produce("A");
		IProduct midea =  airContidionFactory.produce("B");
		
		getDetail(cocoCola);
		getDetail(sprite);
		getDetail(glanze);
		getDetail(midea);
		
	}
	
}

 以上是工厂方法模式。

 

抽象工厂模式是所有工厂模式中最具一般性的形态,因而也更抽象。会专门用一篇博文做详细的解释。

 

 

分享到:
评论

相关推荐

    设计模式——工厂方法模式

    工厂方法模式是面向对象设计模式中的一种,它属于创建型模式,主要解决的是当系统需要创建的对象具有多种类型,而具体创建哪种类型的对象在运行时才能确定的问题。在这个压缩包中,`FactoryMethod`可能包含了Java...

    设计模式——工厂模式在开发中的应用(简单计算器)

    这个是http://blog.csdn.net/dawanganban/article/details/9884681博客中java设计模式的源代码。下载前请先看《设计模式——工厂模式在开发中的应用》一文。

    设计模式——简单工厂模式

    **设计模式——简单工厂模式** 简单工厂模式是创建型设计模式的一种,它提供了一种创建对象的最佳方式。在简单工厂模式中,一个专门的类(称为工厂类)负责创建对象,客户端无需知道所创建的对象的具体类,只需要...

    设计模式——抽象工厂模式

    抽象工厂模式是设计模式中的一种创建型模式,它提供了一种创建对象集合的接口,而无需指定具体类。这种模式的主要目的是为了隔离产品对象的创建和使用,使得系统对产品类的依赖降低到最低,同时也方便了产品的扩展和...

    设计模式实现——抽象工厂模式结构实现

    抽象工厂模式是设计模式中的一种创建型模式,它提供了一种创建对象集合的接口,而无需指定具体的类。这种模式允许客户端使用一个通用接口来创建一组相关或相互依赖的对象,而无需关心它们的具体实现。在Java或其他...

    设计模式实现——观察者模式

    在《设计模式实现——观察者模式》这篇博客中,作者可能详细解释了观察者模式的概念、结构以及其在实际编程中的应用。以下是对观察者模式的详细阐述: 1. **模式定义**:观察者模式是一种对象行为型模式,它允许...

    软件设计模式——抽象工厂

    在学习和应用抽象工厂模式时,理解其核心思想——封装变化和解耦,以及如何在实际项目中选择合适的场景使用这一模式,是非常关键的。对于软件工程专业的学生来说,掌握这一模式不仅可以提升编程能力,还能提高对软件...

    设计模式——简单工厂 VS 工厂方法

    简单工厂模式,也称为静态工厂模式,是一种创建型设计模式,它提供了一个静态方法来创建对象,而无需暴露实例化逻辑。在简单工厂模式中,一个单一的工厂类负责生产所有相关类型的实例。这种模式适用于产品种类较少且...

    Android之大话设计模式——:抽象工厂模式借鉴.pdf

    Android之大话设计模式——:抽象工厂模式借鉴.pdf

    设计模式——刘伟

    2. **工厂模式**:定义一个创建对象的接口,让子类决定实例化哪一个类。工厂模式使代码更加灵活,避免了硬编码具体类名。分为简单工厂、工厂方法和抽象工厂三种类型。 3. **观察者模式**:定义对象之间的一对多依赖...

    设计模式之美——教你写出高质量代码

    "设计模式之美——教你写出高质量代码"这个主题旨在帮助开发者更好地理解和应用设计模式,从而提升代码的质量和可维护性。设计模式不仅对面试有所帮助,也是职场发展中的必备技能,无论你使用哪种开发语言。 设计...

    实验二 简单工厂模式.zip_31QS_C#_设计模式——简单工厂模式_设计模式实验

    简单工厂模式是软件设计模式中的一种基础模式,它属于创建型模式,主要解决对象的创建问题,降低了客户端代码与具体产品类之间的耦合度。在本实验中,我们将深入理解和应用C#语言实现简单工厂模式。 简单工厂模式的...

    深入浅出设计模式四——比萨店生产比萨实现(工厂方法模式)

    在IT行业中,设计模式是软件开发中的重要概念,它们代表了在特定场景下解决常见问题的最佳实践。本文将深入探讨“工厂方法模式”,并结合比萨店生产比萨的实例来解析这一模式的运用。首先,我们要理解工厂方法模式的...

    Java设计模式——工厂设计模式详解

    Java设计模式——工厂设计模式详解 在软件设计中,工厂设计模式是一种常用的设计模式,主要用于实例化有共同接口的类。Java设计模式——工厂设计模式是Java中的一种常用的设计模式,主要用于实例化有共同接口的类。...

    设计模式代码——c#

    C#设计模式(23种设计模式) 1. 单件模式(Singleton Pattern) 2. 抽象工厂(Abstract Factory) 3. 建造者模式(Builder) 4. 工厂方法模式(Factory Method) 5. 原型模式(Prototype) 结构型: 6. 适配器...

    C#设计模式(3)——工厂方法模式.pdf

    工厂方法模式之所以可以解决简单工厂的模式,是因为它的实现把具体产品的创建推迟到子类中,此 时工厂类不再负责所有产品的创建,而...下面看下工厂模式 的具体实现代码(这里还是以简单工厂模式中点菜的例子来实现):

    Android之大话设计模式——:抽象工厂模式参考.pdf

    Android之大话设计模式——:抽象工厂模式参考.pdf

    设计模式——GFour

    《设计模式——GFour》是一本深受IT从业者喜爱的经典书籍,尤其在C++开发者中具有广泛影响力。设计模式是软件工程领域中的一种最佳实践,它总结了在特定情境下解决问题的常见方法,使得代码可读性更强,复用性更高,...

    深入浅出设计模式四——多区域比萨加盟店生产比萨实现(抽象工厂模式)

    今天我们将深入探讨“抽象工厂模式”(Abstract Factory Pattern),它在“深入浅出设计模式四——多区域比萨加盟店生产比萨实现”中得到了应用。这个模式主要用于创建一系列相关的对象,而无需指定其具体的类。 ...

    c#工厂模式——简单工厂,抽象工厂,单件模式实例

    2. **抽象工厂模式**: 抽象工厂模式则更进一步,它提供了一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类。在多线程或者跨平台的C#应用中,抽象工厂可以帮助我们隔离产品族,使得更换产品族变得...

Global site tag (gtag.js) - Google Analytics