磊哥学设计模式（二）工厂模式

工厂模式

什么是工厂模式

工厂方法模式（FACTORY METHOD）是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品

为什么要用工厂模式

1. 为了解耦，把对象的创建和使用的过程分开。就是Class A 想调用 Class B ，那么A只是调用B的方法，而不用实例化Class B。
2. 降低代码重复量，提高程序的可扩展性。也就是说，创建对象的代码，都放到工厂里面。

代码演示

下面就来演示下，使用工厂模式。
首先，先举个例子，比如一个游戏，有两种攻击方式，魔法攻击和物理攻击，那么我们很容易就写出代码来：

普通代码

public class OldAttack {
	void magic(){
		System.out.println("magic attack!");
	}
	
	void Physical(){
		System.out.println("Physical attack!");
	}
}

然后在主函数调用：

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OldAttack a = new OldAttack();
		a.magic();
	}

}

很简单，对不对，好现在问题来了，需要A,B,C,D四个对象来执行攻击，也很容易，马上就可以写出下面的代码：

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OldAttack a = new OldAttack();
		a.magic();
		
		OldAttack b = new OldAttack();
		b.magic();
		
		OldAttack c = new OldAttack();
		c.magic();
		
		OldAttack d = new OldAttack();
		d.magic();
	}

}

好，现在需求又改了，需要有初始的参数，那么就要改变如下：

public class OldAttack {
	void magic(){
		System.out.println("magic attack!");
	}
	
	void Physical(){
		System.out.println("Physical attack!");
	}
	OldAttack(int a,int b,int c,int d){
		
	}
}

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OldAttack a = new OldAttack(1,2,3,4);
		a.magic();
		
		OldAttack b = new OldAttack(1,2,3,4);
		b.magic();
		
		OldAttack c = new OldAttack(1,2,3,4);
		c.magic();
		
		OldAttack d = new OldAttack(1,2,3,4);
		d.magic();
	}

}

工厂模式代码

改变就要如上，逐个更改，每一个对象的初始化都要加上参数，现在代码比较简单，改起来还算容易，但是要是有更多的代码呢，对于一个工程来说，更改需求很正常，代码量大也很正常。但是改起来真的很麻烦，所以我们就想换一种方式来写：

public interface Attack {
	public void attack();
}

public class Magic implements Attack {

	@Override
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("Magic attack!");
	}

	Magic(int a,int b ,int c,int d){
		
	}
	
}

public class Physical implements Attack {

	@Override
	public void attack() {
		// TODO Auto-generated method stub
		 System.out.println("Physical attack!"); 
	}

	Physical(int a,int b,int c,int d){
		
	}
}

public interface Provider {
	public Attack toAttack();
}

public class MagicFactory implements Provider {

	@Override
	public Attack toAttack() {
		// TODO Auto-generated method stub
		return new Magic(1,2,3,4);
	}

}

public class PhysicalFactory implements Provider {

	@Override
	public Attack toAttack() {
		// TODO Auto-generated method stub
		return new Physical(1,2,3,4);
	}

}

public class FactoryTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Provider p = new MagicFactory();
		Attack a = p.toAttack();
		a.attack();
		
	}

}

如上代码就是，要改的时候只需要改实现类和工厂类，就可以，不影响主函数的使用，而且要扩展的时候，比如加一个特殊攻击，只需要再做个工厂类和实现类。
如下：

public class Special implements Attack {

	@Override
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("Special attack!");
	}

	Special(int a,int b,int c,int d){
		
	}
}

public class SpecialFactory implements Provider {

	@Override
	public Attack toAttack() {
		// TODO Auto-generated method stub
		return new Special(1,2,3,4);
	}

}

public class FactoryTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Provider p = new MagicFactory();
		Attack a = p.toAttack();
		a.attack();
		Provider p2 = new SpecialFactory();
		Attack a2 = p2.toAttack();
		a2.attack();
	}

}

看，扩展起来非常的方便。