【java学习—九】工厂方法FactoryMethod（6）

---

1. 概念

    FactoryMethod 模式是设计模式中应用最为广泛的模式，在面向对象的编程中，对象的创建工作非常简单，对象的创建时机却很重要。 FactoryMethod 解决的就是这个问题，它通过面向对象的手法，将所要创建的具体对象的创建工作延迟到了子类，从而提供了一种扩展的策略，较好的解决了这种紧耦合的关系。

听不懂是吧？下面直接举例说明：

2. 实际的应用

注：图中原作者出现笔误，BMW错拼成了BWM
上图中①是BMW的产品接口，②是产品工厂的接口。

代码实现：
（1）开发人员A的工作
接口BMW.java：

package day09;
/**
 * 宝马车的产品接口
 * @author 14532
 *
 */
public interface BMW {
	//产品的信息介绍
	//车的发动方式
	void showInfo();
}


/**
 * 构建具体的车的类
 * @author 14532
 *
 */
class BMW3 implements BMW{
	@Override
	public void showInfo() {
		System.out.println("这个是宝马3系车");
	}
}

class BMW5 implements BMW{
	@Override
	public void showInfo() {
		System.out.println("这个是宝马5系车");	
	}
}

class BMW7 implements BMW{
	@Override
	public void showInfo() {
		System.out.println("这个是宝马7系车");		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

接口BMWFactory.java：

package day09;
/**
 * 汽车生产工厂接口
 * @author 14532
 *
 */
public interface BMWFactory {
	BMW productBMW();
}

/**
 * 实现具体的车型的生产工厂
 * @author 14532
 *
 */
class BMW3Factory implements BMWFactory{

	@Override
	public BMW productBMW() {
		System.out.println("生产宝马3系车");
		return new BMW3();
	}
}


class BMW5Factory implements BMWFactory{

	@Override
	public BMW productBMW() {
		System.out.println("生产宝马5系车");
		return new BMW5();
	}
}


class BMW7Factory implements BMWFactory{

	@Override
	public BMW productBMW() {
		System.out.println("生产宝马7系车");
		return new BMW7();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

（2）开发人员B的工作：
Test.java：

package day09;

public class Test2 {
	public static void main(String[] args) {
		//这是开发人员B的工作
		BMW b3 = new BMW3Factory().productBMW();
		b3.showInfo();
		
		BMW b5 = new BMW5Factory().productBMW();
		b5.showInfo();
		
		BMW b7 = new BMW7Factory().productBMW();
		b7.showInfo();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行结果：

如果现在需要对宝马3系的车进行改造，改成宝马3i，该如何实现：
BMW.java中class BMW3 implements BMW{改成class BMW3i implements BMW{
BMWFactory.java中return new BMW3();改成return new BMW3i();
为了区别改造的，在类BMW3Factory中添加一段输出System.out.println("改造3系车，定名为BMW3i型号");
更改后的代码：

（1）开发人员A的工作产生了变化：
接口BMW.java：

package day09;
/**
 * 宝马车的产品接口
 * @author 14532
 *
 */
public interface BMW {
	//产品的信息介绍
	//车的发动方式
	void showInfo();
}


/**
 * 构建具体的车的类
 * @author 14532
 *
 */
class BMW3i implements BMW{//更改为BMW3i
	@Override
	public void showInfo() {
		System.out.println("这个是宝马3系车");
		
	}
}

class BMW5 implements BMW{
	@Override
	public void showInfo() {
		System.out.println("这个是宝马5系车");
		
	}
}

class BMW7 implements BMW{
	@Override
	public void showInfo() {
		System.out.println("这个是宝马7系车");
		
	}
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

接口BMWFactory.java：

package day09;
/**
 * 汽车生产工厂接口
 * @author 14532
 *
 */
public interface BMWFactory {
	BMW productBMW();
}

/**
 * 实现具体的车型的生产工厂
 * @author 14532
 *
 */
class BMW3Factory implements BMWFactory{//在BMW3Factory中改造BMW3为BMW3i

	@Override
	public BMW productBMW() {
		System.out.println("生产宝马3系车");
		System.out.println("改造3系车，定名为BMW3i型号");
		return new BMW3i();//返回BMW3i
	}
	
}


class BMW5Factory implements BMWFactory{

	@Override
	public BMW productBMW() {
		System.out.println("生产宝马5系车");
		return new BMW5();
	}
	
}


class BMW7Factory implements BMWFactory{

	@Override
	public BMW productBMW() {
		System.out.println("生产宝马7系车");
		return new BMW7();
	}
	
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

（2）开发人员B的工作没有变化：
Test.java：

package day09;

public class Test2 {
	public static void main(String[] args) {
		//这是开发人员B的工作
		BMW b3 = new BMW3Factory().productBMW();
		b3.showInfo();
		
		BMW b5 = new BMW5Factory().productBMW();
		b5.showInfo();
		
		BMW b7 = new BMW7Factory().productBMW();
		b7.showInfo();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出结果：

通过工厂把new对象给隔离，通过产品的接口可以接收不同实际产品的实现类。实现的类名的改变不影响其他合作开发人员的编程。