设计模式之过程型

设计模式之过程型

1.适配器模式(Adapter)
适配器模式将某个类的接口转换成客户端期望的另一个接口表示,主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式

1
2
3
4
5
public class Source {
public void method1() {
System.out.println("this is original method!");
}
}

1
2
3
4
public interface Targetable {
public void method1() ;
public void method2() ;
}
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
A.类的适配器模式
public class Target1 extends Source implements Targetable{
public void method2() {
System.out.println("this is target method!");
}
}
B.对象的适配器模式
public class Target2 implements Targetable{
private Source source;
public Target2(Source source){
this.source = source;
}
public void method1() {
source.method1();
}
public void method2() {
System.out.println("this is target method!");
}
}
C.接口的适配器模式
public abstrqact class ATarget implements Targetable{
public void method1(){}
public void method2(){}
}
public class Target3 extends ATarget{
public void method1(){
System.out.println("this is method 1!");
}
}
public class Target4 extends ATarget{
public void method2(){
System.out.println("this is method 2!");
}
}

适配器模式总结

  • 类的适配器模式:将一个类转换成满足另一个新接口的类,创建一个新类,继承原有的类,实现新的接口即可。
  • 对象的适配器模式:将一个对象转换成满足另一个新接口的对象,创建一个Target类,持有原类的一个实例,在Target类的方法中,调用实例的方法就行。
  • 接口的适配器模式:不希望实现一个接口中所有的方法,可以创建一个抽象类,实现所有方法,我们写别的类的时候,继承抽象类。

2.装饰模式(Decorator)
给一个对象增加一些新的功能

1
2
3
public interface Sourceable{
public void method();
}

1
2
3
4
5
public class Source implements Sourceable{
public void method() {
System.out.println("this is original method!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class ExSource implements Sourceable{
private Sourceable s;
public ExSource(Sourceable s){
this.s = s;
}
public void method() {
System.out.println("before expand");
···
s.method();
···
System.out.println("end expand");
}
}
1
2
3
4
5
public static void main(String[] args){
Sourceable s = new Source();
ExSource e = new ExSource(s);
s.method();
}

3.代理模式(Proxy)
代理模式就是多一个代理类出来,替原对象进行一些操作

1
2
3
public interface Sourceable{
public void method();
}

1
2
3
4
5
public class Source implements Sourceable{
public void method() {
System.out.println("this is original method!");
}
}
1
2
3
4
5
6
7
8
9
10
11
public class Proxy implements Sourceable{
private Source s;
public Proxy (){
s = new Source();
}
public void method() {
System.out.println("before proxy");
s.method();
System.out.println("end proxy");
}
}
1
2
3
4
public static void main(String[] args){
Sourceable s = new Proxy();
s.method();
}

代理模式与装饰模式的区别

  • 代理模式中类的关系不需要客户端去配置,在开始就决定了代理者与被代理者,客户(main函数中)只需要使用代理类就ok了。但是装饰者模式中,类之间的关系需要客户指定,扩展哪个类需要客户指定。

4.外观模式(Facade)
外观模式是为了解决类与类之间的依赖关系

1
2
3
4
5
6
7
8
9
10
public class Computer{
private Cpu cpu;
private Memory memory;
private Fan fan;
public void start(){
cpu.start();
memory.start();
fan.start();
}
}

只需要在Computer类中调用start()方法,cpu、memory、fan依次启动,而不用在cpu.start()方法的最后一行加上memoty.start(),降低耦合性

5.桥接模式(Bridge)
将抽象与实现解耦,使得二者可以独立变化
创建Computer抽象类及DELL、HP

1
2
3
4
5
6
7
public abstract class Computer{
public CPUMode cpu;
public Computer(CPUMode cpu){
this.cpu=cpu;
}
public abstract void produceComputer();
}

1
2
3
4
5
6
7
8
9
public class DELL extends Computer{
public DELL(CPUMode cpu){
super(cpu);
}
public void produceComputer(){
System.out.println("This is DELL,"+“CPU:”+cpu.produceCPUMode());
}
}
1
2
3
4
5
6
7
8
9
public class HP extends Computer{
public HP(CPUMode cpu){
super(cpu);
}
public void produceComputer(){
System.out.println("This is DELL,"+“CPU:”+cpu.produceCPUMode());
}
}

创建CPUMode及Intel、AMD

1
2
3
public abstract class CPUMode{
public abstract String produceCPUMode();
}

1
2
3
4
5
public class Intel extends CPUMode{
public String produceCPUMode(){
return "Intel Core I7";
}
}
1
2
3
4
5
public class AMD extends CPUMode{
public String produceCPUMode(){
return "AMD A10";
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args){
Intel i = new Intel();
AMD a = new AMD();
//DELL I7系列
DELL d1 = new DELL(i);
//DELL A10系列
DELL d2 = new DELL(i);
//HP I7系列
HP h1 = new HP(i);
//DELL A10系列
HP h2 = new DELL(i);
}

若此时Loongson芯片非常流行

1
2
3
4
5
public class Loongson extends CPUMode{
public String produceCPUMode(){
return "Loongson 3A";
}
}
1
2
3
4
5
main(){
Loongson l = new Loongson();
DELL d3 = new DELL(l);
HP h3 = new HP(l);
}

Computer对应为抽象部分,CPUMode对应实现部分,桥接模式将这两个部分分开,可以分别扩展,降低耦合。

6.组合模式(Composite)
将多个对象组合在一起进行操作,常用于表示树形结构中

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 TreeNode {
private String name;
private TreeNode parent;
private Vector<TreeNode> children = new Vector<TreeNode>();
public TreeNode(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public TreeNode getParent() {
return parent;
}
public void setParent(TreeNode parent) {
this.parent = parent;
}
//添加孩子节点
public void add(TreeNode node){
children.add(node);
}
//删除孩子节点
public void remove(TreeNode node){
children.remove(node);
}
//取得孩子节点
public Enumeration<TreeNode> getChildren(){
return children.elements();
}
}

7.享元模式(Flyweight)
实现对象的共享,可以减少内存的开销,通常与工厂模式一起使用(String为享元模式,多个不同名字符串对象,值相同则只在堆中创建一个)

1
2
3
4
5
6
7
8
9
10
11
12
public class GetTicketSofware{
//抢票软件会多次执行此函数,会创建很多Ticket对象,占用内存
public Ticket getTicket(String from,String to){
boolean getable;
long price;
...
...
...
return new Ticket(from,to,price,getable);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class GetTicketSofware{
//利用Map存储Ticket对象,实现复用
private Map<String,Ticket> ticketsMap = new HashMap<String,Ticket>();
public Ticket getTicket(String from,String to){
String key = from+to;
if(ticketsMap.containsKey(key)){
boolean getable;
...
...
...
ticketsMap.get(key).setGetable(getable);
return ticketsMap.get(key);
}lese{
boolean getable;
...
...
Ticket ticket = new Ticket(from,to,price,getable)
ticketsMap.put(key,ticket);
return ticket;
}
}
}