设计模式----------工厂(Factory)模式
设计模式----------工厂(Factory)模式
作用
实现了创建者和调用者分离。
工厂模式核心/本质：
实例化对象不在使用new，而是用工厂方法代替。
将选择实现类，创建对象统一管理和控制，从而实现调用者和我们实现类解耦
工厂模式详细分类
1.简单工厂模式（用来生产同一等级结构中的任意产品（对于新增的产品，需要覆盖已有的代码））
实现以汽车为例
1 //汽车接口
2 public interface Car {
3 void carName();
4 }
5
6 //三个实现类
7 public class Audi implements Car {
8 @Override
9 public void carName() {
10 System.out.println("I`m Audi Car");
11 }
12 }
13
14 public class Benz implements Car {
15 @Override
16 public void carName() {
17 System.out.println("I`m Benz Car");
18 }
19 }
20
21 public class BMW implements Car {
22 @Override
23 public void carName() {
24 System.out.println("I`m BMW Car");
25 }
26 }
27
28 //测试方法
29 public static void main(String[] args) {
30 Car c1 = new Audi();
31 Car c2 = new Benz();
32 Car c3 = new BMW();
33 c1.carName();
34 c2.carName();
35 c3.carName();
36 }
此时如果需要增加一个类，那么开发人员又需要new一个对象。
解决方案------简单工厂模式 / 静态工厂模式
1 package com.qing.factory;
2
3 public class FactoryMethod {
4 /*
5 解决方案一
6 此时外部调用只需要传一个名字就可new一个该对象。但是此解决方案需改动方法内部代码结构
7 违反了开闭原则
8 */
9 public static Car getCar(String carName){
10 if(carName == "Audi") {
11 return new Audi();
12 } else if(carName == "Benz") {
13 return new Benz();
14 }else if(carName == "BMW") {
15 return new BMW();
16 }else{
17 return null;
18 }
19 }
20 /*
21 解决方案二
直接添加get方法获取对象
22 这种解决方案虽然也违反了开闭原则，但不涉及方法内部代码结构的改动，
23 在小型解决方案推荐使用此方案
24 */
25 public static Car getAudi(){
26 return new Audi();
27 }
28 public static Car getBenz(){
29 return new Benz();
30 }
31 public static Car getBMW(){
32 return new BMW();
33 }
34 public static void main(String[] args) {
35 Car audi = FactoryMethod.getAudi();
36 }
37 }
2. 工厂方法模式（用来生产同一等级结构中的任意产品（支持增加任意产品） ）
1 //车接口
2 public interface Car {
3 void carName();
4 }
5 //车工厂接口
6 public interface CarFactory {
7 Car getCar();
8 }
9 //奥迪车实现类
10 public class Audi implements Car {
11 @Override
12 public void carName() {
13 System.out.println("I`m Audi Car");
14 }
15 }
16 //奥迪车工厂实现类
17 public class AudiFactory implements CarFactory{
18 @Override
19 public Car getCar() {
20 return new Audi();
21 }
22 }
23 //奔驰车实现类
24 public class Benz implements Car {
25 @Override
26 public void carName() {
27 System.out.println("I`m Benz Car");
28 }
29 }
30 //奔驰车工厂实现类
31 public class BenzFactory implements CarFactory {
32 @Override
33 public Car getCar() {
34 return new Benz();
35 }
36 }
37 //宝马车实现类
38 public class BMW implements Car {
39 @Override
40 public void carName() {
41 System.out.println("I`m BMW Car");
42 }
43 }
44 //宝马车工厂实现类
45 public class BMWFactory implements CarFactory {
46 @Override
47 public Car getCar() {
48 return new BMW();
49 }
50 }
51
52 //测试方法
53 public class MyTest {
54 public static void main(String[] args) {
55 Car c1=new AudiFactory().getCar();
56 Car c2=new BenzFactory().getCar();
57 Car c3=new BMWFactory().getCar();
58 c1.carName();
59 c2.carName();
60 c3.carName();
61 }
62 }
工厂方法模式虽然遵守设计原则，但是从结构复杂度、代码复杂度、编程复杂度、管理复杂度来说，简单工厂模式更容易实现。如下图，实现相同的功能，多了几个类
3.抽象工厂模式（围绕一个超级工厂创建其他工厂，又称为其他工厂的工厂）
直接上代码，整理手机、电脑、魅族、小米之间的瓜关系
1 //手机产品接口
2 public interface Phone {
3 void start();
4 void shutdown();
5 }
6 //魅族手机
7 public class MezuPhone implements Phone {
8 @Override
9 public void start() {
10 System.out.println("魅族手机开机");
11 }
12
13 @Override
14 public void shutdown() {
15 System.out.println("魅族手机关机");
16 }
17 }
18 //小米手机
19 public class MiPhone implements Phone {
20 @Override
21 public void start() {
22 System.out.println("小米手机开机");
23 }
24
25 @Override
26 public void shutdown() {
27 System.out.println("小米手机关机");
28 }
29 }
30 //电脑产品接口
31 public interface Computer {
32 void start();
33 void shutdown();
34 }
35 //魅族电脑
36 public class MezuComputer implements Computer{
37 @Override
38 public void start() {
39 System.out.println("魅族电脑开机");
40 }
41
42 @Override
43 public void shutdown() {
44 System.out.println("魅族电脑关机");
45 }
46 }
47 //小米电脑
48 public class MiComputer implements Computer {
49 @Override
50 public void start() {
51 System.out.println("小米电脑开机");
52 }
53
54 @Override
55 public void shutdown() {
56 System.out.println("小米电脑关机");
57 }
58 }
59 //产品工厂
60 public interface ProductFactory {
61 Phone getPhone();
62
63 Computer getComputer();
64 }
65 //魅族工厂
66 public class MezuProduct implements ProductFactory {
67 @Override
68 public Phone getPhone() {
69 return new MezuPhone();
70 }
71
72 @Override
73 public Computer getComputer() {
74 return new MezuComputer();
75 }
76 }
77 //小米工厂
78 public class MiProduct implements ProductFactory {
79 @Override
80 public Phone getPhone() {
81 return new MiPhone();
82 }
83
84 @Override
85 public Computer getComputer() {
86 return new MiComputer();
87 }
88 }
上图可看出产品工厂（ProductFactory）可以创建魅族和小米的产品，就可以分别获取手机和电脑对象了（可以把小米和魅族看作产品族，手机和电脑看作是产品系列）。总之一句话，抽象工厂是工厂的工厂
引用一句维基百科的说明：
工厂模式中的每一个形态都是针对一定问题的解决方案，工厂方法针对的是多个产品系列结构；而抽象工厂模式针对的是多个产品族结构，一个产品族内有多个产品系列。
1 bgftg 2 3 4 ger 5 ge 6 7 gers
工厂模式依赖的原则
开闭原则：一个软件的实体应当对扩展开放，对修改关闭
依赖倒转原则：要针对接口编程，不要针对实现编程
迪米特法则：只与直接朋友通信，避免和陌生人通信
