在面向对象编程的程序设计中,我们最常见的操作就是new对象,但在创建一个新对象的过程中,会有一些问题,比如我们需要注意创建新对象的实现细节,初始化一些必要的参数等。这样会让我们在讲更多的心思放在对象的创建上,而不是程序逻辑的实现上,严重拖延了我们的程序开发效率。工厂模式和抽象工厂模式的出现则完美解决了这个问题,让我们不再关心对象的创建,更多的在重心放在业务的实现上。
特点:
1、程序员直接通过工厂方法创建对象,不再关注创建对象的细节。
2、隐藏对象的实现细节,也有利于程序的安全性。
3、降低程序耦合度。
企业级开发和常见框架中的应用:
Hibernate中的sessionfactory等
工厂模式分类:
简单工厂模式,程序开发中最常用的形式,具体代码如下:
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
|
public class Demo {
/**
* demo这个类就是我们平时的操作类,在这个类中我们不用去关心 创建汽车的实现细节
*/
public static void main(String[] args) {
Car car = CarFactory.createCar( "dz" );
car.run();
Car car2 = CarFactory.createCar( "at" );
car2.run();
}
}
interface Car{
public void run();
}
class Dz implements Car{
public void run() {
System.out.println( "大众汽车在跑" );
}
}
class At implements Car{
public void run() {
System.out.println( "奥拓汽车在跑" );
}
}
class CarFactory{
public static Car createCar(String type){
if ( "dz" .equals(type)){
System.out.println( "创建了一个大众车" );
return new Dz();
}
if ( "at" .equals(type)){
System.out.println( "创建了一个奥拓车" );
return new At();
}
return null ;
}
}
|
工厂方法模式,相比于简单工厂模式,方便扩展,不必去修改以前的代码
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
|
public class Demo {
/**
* demo这个类就是我们平时的操作类,在这个类中我们不用去关心 创建汽车的实现细节
*/
public static void main(String[] args) {
AtFactory atFactory = new AtFactory();
DzFactory dzFactory = new DzFactory();
Car at = atFactory.createCar();
Car dz = dzFactory.createCar();
at.run();
dz.run();
}
}
interface Car {
public void run();
}
class Dz implements Car {
public void run() {
System.out.println( "大众汽车在跑" );
}
}
class At implements Car {
public void run() {
System.out.println( "奥拓汽车在跑" );
}
}
interface CarFactory {
Car createCar();
}
class DzFactory implements CarFactory {
public Car createCar() {
return new Dz();
}
}
class AtFactory implements CarFactory {
public Car createCar() {
return new At();
}
}
|
抽象工厂方法模式:
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
public class Demo {
public static void main(String[] args) {
Car carFactory = new GDCarFactory();
FDZ fdz = carFactory.createFdz();
fdz.zhuansu();
}
}
interface FDZ {
void zhuansu();
}
class GDFDZ implements FDZ {
public void zhuansu() {
System.out.println( "高端发动机转速快" );
}
}
class DDFDZ implements FDZ {
public void zhuansu() {
System.out.println( "低端发动机转速慢" );
}
}
interface ZY {
void shushidu();
}
class GDZY implements ZY {
public void shushidu() {
System.out.println( "高端座椅很舒适" );
}
}
class DDZY implements ZY {
public void shushidu() {
System.out.println( "低端座椅不舒适" );
}
}
interface LT {
void mosundu();
}
class GDLT implements LT {
public void mosundu() {
System.out.println( "高端轮胎不磨损" );
}
}
class DDLT implements LT {
public void mosundu() {
System.out.println( "低端轮胎磨损快" );
}
}
interface Car {
FDZ createFdz();
ZY createZy();
LT createLt();
}
class GDCarFactory implements Car{
@Override
public FDZ createFdz() {
return new GDFDZ();
}
@Override
public ZY createZy() {
return new GDZY();
}
@Override
public LT createLt() {
return new GDLT();
}
}
class DDCarFactory implements Car{
@Override
public FDZ createFdz() {
return new DDFDZ();
}
@Override
public ZY createZy() {
return new DDZY();
}
@Override
public LT createLt() {
return new DDLT();
}
}
|
三种方法的比较:
1、简单工厂模式:简单工厂模式设计简单,代码量少,但是可扩展性却很差,需要扩展时需要修改以前的代码
2、工厂方法模式:扩展性强,但增加了代码复杂度
3、抽象工厂模式:抽象工厂模式和工厂模式是不同,抽象工厂模式是对产品分等级,但工厂模式是对产品分类,举个汽车的例子:工厂模式是生产不同品种的汽车,比如奥迪和大众,而抽象工厂模式则是对同一款汽车进行等级划分,比如同样都是大众汽车,我们分了高端车和低端车。从方法上讲抽象工厂模式更像是工厂模式的细化。一个针对的不不同产品,一个针对的是同一个产品家族。
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。