深造工厂模式

简单工厂模式

介绍

简单工厂模式不属于23种设计模式,属于创建行模式,有称为静态工厂方法模式。该模式是由一个工厂对象决定创建哪一产品的实例,就是说创建对象由工厂去做。

场景

在系统种会遇到各种待办任务,比如请假审批,加薪申请审批等各种待办,但是这些待办在刚开始是不确定的,随心和项目的开展自然就会增加,我们就以此为例。

首先是任务接口

1
2
3
4
5
6
7
8
9
10
11
package factory;

/**
* @Descriptions: 任务接口
* @Author: wsylp
* @Date: created in 下午4:32 19-9-7
*/
public interface Task {

void getUndoneTask();
}

请假任务类

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


/**
* @Descriptions: 请假任务
* @Author: wsylp
* @Date: created in 下午4:32 19-9-7
*/
public class LeaveTask implements Task {

@Override
public void getUndoneTask() {
System.out.println("获取请假待办");

}
}

加薪任务类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package factory;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 下午4:47 19-9-7
*/
public class RiseSalary implements Task{

@Override
public void getUndoneTask() {
System.out.println("获取加薪待办");

}
}

简单工厂类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package factory.simpleFactory;

import factory.Task;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 下午5:19 19-9-7
*/
public class SimpleFactoryTest {

public static void main(String[] args) {
TaskSimpleFactory taskSimpleFactory = new TaskSimpleFactory();

Task task = taskSimpleFactory.getTask("leave");

if (task != null) {
task.getUndoneTask();
}
}
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package factory.simpleFactory;

import factory.Task;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 下午5:19 19-9-7
*/
public class SimpleFactoryTest {

public static void main(String[] args) {
TaskSimpleFactory taskSimpleFactory = new TaskSimpleFactory();

Task task = taskSimpleFactory.getTask("leave");

if (task != null) {
task.getUndoneTask();
}
}
}

总结

1、用简单工厂类的很少,但是相比较那些冗余可以合并,在原先基础上进行频繁的增键新功能来说,简单工厂类要好很多。

2、简单工厂类讲各个职责权利进行区分,更加方便。

3、简单工厂模式讲逻辑全部进行控制在工厂类,违反了开闭原则。

工厂方法模式

介绍

工厂方法模式Factory method,又称为多态性工厂模式。在该模式中工厂不在进行创建对象,而是由客户端去创建,在原有简单工厂方法的基础上满足了开闭原则,达到了可扩展。

定义:工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

场景

在上述内容中,我们如果增加出差报销申请的话,就需要该工厂方法,如果增加的多就会很麻烦,也可能会出现改错的情况。

但是如果使用工厂方法模式就不会,工厂方法是由客户端,也就是调用者这来确定产出什么产品。

增加差旅任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package factory.factoryMethod;

import factory.Task;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 上午9:22 19-9-8
*/
public class TravelTask implements Task {
@Override
public void getUndoneTask() {
System.out.println("出差待办。。。");
}
}

任务工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package factory.factoryMethod;

import factory.LeaveTask;
import factory.Task;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 上午9:10 19-9-8
*/
public class LeaveTaskFactory implements TaskFactory {
@Override
public Task getTask() {
return new LeaveTask();
}
}

请假工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package factory.factoryMethod;

import factory.LeaveTask;
import factory.Task;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 上午9:10 19-9-8
*/
public class LeaveTaskFactory implements TaskFactory {
@Override
public Task getTask() {
return new LeaveTask();
}
}

加薪工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package factory.factoryMethod;

import factory.RiseSalary;
import factory.Task;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 上午9:19 19-9-8
*/
public class RiseTaskFactory implements TaskFactory {
@Override
public Task getTask() {
return new RiseSalary();
}
}

出差工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package factory.factoryMethod;

import factory.Task;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 上午9:22 19-9-8
*/
public class TravelTaskFactory implements TaskFactory {
@Override
public Task getTask() {
return new TravelTask();
}
}

测试类

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
package factory.factoryMethod;

import factory.Task;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 上午9:21 19-9-8
*/
public class FactoryMethodTest {

public static void main(String[] args) {
LeaveTaskFactory factory = new LeaveTaskFactory();
Task task = factory.getTask();
task.getUndoneTask();


TravelTaskFactory travelTaskFactory = new TravelTaskFactory();
Task travelTask = travelTaskFactory.getTask();

travelTask.getUndoneTask();


}

}

总结

1、实现了开-闭原则,将实现与使用分离开来。

2、每增减一个产品需要增加一个子工厂,增加开发量。

抽象工厂模式

介绍

抽象工厂模式(Abstract Factory),提供了一个创建一系列相关或相互同意以来的接口,而无需指定他们具体的类。

场景

在上述情景中我们增加申请类,但是我们如何实现呢?难道在在写一个任务工厂?非也,我们仅仅需要在原先的基础上进行改造为抽象工厂模式。

工厂方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package factory.factoryMethod;

import factory.Apply;
import factory.Task;

/**
* @Descriptions: 任务工厂方法
* @Author: wsylp
* @Date: created in 上午9:07 19-9-8
*/
public interface TaskFactory {

Task getTask();

Apply addApply();
}

apply类

1
2
3
4
5
6
7
8
9
10
package factory;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 下午4:22 19-9-8
*/
public interface Apply {
void addAapply();
}

leaveApply

1
2
3
4
5
6
7
8
9
10
11
/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 下午4:23 19-9-8
*/
public class LeaveApply implements Apply {
@Override
public void addAapply() {
System.out.println("请假申请。。。。");
}
}

总结

1、简单的说抽象工厂模式是对一系列产品进行使用。

本文标题:深造工厂模式

文章作者:wsylp

发布时间:2019年09月09日 - 21:09

最后更新:2019年09月09日 - 21:09

原始链接:http://wsylp.top/2019/09/09/深造工厂模式/

许可协议: 本文为 wsylp 版权所有 转载请保留原文链接及作者。

-------------本文结束感谢阅读-------------