喜迎
牛年

Java 工厂设计模式

Posted by 陈陈菌 on 2020-06-13
Estimated Reading Time 4 Minutes
Words 930 In Total
Viewed Times

工厂模式,是一种创建型模式,用于对象的创建。工厂模式又分为 简单/抽象工厂 两种。

其设计模式特点是让类的分工细化,且方便扩展。调用者如果想创建一个对象,只要知道接口和创建类即可了。不过缺点就是会增加类的数量,从而导致系统复杂,增加维护难度。

简单工厂实现:

定义接口:MObject.java

1
2
3
public interface MObject {
void run();
}

定义创建类:CreateObject.java

1
2
3
4
5
6
7
8
9
10
11
12
13
public class CreateObject{
public static MObject create(String tpye){
//一旦值传进来,就根据判断并返回相应的new对象
if(tpye=="人类"){
return new People();
}else if(tpye=="猫"){
return new Cat();
}
else{
return null;
}
}
}

定义猫类:Cat.java,并实现 MObject 接口

1
2
3
4
5
public class Cat implements MObject{
public void run(){
System.out.println("猫在跑");
}
}

定义人类:People.java 与猫类一样,实现 MOject 接口

1
2
3
4
5
public class People implements MObject {
public void run(){
System.out.println("人在跑");
}
}

调用类(调用者):如果想要调用人跑,只需要这样写就可以了。

1
2
3
4
5
6
public class Main{
public static void main(String[] args) {
MObject people = CreateObject.create("人类");
people.run();
}
}

输出结果:人在跑

抽象工厂:

当我们要产生的对象越来越复杂时,简单工厂已经满足不了需求,就需要用到抽象工厂模式。比如以造汽车为例子,由好的轮胎、高级座椅、好的发动机组成奢侈车辆。而低端车则由较差的轮胎、普通的座椅、普通的发动机组成。

Engine.java(引擎接口)

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
public interface Engine {
void run();

void start();
}
/***较好的汽车引擎***/
class LuxuryEngine implements Engine {
@Override
public void run() {
System.out.println("转的快!");
}
@Override
public void start() {
System.out.println("启动快!");
}
}
/***较差的汽车引擎***/
class LowEngine implements Engine {
@Override
public void run() {
System.out.println("转的慢!");
}

@Override
public void start() {
System.out.println("启动慢!");
}
}

Seat.java(座椅接口)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public interface Seat {
void massage();
}
/***高级座椅***/
class LuxurySeat implements Seat {
@Override
public void massage() {
System.out.println("可以自动按摩");
}
}
/***普通座椅***/
class LowSeat implements Seat {
@Override
public void massage() {
System.out.println("不能按摩");
}
}

Tyre.java(轮胎接口)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public interface Tyre {
void revolve();
}
/***较差的轮胎***/
class LuxurTyre implements Tyre {
@Override
public void revolve() {
System.out.println("不易磨损");
}
}
/***较好的轮胎***/
class LowTyre implements Tyre {
@Override
public void revolve() {
System.out.println("易磨损");
}
}

CarFactory.java(工厂接口)

1
2
3
4
5
6
7
8
public interface CarFactory {
/***创造引擎***/
Engine createEngine();
/***创造座椅***/
Seat createSeat();
/***创造轮胎***/
Tyre createTyre();
}

LowCarFactory.java(低端汽车工厂)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class LowCarFactory implements CarFactory {
@Override
public Engine createEngine() {
//创造低端汽车引擎
return new LowEngine();
}
@Override
public Seat createSeat() {
//创造低端座椅
return new LowSeat();
}
@Override
public Tyre createTyre() {
//创造低端轮胎
return new LowTyre();
}
}

LuxuryCarFactory.java(高端汽车工厂)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
//创造高端汽车引擎
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
//创造高端座椅
return new LuxurySeat();
}
@Override
public Tyre createTyre() {
//创造高端轮胎
return new LuxurTyre();
}
}

Main.java(调用者)

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
public class Main {
public static void lowCar(){
//低端汽车工厂的对象
CarFactory factory = new LowCarFactory();

//低端汽车的引擎
Engine e = factory.createEngine();
//转的慢
e.run();
//启动慢
e.start();

//低端汽车的座椅
Seat s = factory.createSeat();
//不能按摩
s.massage();

//低端汽车的轮胎
Tyre t = factory.createTyre();
//易磨损
t.revolve();
}
public static void LuxurCar(){
//高端汽车工厂的对象
CarFactory factory = new LuxurCarFactory();
//高端汽车的引擎
Engine e = factory.createEngine();
//转的快
e.run();
//启动快
e.start();

//高端汽车的座椅
Seat s = factory.createSeat();
//能自动按摩
s.massage();

//高端汽车的轮胎
Tyre t = factory.createTyre();
//不易磨损
t.revolve();
}
public static void main(String[] args) {
lowCar();
LuxurCar();
}
}