`
huntfor
  • 浏览: 194219 次
  • 性别: 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);
		
	}
	
}

 以上是工厂方法模式。

 

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

 

 

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics