设计模式———-工厂(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("Im Audi Car");
11     }
12 }
13
14 public class Benz implements Car {
15     @Override
16     public void carName() {
17         System.out.println("I Benz Car");
18     }
19 }
20
21 public class BMW implements Car {
22     @Override
23     public void carName() {
24         System.out.println("Im 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     }
</code></pre>
<p><strong>此时如果需要增加一个类，那么开发人员又需要new一个对象。</strong></p>
<p>解决方案------简单工厂模式 / 静态工厂模式</p>
<pre><code>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 }
</code></pre>
<h2>2. 工厂方法模式（用来生产同一等级结构中的任意产品（支持增加任意产品） ）</h2>
<pre><code>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 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("Im 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 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

View Code

工厂模式依赖的原则

开闭原则：一个软件的实体应当对扩展开放，对修改关闭

依赖倒转原则：要针对接口编程，不要针对实现编程

迪米特法则：只与直接朋友通信，避免和陌生人通信

Original: https://www.cnblogs.com/qing979/p/13508366.html
Author: 秦鲸卿
Title: 设计模式———-工厂(Factory)模式