工厂模式

一、工厂模式介绍

1、工厂模式简介

(1)实例化对象,用工厂方法代替new操作;

(2)工厂模式包括工厂方法模式和抽象工厂模式,抽象工厂模式是工厂方法模式的扩展;

2、工厂模式的意图

(1)定义一个接口来创建对象,但是让子类来决定哪些类需要被实例化;

(2)工厂方法把实例化的工作推迟到子类中去实现;

3、什么情况下适合工厂模式?

(1)有一组类似的对象需要创建;

(2)在编码时不能预见需要创建哪种类的实例;

(3)系统需要考虑扩展性,不应依赖于产品类实例如何被创建、组合和表达的细节;

4、工厂模式的动机

(1)在软件系统中经常面临着“对象”的创建工作,由于需求的变化,这个对象可能随之也会发生变化,但它却拥有比较稳定的接口。为此,我们要提供一种封装机制来隔离出这个易变对象的变化,从而保持系统中其他依赖该对象的对象不随着需求变化而变化;

(2)基于以上情况,代码设计应尽量松耦合,一个对象的依赖对象的变化与本身无关,具体产品与客户端剥离,责任分割;

5、工厂模式类图


二、工厂模式应用

1、引例

发型接口:

public interface HairInterface {
	//画一个发型
	public void drawHair();
}
左偏分发型实现类:
public class LeftHair implements HairInterface{

	@Override
    public void drawHair() {
	    System.out.println("画一个左偏分发型");	    
    }
	
}
右偏分发型实现类:
public class RightHair implements HairInterface{

	@Override
    public void drawHair() {
	    System.out.println("画一个右偏分发型");	    
    }
	
}
测试类:
public class Test {

	public static void main(String[] args) {
		//画一个左偏分发型
	    HairInterface left = new LeftHair();
	    left.drawHair();
	    //画一个右偏分发型
	    HairInterface right = new RightHair();
	    right.drawHair();
    }
	
}

2、以上是最普通的实现方式,但是非常麻烦,每画一个新发型,都要new一个新实例,耦合性高。运用工厂模式,我们增加一个发型的工厂管理类:

/**
 * 发型的工厂管理类
 */
public class HairFactory {
        //根据标识生产对象
	public HairInterface getHair(String hair){
		if("left".equals(hair)){
			return new LeftHair();
		}else if("right".equals(hair)){
			return new RightHair();
		}
		return null;
	}
}
此时,测试类修改为:

public class Test {

	public static void main(String[] args) {
		//画一个左偏分发型
	    HairFactory factory = new HairFactory();
	    HairInterface hair = factory.getHair("left");
	    if(hair!=null){
	    	hair.drawHair();
	    }	    
    }
	
}
3、上述的工厂管理类,还可以简化,通过类名去生产对象,修改如下:

/**
 * 发型的工厂管理类
 */
public class HairFactory {

	//根据类名生产对象
	public HairInterface getHairByClassName(String className){
		try {
	        HairInterface hair = (HairInterface) Class.forName(className).newInstance();
	        return hair;
        } catch (InstantiationException e) {
	        e.printStackTrace();
        } catch (IllegalAccessException e) {
	        e.printStackTrace();
        } catch (ClassNotFoundException e) {
	        e.printStackTrace();
        }
		return null;
	}
}
此时,测试类修改为:

public class Test {

	public static void main(String[] args) {
		//画一个左偏分发型
	    HairFactory factory = new HairFactory();
	    HairInterface hair = factory.getHairByClassName("Factory.LeftHair");
	    if(hair!=null){
	    	hair.drawHair();
	    }	    
    }
	
}
4、上述方法已经实现了工厂模式的应用,但是通过类名去生产对象,如果类名过长就容易写错,所以可以通过映射的方法去优化,此时需要添加一个属性文件type.properties和属性读取类PropertiesReader.java
type.properties代码如下:

left=Factory.LeftHair
right=Factory.RightHair
PropertiesReader.java
public class PropertiesReader {
	
