TA的每日心情 | 开心
2021-3-12 23:18 |
|---|
签到天数: 2 天 [LV.1]初来乍到
|
|
倘若,有这么一个需求,对于一个数字,如果是负的,那么需要变成正的相反数,如果是2的倍数,那么就除以2,如果是3的倍数,那么就除以3, 可能以后还有其他的需求,比如是5的倍数,就再除以5,或者是6的倍数,那么就加上6,也就是结果与顺序息息相关,那么应该如何来实现呢?
如果写一个类的方法,按照这个需求来写if语句,可以,但是,如果有两套定制的呢?一套需要其中的几种变化,另外需要另外几种,那么就需要2个方法, 而且其中有很多的重复代码,这样行不通的.
其实设计模式说到底,其根本思想就是找到变化并封装之.这里变化的是处理的方法,那么我们就把它封装起来.实现的类如下:
package
decorater;
public
class
Integor {
private
Integer x;
public
Integer getX() {
return
x;
}
public
void
setX(Integer x) {
this
.x
=
x;
}
Integor(Integer x){
this
.x
=
x;
}
}
由于Integer不能修改传递的值,所以写一个类来封装一个integer
/**
*
*/
package
decorater;
public
abstract
class
Decorater {
private
Decorater next;
public
Decorater setNext(Decorater dcrtr) {
this
.next
=
dcrtr;
return
this
.next;
}
public
void
process(Integor x) {
this
.executeBefore(x);
if
(
this
.next
!=
null
) {
this
.next.process(x);
}
this
.executeAfter(x);
}
protected
abstract
void
executeBefore(Object x);
protected
abstract
void
executeAfter(Object x);
}
每个实现的类只需要来实现executeBefore和executeAfter方法即可.
注意实现的顺序是
decorater1.executeBefore->decorater2.executeBefore->decorater3.executeBefore->decorater3.executeAfter->
decorater2.executeAfter->decorater1.executerAfter
package
decorater;
public
class
PositiveDecorater
extends
Decorater {
@Override
protected
void
executeAfter(Object x) {
System.out.println(
"
PositiveDecorater end!
"
);
}
@Override
protected
void
executeBefore(Object x) {
//
TODO Auto-generated method stub
System.out.println(
"
starting PositiveDecorater!
"
);
Integor in
=
(Integor) x;
if
(in.getX()
<
0
)
in.setX(
-
in.getX());
}
}
package
decorater;
public
class
Devide2Decorater
extends
Decorater {
@Override
protected
void
executeAfter(Object x) {
System.out.println(
"
Devide2Decorater end!
"
);
}
@Override
protected
void
executeBefore(Object x) {
System.out.println(
"
Starting Devide2Decorater!
"
);
Integor in
=
(Integor) x;
if
(in.getX()
%
2
==
0
) {
in.setX(in.getX()
/
2
);
}
}
}
package
decorater;
public
class
Devide3Decorater
extends
Decorater {
@Override
protected
void
executeAfter(Object x) {
System.out.println(
"
Devide3Decorater end!
"
);
}
@Override
protected
void
executeBefore(Object x) {
System.out.println(
"
Starting Devide3Decorater!
"
);
Integor in
=
(Integor) x;
if
(in.getX()
%
3
==
0
) {
in.setX(in.getX()
/
3
);
}
}
}
/**
*
*/
package
decorater;
/**
*
@author
KONGHE
*
*/
public
class
Main {
/**
*
@param
args
*/
public
static
void
main(String[] args) {
Decorater a
=
new
PositiveDecorater();
a.setNext(
new
Devide2Decorater()).setNext(
new
Devide3Decorater());
Integor x
=
new
Integor(
-
18
);
a.process(x);
System.out.println(x.getX());
}
}
输出结果是:
starting PositiveDecorater!
Starting Devide2Decorater!
Starting Devide3Decorater!
Devide3Decorater end!
Devide2Decorater end!
PositiveDecorater end!
3
其实每种设计模式的核心思想都是一致的,但是没有必要照本宣科,只要注意其模式的精髓,就可以了,剩下的就是自己去按照实现来设 计其中的细节了.比如我设计这个模式,就是先写了main函数,把其中的方法写好,然后去按照这个实现来想去如何实现,这样才更符合解 决实际的问题.其实decorater模式有很多种实现方式.比如下面的这种解法,也可:
/**
*
*/
package
decorater;
/**
*
@author
KONGHE
*
*/
public
class
Main1 {
/**
*
@param
args
*/
public
static
void
main(String[] args) {
DecoraterChain a =
new
DecoraterChain();
a.setNext(
new
PositiveDecorater()).setNext(
new
Devide2Decorater()).setNext(
new
Devide3Decorater());
Integor x = new Integor(-32);
a.process(x);
System.out.println(x.getX());
}
}
/**
*
*/
package
decorater;
import
java.util.ArrayList;
import
java.util.List;
/**
*
@author
KONGHE
*
*/
public
class
DecoraterChain {
private
List<Decorater> decorater =
new
ArrayList<Decorater>();
public
DecoraterChain setNext(Decorater decrter) {
decorater.add(decrter);
return
this
;
}
public
void process(Integor x) {
for
(
int
i
=
0
; i
<
this
.decorater.size(); i
++
) {
this
.decorater.get(i).process(x);
}
}
}
总而言之,模式是为了具体的实际情况而服务的,不要为了一定要去用某种设计模式而委屈自己的需求.
在设计的时候多想想,可能某天你再读设计模式的书,你会发现,原来我之前写的代码,包含了这么多的设计模式啊!
源码下载：http://file.javaxxz.com/2014/11/5/000141593.zip |
|
|手机版|Java学习者论坛
( 声明：本站资料整理自互联网，用于Java学习者交流学习使用，对资料版权不负任何法律责任，若有侵权请及时联系客服屏蔽删除 )
发表于 2014-11-5 00:01:41