Java进阶篇设计模式之二 ----- 工厂模式

前言

在上一篇中咱们学习了单例模式，介绍了单例模式建立的几种方法以及最优的方法。本篇则介绍设计模式中的工厂模式，主要分为简单工厂模式、工厂方法和抽象工厂模式。

简单工厂模式

简单工厂模式是属于建立型模式，又叫作静态工厂方法模式。简单工厂模式是由一个工厂对象决定建立出哪种产品类的实例。调用只须要告诉工厂类所须要的类型，工厂类就会返回须要的产品类工厂的子类。 能够说是工厂模式中最简单的一种。

打个比方，咱们在电脑常常玩游戏，咱们只须要告诉电脑咱们要玩什么游戏，电脑就会打开这个游戏，咱们并不须要关心游戏是怎么运做的。 咱们能够在如下的代码中进行相应的说明。

咱们首先建立一个游戏总类接口，包含一个玩游戏的方法； 而后再由各自的游戏类继承该类并实现该类的方法，最后在建立一个工程类根据不一样的游戏进行建立对象。 那么实现的代码以下：

代码示例：

private static final String LOL="LOL"; 
	private static final String DNF="DNF"; 
	
	public static void main(String[] args) {
		Game game= ComputerFactory.playGame(LOL);
		Game game2= ComputerFactory.playGame(DNF);
		game.play();
		game2.play();
	}
}

interface Game{
	void play();
}

class LOL implements Game{
	@Override
	public void play() {
		System.out.println("正在玩LOL...");
	}	
}

class DNF implements Game{
	@Override
	public void play() {
		System.out.println("正在玩DNF...");
	}	
}


class ComputerFactory{
	private static final String LOL="LOL"; 
	private static final String DNF="DNF"; 
	 public static Game playGame(String game){
		 if(LOL.equalsIgnoreCase(game)){
			 return new LOL();
		 }else if(DNF.equalsIgnoreCase(game)){
			 return new DNF();
		 }
		 return null;
	 }

输出结果：

正在玩LOL...
正在玩DNF...

咱们在使用简单工厂模式进行实现该功能以后，会发现咱们将游戏类的实例化放到了工厂类中实现，隐藏了对象建立的细节，而且不须要知道是怎么玩的，只须要知道调用该工厂类就好了。并且方便切换，由于只需更改工厂类传递的类型值就好了。 可是咱们也发现一个问题，若是咱们须要新增一个游戏类，那么须要新定义一个接口，而后还要在工厂类中添加一个判断分支，若是少许的话还好，可是大量的话就比较麻烦了，而且这也违背了开放-封闭原则。

工厂方法模式

工厂方法模式是 Java 中最经常使用的设计模式之一，属于建立型模式。定义一个建立对象的接口，让其子类本身决定实例化哪个工厂类，工厂模式使其建立过程延迟到子类进行。

在简单工厂模式中，咱们发如今添加子类的时候，相应的也须要在工厂类中添加一个判断分支，是违背了开放-封闭原则的。而工厂方法模式就是主要解决这个问题的。

这里仍是用上述的玩游戏示例，只不过这里每一个游戏都是由各自的游戏工厂类实现。主要区别就是由一个 工厂类变成了多个了，下降了耦合度。若是新增一个游戏类，相应的也只需在新增一个工厂类而已， 而且完美的遵循了开放-封闭原则。

将上述代码更改以后，相应的代码实现以下：

代码示例：

private static final String LOL="LOL"; 
	private static final String DNF="DNF"; 
	private static final String WOW="WOW"; 