	public Map<String, String> getProperties(){
		Properties props = new Properties();
		Map<String, String> map = new HashMap<String, String>();
		try {
			InputStream in = getClass().getResourceAsStream("type.properties");
			props.load(in);
			Enumeration en = props.propertyNames();
			while (en.hasMoreElements()) {
				String key = (String) en.nextElement();
				String property = props.getProperty(key);
				map.put(key, property);
				System.out.println(key + "  " + property);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return map;
	}
}
工厂管理类修改为:

/**
 * 发型的工厂管理类
 */
public class HairFactory {

	// 根据类名的映射生产对象
	public HairInterface getHairByClassKey(String key) {
		try {
			Map<String, String> map = new PropertiesReader().getProperties();
			HairInterface hair = (HairInterface) Class.forName(map.get(key)).newInstance();
			return hair;
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
}
测试类修改为:

public class Test {

	public static void main(String[] args) {
		//画一个左偏分发型
	    HairFactory factory = new HairFactory();
	    HairInterface hair = factory.getHairByClassKey("left");
	    if(hair!=null){
	    	hair.drawHair();
	    }	    
    }
	
}
三、抽象工厂模式应用

应用场景:脸萌需要做不同的头像系列,比如男孩新年系列、男孩圣诞系列、女孩新年系列、女孩圣诞系列

/**
 * 男孩系列
 */
public interface Boy {
	public void drawBoy();
}
/**
 * 女孩系列
 */
public interface Girl {
	public void drawGirl();
}
/**
 * 新年男孩系列
 */
public class HNBoy implements Boy{

	@Override
    public void drawBoy() {
	    System.out.println("新年男孩系列");	    
    }

}
/**
 * 圣诞男孩系列
 */
public class MCBoy implements Boy{

	@Override
    public void drawBoy() {
	    System.out.println("圣诞男孩系列");	    
    }

}
/**
 * 新年女孩系列
 */
public class HNGirl implements Girl{

	@Override
    public void drawGirl() {
	    System.out.println("新年女孩系列");	    
    }

}
/**
 * 圣诞女孩系列
 */
public class MCGirl implements Girl{

	@Override
    public void drawGirl() {
	    System.out.println("圣诞女孩系列");	    
    }

}
/**
 * 人物的实现接口
 */
public interface PersonFactory {
	public Boy getBoy();
	public Girl getGirl();
}
/**
 * 新年系列加工厂
 */
public class HNFactory implements PersonFactory{

	@Override
    public Boy getBoy() {
	    return new HNBoy();	    
    }

	@Override
    public Girl getGirl() {
		return new HNGirl();	  
    }

}
/**
 * 圣诞系列加工厂
 */
public class MCFactory implements PersonFactory{

	@Override
    public Boy getBoy() {
	    return new MCBoy();	    
    }

	@Override
    public Girl getGirl() {
		return new MCGirl();	  
    }

}
/**
 * 测试类
 */
public class Test {

	public static void main(String[] args) {
		//生成一个圣诞系列的Boy
		PersonFactory factory = new MCFactory();
		Boy boy = factory.getBoy();
		boy.drawBoy();
//		//生成一个圣诞系列的Girl
//		PersonFactory factory = new MCFactory();
//		Girl girl = factory.getGirl();
//		girl.drawGirl();
//		//生成一个新年系列的Boy
//		PersonFactory factory = new HNFactory();
//		Boy boy = factory.getBoy();
//		boy.drawBoy();
//		//生成一个新年系列的Girl
//		PersonFactory factory = new HNFactory();
//		Girl girl = factory.getGirl();
//		girl.drawGirl();
    }
	
}
【运行结果】圣诞男孩系列

四、总结

1、工厂方法模式和抽象工厂模式的对比

(1)工厂模式是一种极端情况的抽象工厂模式,而抽象工厂模式可以看成是工厂模式的推广;

(2)工厂模式是用来创建一个产品的等级结构,而抽象工厂模式是用来创建多个产品的等级结构;

(3)工厂模式只有一个抽象产品类,而抽象工厂模式有多个抽象产品类;

2、工厂模式的优点

(1)系统可以在不修改具体工厂角色的情况下引进新的产品;

(2)客户端不必关心对象如何创建,明确了职责;

(3)更好的理解面向对象的原则,面向接口编程,而不是面向实现编程;

3、工厂模式适用于哪些场景

(1)一个系统应当不依赖于产品类实例被创建、组成、表示的细节,这对于所有形态的工厂模式都是重要的;

(2)这个系统的产品有至少一个的产品族;

(3)同属于同一个产品族的产品是设计成在一起使用的,这一约束必须得在系统的设计中体现出来;

(4)不同的产品以一系列的接口面貌出现,从而使系统不依赖于接口实现的细节;

五、工厂模式的一个常用举例


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值