这里我要写的整个设计模式的学习日志，我想以魔兽世界这个游戏里的内容来比喻，虽然不爱玩了，不过，提高趣味性，我认为对学习很有帮助。
玩魔兽世界，最开始的时候是干什么呢？答案当然是建人物了，在这里，我们认为是有一个“创建人物工厂”，这个工厂的作用就是，你告诉它，你要创建血精灵妹纸，那它就给你个血精灵妹纸，你告诉它你要创建矮人大妈，那它就给你创建一个矮人大妈，那如何实现这个工厂呢？我这里思考了两种方案，至于哪一种方案好，写完了再总结下。
方案1：
我是一个很大的工厂，目前有10个种族可以选择，OK，你告诉我你要什么种族的，我就给你什么种族的角色。
首先要有一个角色接口，用于工厂创建角色返回的类型
IRole.
java[
java] package factory;
public
interface IRole {
}
package factory;
public interface IRole {
}
然后创建角色的工厂类如下：
RoleFactory.
java[
java] package factory;
public class RoleFactory {
public IRole createRole(String roleName, String myName, String mySex, String post) {
if (roleName.equals("manikin")) {// 如果你要侏儒，我就给你侏儒
return new Manikin(myName, mySex, post);
} else if (roleName.equals("human")) {// 如果你要人类，我就给你人类
return new Human(myName, mySex, post);
}// 为了减少代码量，这里就写了两种角色
return null;
}
}
package factory;
public class RoleFactory {
public IRole createRole(String roleName, String myName, String mySex, String post) {
if (roleName.equals("manikin")) {// 如果你要侏儒，我就给你侏儒
return new Manikin(myName, mySex, post);
} else if (roleName.equals("human")) {// 如果你要人类，我就给你人类
return new Human(myName, mySex, post);
}// 为了减少代码量，这里就写了两种角色
return null;
}
}
接下来，还有个角色基类，以及一个人类子类和一个侏儒子类
BaseRole.
java[
java] package factory;
/**
* DOC 角色基类
*/
public abstract class BaseRole implements IRole {
protected String race;// 种族
protected String sex;// 性别
protected String name;// 名字
protected String post;// 职业
public void speak() {
System.out.println("Hi,I am a " + race + " my name is " + name + " and my post is " + post);
}
}
package factory;
/**
* DOC 角色基类
*/
public abstract class BaseRole implements IRole {
protected String race;// 种族
protected String sex;// 性别
protected String name;// 名字
protected String post;// 职业
public void speak() {
System.out.println("Hi,I am a " + race + " my name is " + name + " and my post is " + post);
}
}
Human.
java[
java] package factory;
/**
* DOC 人类
*/
public class Human extends BaseRole {
public Human(String name, String sex, String post) {
race = "human";
super.name = name;
super.sex = sex;
super.post = post;
}
}
package factory;
/**
* DOC 人类
*/
public class Human extends BaseRole {
public Human(String name, String sex, String post) {
race = "human";
super.name = name;
super.sex = sex;
super.post = post;
}
}
Manikin.
java[
java] package factory;
/**
* DOC 侏儒
*/
public class Manikin extends BaseRole {
public Manikin(String name, String sex, String post) {
race = "Manikin";
super.name = name;
super.sex = sex;
super.post = post;
}
}
package factory;
/**
* DOC 侏儒
*/
public class Manikin extends BaseRole {
public Manikin(String name, String sex, String post) {
race = "Manikin";
super.name = name;
super.sex = sex;
super.post = post;
}
}
最后，测试类：
[
java] package test;
import factory.Human;
import factory.Manikin;
import factory.RoleFactory;
public class FactoryTest1 {
public static void main(String[] args) {
// 分别创建两个角色，一个侏儒，一个人类
RoleFactory factory = new RoleFactory();
Human human = (Human) factory.createRole("human", "法神", "man", "法师");
Manikin manikin = (Manikin) factory.createRole("manikin", "血匕透心凉", "girl", "盗贼");
human.speak();
manikin.speak();
}
}
package test;
import factory.Human;
import factory.Manikin;
import factory.RoleFactory;
public class FactoryTest1 {
public static void main(String[] args) {
// 分别创建两个角色，一个侏儒，一个人类
RoleFactory factory = new RoleFactory();
Human human = (Human) factory.createRole("human", "法神", "man", "法师");
Manikin manikin = (Manikin) factory.createRole("manikin", "血匕透心凉", "girl", "盗贼");
human.speak();
manikin.speak();
}
}
测试结果：
Hi,I am a human my name is 法神 and my post is 法师
Hi,I am a Manikin my name is 血匕透心凉 and my post is 盗贼
方案2：
和方案1不同的是，这里存在多个子工厂，有创建人类的工厂，也有创建侏儒的工厂。要创建不同的角色，使用不同的工厂来创建即可。
首先有个工厂接口，然后有一个创建人类的工厂，一个创建侏儒的工厂：
[
java] package factory;
public interface IRoleFactory {
public IRole createRole(String myName, String mySex, String post);
}
package factory;
public interface IRoleFactory {
public IRole createRole(String myName, String mySex, String post);
}
[
java] package factory;
/**
* DOC 创建人类工厂
*/
public class HumanFactory implements IRoleFactory {
@Override
public IRole createRole(String myName, String mySex, String post) {
return new Human(myName, mySex, post);
}
}
package factory;
/**
* DOC 创建人类工厂
*/
public class HumanFactory implements IRoleFactory {
@Override
public IRole createRole(String myName, String mySex, String post) {
return new Human(myName, mySex, post);
}
}
[
java] package factory;
/**
* DOC 创建人类工厂
*/
public class ManikinFactory implements IRoleFactory {
@Override
public IRole createRole(String myName, String mySex, String post) {
return new Manikin(myName, mySex, post);
}
}
package factory;
/**
* DOC 创建人类工厂
*/
public class ManikinFactory implements IRoleFactory {
@Override
public IRole createRole(String myName, String mySex, String post) {
return new Manikin(myName, mySex, post);
}
}
其他类不变，测试类修改如下：
[
java] public static void main(String[] args) {
// 分别创建两个角色，一个侏儒，一个人类
IRoleFactory factory = null;
factory = new HumanFactory();
Human human = (Human) factory.createRole("法神", "man", "法师");
factory = new ManikinFactory();
Manikin manikin = (Manikin) factory.createRole("血匕透心凉", "girl", "盗贼");
human.speak();
manikin.speak();
}
public static void main(String[] args) {
// 分别创建两个角色，一个侏儒，一个人类
IRoleFactory factory = null;
factory = new HumanFactory();
Human human = (Human) factory.createRole("法神", "man", "法师");
factory = new ManikinFactory();
Manikin manikin = (Manikin) factory.createRole("血匕透心凉", "girl", "盗贼");
human.speak();
manikin.speak();
}
最后打印结果：
Hi,I am a human my name is 法神 and my post is 法师
Hi,I am a Manikin my name is 血匕透心凉 and my post is 盗贼
总结：个人觉得方案一适合要创建的子类型不多的情况，方案二适合要创建的子类型很多的情况。比如spring就是一个大工厂，装配的每个bean，都是一个一个对应配置好的，和方案一是一样的。还有个区别就是，方案一，你在实例化的时候，要自己知道该给方法传入什么参数，才能得到你要的对象：
Human human = (Human) factory.createRole("human", "法神", "man", "法师");比如这里传入 human，表示我要人类对象。而方案二，通过工厂名称就知道他是创建什么对象的： factory = new HumanFactory(); Human human = (Human) factory.createRole("法神", "man", "法师");这里就不需要自己输入 human了，因为该工厂创建的就已经是人类对象。