	public static void main(String[] args) {

		Game game3=new LOLFactory().playGame(LOL);
		Game game4=new DNFFactory().playGame(DNF);
		Game game5=new WOWFactory().playGame(WOW);
		game3.play();
		game4.play();
		game5.play();		
	}
	
interface Game{
	void play();
}


class LOL implements Game{
	@Override
	public void play() {
		System.out.println("正在玩LOL...");
	}	
}

class DNF implements Game{
	@Override
	public void play() {
		System.out.println("正在玩DNF...");
	}	
}

class WOW  implements Game{
	@Override
	public void play() {
		System.out.println("正在玩WOW...");
	}	
}


interface ComputerFactory2{
	Game playGame(String game);
}

class LOLFactory implements ComputerFactory2{
	@Override
	public Game playGame(String game) {
		return new LOL();
	}
}

class DNFFactory implements ComputerFactory2{
	@Override
	public Game playGame(String game) {
		return new DNF();
	}
}

class WOWFactory implements ComputerFactory2{
	@Override
	public Game playGame(String game) {
		return new WOW();
	}
}

输出结果：

正在玩LOL...
正在玩DNF...
正在玩WOW...

能够看到使用工厂方法模式以后，咱们的代码更加清晰了，扩展性也变高了，若是想增长一个产品，只要扩展一个工厂类就能够。可是随之而来的是在系统中增长了复杂度，每增长一个产品时，都须要增长一个具体类和对象实现工厂类。 因此在是否使用该模式需注意。 使用该模式比较经典的使用案例是大名鼎鼎的hibernate框架在选择数据库方言这块。可是若是直接简单的new一个对象的话，则没必要使用了，若使用反而会增长系统的复杂度。

抽象工厂模式

抽象工厂模式是围绕一个超级工厂建立其余工厂。该超级工厂又称为其余工厂的工厂。这种类型的设计模式属于建立型模式，它提供了一种建立对象的最佳方式。也就是提供一个建立一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

抽象工厂模式相比工厂方法模式来讲更加复杂，也更难理解，可是更容易扩展。 抽象工厂模式就将同一类的产品子类归为一类，让他们继承同一个抽象子类，而后把它们看成一组，而后再把多个组组成一个族。 打个比方，仍是上述的玩游戏，咱们能够把LOL和WOW看成PVP类型的游戏，也能够把DNF和WOW看成PVE类型的游戏。

那么相应更改的代码以下：

代码示例：

private static final String LOL="LOL"; 
	private static final String DNF="DNF"; 
	private static final String WOW="WOW"; 
	
	public static void main(String[] args) {

		ComputerFactory3 cf3=new PVPFactory();
		cf3.playGame().play();
		cf3.playGame2().play();
		ComputerFactory3 cf4=new PVEFactory();
		cf4.playGame().play();
		cf4.playGame2().play();			
	}		
}


interface Game{
	void play();
}


class LOL implements Game{
	@Override
	public void play() {
		System.out.println("正在玩LOL...");
	}	
}

class DNF implements Game{
	@Override
	public void play() {
		System.out.println("正在玩DNF...");
	}	
}

class WOW  implements Game{
	@Override
	public void play() {
		System.out.println("正在玩WOW...");
	}	
}


interface ComputerFactory3{
	 Game playGame();
     Game playGame2();
}

class PVPFactory implements ComputerFactory3{

	@Override
	public Game playGame() {
		return new LOL();
	}

	@Override
	public Game playGame2() {
		return new WOW();
	}	
}

class PVEFactory implements ComputerFactory3{

	@Override
	public Game playGame() {
		return new DNF();
	}

	@Override
	public Game playGame2() {
		return new WOW();
	}
	
}

输出结果：

正在玩LOL...
正在玩WOW...
正在玩DNF...
正在玩WOW...

在抽象工厂模式中，能够在不须要知道产品是怎么样的，只需知道是哪一个工厂类就好了。咱们也能够根据子类的共同的特性而将它们设计在一块儿，组成一个相同类型组，能够很方便的直接调用。可是相对的，产品族比较难以扩展，增长一个产品，须要增长相应的接口和实现类。例如某个品牌的手机，有不一样系列，每一个系列有不一样的型号，若是只是增长型号的话，比较容易，可是相对的，增长某个系列就比较麻烦了。 因此咱们在使用抽象工厂模式，也须要相应的结合实际场景来使用。

其它

音乐推荐

在这浮躁的社会，也会受其影响，从而没法静下心来。所以出门走走，静静的听下音乐，会感受心情慢慢的舒缓起来，整我的也会轻松很多。因而便分享一首纯音乐，但愿可以给读者带来轻松和微笑。

<iframe frameborder="no" border="0" marginwidth="0" marginheight="0" width=330 height=86 src="//music.163.com/outchain/player?type=2&id=27580689&auto=0&height=66"></iframe>

原创不易，若是感受不错，但愿给个推荐！您的支持是我写做的最大动力！ 版权声明: 做者：虚无境 博客园出处：http://www.cnblogs.com/xuwujing CSDN出处：http://blog.csdn.net/qazwsxpcm　　　　 我的博客出处：http://www.panchengming.com