java23种常用设计模式之工厂方法模式（Factory Method）2

就举个比较容易理解的例子：人有白、黑、黄三种人，他们都会说会笑，无论什么肤色。类图我就省了，大家有兴趣可以画画。

工厂方法模式：

管你是白的、黑的还是黄的，反正都是人，会说会笑，所以先定义一个人类的接口（Human）

package com.freedom.factory.abstractfactory;

public interface Human {

public void say();
public void smile();

}

接着定义人种：

package com.freedom.factory.abstractfactory;

public class YellowHuman implements Human{

@Override
public void say() {
System.out.println("yellow human can say anything!");

}

@Override
public void smile() {
System.out.println("yellow human can smile!");

}

}

package com.freedom.factory.abstractfactory;

public class WhiteHuman implements Human{
    
    
    @Override
    public void say() {
        System.out.println("white human can say anything!");
        
    }

    @Override
    public void smile() {
        System.out.println("white human can smile!");
        
    }

}

package com.freedom.factory.abstractfactory;

public class BlackHuman implements Human{
    
    
    @Override
    public void say() {
        System.out.println("black human can say anything!");
        
    }

    @Override
    public void smile() {
        System.out.println("black human can smile!");
        
    }

}

造人工厂

package com.freedom.factory.abstractfactory;

public class HumanFactory {

public static Human createHuman(Class c) {

Human human = null; // 定义一个类型的人类
try {
human = (Human) Class.forName(c.getName()).newInstance();

} catch (InstantiationException e) {
System.out.println("必须指定人种的颜色");
} catch (IllegalAccessException e) {
System.out.println("人种定义错误！");
} catch (ClassNotFoundException e) {
System.out.println("混蛋，你指定的人种找不到！");
}
return human;
}
}

test

package com.freedom.factory.abstractfactory;

import org.junit.Test;

public class TestAbstractFactory {

@Test
public void test() {
System.out.println("生产的第一批人是：白人");
Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
whiteHuman.say();
whiteHuman.smile();
}

@Test
public void test2() {
System.out.println("生产的第二批人是：黑人");
Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
blackHuman.say();
blackHuman.smile();
}

@Test
public void test3() {
System.out.println("生产的第三批人是：黄人");
Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
yellowHuman.say();
yellowHuman.smile();
}

}
/*
运行结果：
生产的第一批人是：白人
white human can say anything!
white human can smile!
生产的第三批人是：黄人
yellow human can say anything!
yellow human can smile!
生产的第二批人是：黑人
black human can say anything!
black human can smile!
*/

当然机器总是不停地生产有时也会罢工，所以这里可以偷个懒，目前的HumanFactory只能定性生产特定人种，改造一下，让它可以批量随机生产

package com.freedom.factory.abstractfactory;

import java.util.List;
import java.util.Random;

public class HumanFactory {

//批量随机生产
public static Human createHuman(){
Human human=null; //定义一个类型的人类
//首先是获得有多少个实现类，多少个人种
List<Class> concreteHumanList = ClassUtils.getAllClassByInterface(Human.class); //定义了多少人种
//随机生产什么人种都OK
Random random = new Random();
int rand = random.nextInt(concreteHumanList.size());
human = createHuman(concreteHumanList.get(rand));
return human;
}

//人种定向生产
public static Human createHuman(Class c) {

Human human = null; // 定义一个类型的人类
try {
human = (Human) Class.forName(c.getName()).newInstance();

} catch (InstantiationException e) {
System.out.println("必须指定人种的颜色");
} catch (IllegalAccessException e) {
System.out.println("人种定义错误！");
} catch (ClassNotFoundException e) {
System.out.println("Sorry，你指定的人种找不到！");
}
return human;
}

}

test

package com.freedom.factory.factory2;

import org.junit.Test;

public class TestFactory2 {

@Test
public void test() {
for(int i=0; i<10; i++){
System.out.println("---随机生产---" + i);
Human human = HumanFactory.createHuman();
human.say();
human.smile();
}
}

}
/*
---随机生产---0
black human can say anything!
black human can smile!
---随机生产---1
black human can say anything!
black human can smile!
---随机生产---2
black human can say anything!
black human can smile!
---随机生产---3
white human can say anything!
white human can smile!
---随机生产---4
black human can say anything!
black human can smile!
---随机生产---5
white human can say anything!
white human can smile!
---随机生产---6
black human can say anything!
black human can smile!
---随机生产---7
black human can say anything!
black human can smile!
---随机生产---8
yellow human can say anything!
yellow human can smile!
---随机生产---9
yellow human can say anything!
yellow human can smile!
*/
 

总结一下，增加了createHuman()后，是不是这个工厂的扩展性更好了？你看你要再加一个人种，只要你继续集成Human 接口成了，然后啥都不用修改就可以生产了，具体产多少，随便你说了算，普通工厂模式就是这么简单，然后我们再引入一个问题：人是有性别的呀，有男有女，你这怎么没区别，别急，继续往下看！

工厂方法模式还有一个非常重要的应用，就是延迟始化(Lazy initialization)，什么是延迟始化呢？一个对象初始化完毕后就不释放，等到再次用到得就不用再次初始化了，直接从内存过中拿到就可以了，怎么实现呢，很简单，看例子：

package com.freedom.factory.factory2;

import java.util.HashMap;

public class HumanFactory2 {
// 定义一个MAP,初始化过的Human对象都放在这里
private static HashMap<String, Human> humans = new HashMap<String, Human>();

public static Human createHuman(Class c) {
Human human = null; // 定义一个类型的人类
try {
//这个在类初始化很消耗资源的情况比较实用，比如你要连接硬件，或者是为了初始化一个类需要准备比较多条件（参数），通过这种方式可以很好的减少项目的复杂程度。
// 如果MAP中有，则直接从取出，不用初始化了
if (humans.containsKey(c.getSimpleName())) {
human = humans.get(c.getSimpleName());
} else {
human = (Human) Class.forName(c.getName()).newInstance();
// 放到MAP中
humans.put(c.getSimpleName(), human);
}
} catch (InstantiationException e) {
System.out.println("必须指定人种的颜色");
} catch (IllegalAccessException e) {
System.out.println("人种定义错误！");
} catch (ClassNotFoundException e) {
System.out.println("混蛋，你指定的人种找不到！");
}
return human;
}
}

好了，这还只是工厂方法模式，我想做些拓展，比如白人有男人女人，其他人种也是，这个扩展看似很简单，只要修改各个人种的工厂类就可以了，但是这样做有什么不好呢？违反了闭包原则。那有什么方法可以避免呢？抽象方法继续看下次……

下载源码：http://download.csdn.net/detail/github_22022001/8290541