三种工厂模式
一、题目要求
1．简单工厂模式
使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
2．工厂方法模式
海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。
3．抽象工程模式
电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。
二、题目分析
- 简单工厂模式
1.创建一个Person接口，里面只有一个抽象方法print()
2.创建Person接口的实现类，分别为Man类和Woman类，实现Person接口的抽象方法print()
3.创建一个工厂类，里面定义一个静态方法createPerson(String string)，返回值为Person接口的实现类对象，参数不同，创建的对象也不同
4.主函数中，可根据createPerson(String string)不同的参数，创建不同的对象，调用print()方法，打印不同的结果
5.当程序中要增加一个新的Robot类时，可创建一个Robot类，实现Person接口的抽象方法print()，在工厂类的createPerson(String string)方法中，当参数为R时，返回Robot类对象
- 工厂方法模式
1.创建一个Aircondition接口，里面只有一个抽象方法print()
2.创建Aircondition接口的实现类，分别为Haier类和Midea类，实现Aircondition接口的抽象方法print()
3.创建一个FactoryMethod 接口，里面只有一个抽象方法product()，返回值类型为Aircondition
4.创建FactoryMethod 接口的实现类，分别为HaierFactory类和MideaFactory类，实现FactoryMethod接口的抽象方法print()，并且返回对应的实例化对象
5.主函数中，将所要生产的空调的工厂实例化，用该引用调用product()方法，产生对应空调的实例化对象，在调用print()方法，打印出来
- 工厂模式
1.将产品等级结构RAM,CPU分别定义为接口，里面都定义一个抽象方法print()
2.创建RAM接口的实现类MacRAM类和MacRAM类，分别实现了RAM的print()抽象方法
3.创建CPU接口的实现类MacCPU类和MacCPU类，分别实现了RAM的print()抽象方法
4.创建一个产品族接口Efactory，里面的抽象方法concreteRAM()，返回值类型为RAM、concreteCPU()返回值类型为CPU
5.创建Efactory接口的实现类MacFactory类和PcFactory类，分别实现了各自的抽象方法，返回不同的实例对象
6.主函数中，将所要的品牌的工厂实例化，用该引用调用具体产品的方法，产生对应的实例化对象，在调用print()方法，打印出来
三、类图设计
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
四、JUnit4测试
简单工厂模式
- 对Man类测试
- 对Robot类测试
- 对Woman类测试
工厂方法模式
- 对Haier类测试
- 对Midea类测试
抽象工厂模式
-
对PcRAM类的测试
-
对MacRAM类的测试
-
对PcCPU类的测试
-
对MacCPU类的测试
五、运行结果
简单工厂模式
- 当参数为M时
- 当参数为W时
- 当参数为R时
工厂方法模式 - 将HaierFactory工厂实例化时
- 将MideaFactory工厂实例化时
抽象工厂模式 - 将Mac的产品族实例化
- 将Pc的产品族实例化
六、经验归纳
- 对三种工厂模式的理解
抽象工厂模式
从类图中我们会发现，增加一个产品族很简单，而增加一个新的产品就会非常复杂。
工厂方法模式
优点：
（1）工厂方法用来创建客户所需要的产品，同时隐藏了哪种具体产品类将被实例化的细节，用户只需要要关注工厂，不需要关注创建的细节。从客户端代码就可以看出，只知道对应的工厂就好
(2)在增加类时不用修改代码，只需要增加对应的工厂就好，符合开闭原则
（3）创建对象的细节完全封装在具体的工厂内部
缺点：
(1)在增加新的产品时，也必须增加新的工厂类，会带来额外的开销
简单工厂模式
优点
（1）简单工厂实现了对象的创建和使用的分离。
（2）客户端无需知道所创建的具体产品类的类名，只需要具体产品类对应的参数即可
（3）在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性
缺点
（1）工厂类的职责过重它一旦有问题，整个系统都要出问题
（2）在添加新的类的时候，违反了开闭原则
- 对JUnit4测试的使用
1.JUnit是一个Java语言的单元测试框架，有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework）。
2.摘自百度百科：
Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件 如何（How）完成功能和完成什么样（What）的功能。Junit是一套框架，继 承TestCase类，就可以用Junit进行自动测试了。JUnit4属于XUnit的一 个子集，是一个测试框架，使用断言机制。
3.JUnit测试代码的要求
① 测试方法必须使用@Test进行修饰
② 测试方法必须使用public void进行修饰，不能带任何的参数
③ 新建一个源代码目录来存放测试代码
④ 测试类的包名应和被测试类保持一致
⑤ 测试单元的每个方法必须可以独立测试，测试方法之间不能有任何的依赖
七、源代码
- 简单工厂模式
package com.shangji.simplefactory;
public interface Person {
public void print();
}
package com.shangji.simplefactory;
import org.junit.Test;
public class Man implements Person{
@Test
public void print() {
System.out.println("男孩");
}
}
package com.shangji.simplefactory;
import org.junit.Test;
public class Robot implements Person{
@Test
public void print() {
System.out.println("机器人");
}
}
package com.shangji.simplefactory;
import org.junit.Test;
public class Woman implements Person{
@Test
public void print() {
System.out.println("女孩");
}
}
package com.shangji.simplefactory;
public class SimpleFactory {
public static Person createPerson(String string){
if("M".equals(string)) {
return new Man();
}else if("W".equals(string)) {
return new Woman();
}else if("R".equals(string)) {
return new Robot();
}
return null;
}
}
package com.shangji.simplefactory;
public class Main {
public static void main(String[] args) {
SimpleFactory.createPerson("R").print();
}
}
- 工厂方法模式
package com.shangji.factorymethod;
public interface Aircondition {
public void print();
}
`package com.shangji.factorymethod;
import org.junit.Test;
public class Midea implements Aircondition{
@Test
public void print() {
System.out.println("美的空调生产中......");
}
}
package com.shangji.factorymethod;
import org.junit.Test;
public class Haier implements Aircondition{
@Test
public void print() {
System.out.println("海尔空调生产中......");
}
}
package com.shangji.factorymethod;
public interface FactoryMethod {
public Aircondition product();
}
package com.shangji.factorymethod;
import org.junit.Test;
public class HaierFactory implements FactoryMethod{
@Test
public Aircondition product() {
return new Haier();
}
}
package com.shangji.factorymethod;
public class MideaFactory implements FactoryMethod{
public Aircondition product() {
return new Midea();
}
}
package com.shangji.factorymethod;
public class Main {
public static void main(String[] args) {
FactoryMethod fm=new MideaFactory();
fm.product().print();
}
}
` - 抽象工厂模式
package com.shangji.abstractfactory;
public interface CPU {
public void print();
}
package com.shangji.abstractfactory;
import org.junit.Test;
public class MacCPU implements CPU{
@Test
public void print() {
System.out.println("Mac的CPU使用中......");
}
}
package com.shangji.abstractfactory;
import org.junit.Test;
public class PcCPU implements CPU{
@Test
public void print() {
System.out.println("Pc的CPU使用中......");
}
}
package com.shangji.abstractfactory;
public interface RAM {
public void print();
}
package com.shangji.abstractfactory;
import org.junit.Test;
public class MacRAM implements RAM{
@Test
public void print() {
System.out.println("Mac的RAM使用中......");
}
}
package com.shangji.abstractfactory;
import org.junit.Test;
public class PcRAM implements RAM{
@Test
public void print() {
System.out.println("Pc的RAM使用中......");
}
}
package com.shangji.abstractfactory;
public interface Efactory {
public RAM concreteRAM();
public CPU concreteCPU();
}
package com.shangji.abstractfactory;
public class MacFactory implements Efactory{
public RAM concreteRAM() {
return new MacRAM();
}
public CPU concreteCPU() {
return new MacCPU();
}
}
package com.shangji.abstractfactory;
public class PcFactory implements Efactory{
public RAM concreteRAM() {
return new PcRAM();
}
public CPU concreteCPU() {
return new PcCPU();
}
}
package com.shangji.abstractfactory;
public class Main {
public static void main(String[] args) {
Efactory ef = new PcFactory();
ef.concreteCPU().print();
ef.concreteRAM().print();
}
}