设计模式是个神奇的东西,用得好的话可以让你的代码结构清晰简洁,用得不好则会让结构更加复杂难懂,包括使用过度。下面我打算分好几部分介绍下自己所理解的设计模式。

最近在看一本关于设计模式的书《深入浅出设计模式》,觉得书中讲的很生动形象。我打算用自己的理解结合书中的例子,给大家简单解释一下,适合和我一样的新手,同时欢迎大神批评指正。首先从策略模式开始。下面大家来看一个例子:

现在有抽象父类People,里面有eat()和sleep()等共有的方法以及抽象方法show()。下面有三个子类man,woman以及child,在子类中我们实现对应的show()方法。似乎并没有什么问题,大家都很好。具体代码如下:

 People

public abstract class People {

public void eat(){

System.out.println(“all people eat”);

}

public void sleep(){

System.out.println(“all people sleep”);

}

public abstract void show();

}

 Man

public class Man extends People{

@Override

public void show() {

System.out.println(“I have short hair”);

}

}

 Woman

public class Woman extends People {

@Override

public void show() {

System.out.println(“I have long hair”);

}

}

Child

public class Child extends People {

@Override

public void show() {

System.out.println(“I have less hair”);

}

}

分析以上代码,我们将公有部分(eat和sleep)在抽象类People实现,show在具体子类中实现。(不要说我吃米饭,婴儿吃奶嘴,eat应该不同的,大家安静安静别吵,现在不是纠结这个的时候)只能说我这个例子举的不太恰当,因为实际需求中总有一部分是固定不变的,我们这一步的任务就是将固定不变的抽取出来父类中实现而已。

这个地方有个很重要的思想,就是面对一个系统或者说一个模块,我们将固定不变的部分与经常变化的部分区分开来,分别对待,小心产品经理。

假设我现在需求要变,要所有的人都有move()方法。你会怎么做?你肯定会说我们都是面向对象编程,很简单啊,直接在People中增加move()方法并实现,这种上课时老师一直讲的东西,继承。

可是你想过没有,这样做会不会有什么问题?


child婴儿是不会移动的(不要纠结说婴儿会爬之类的,我眼睛会干)。这时候你会发现如果我们在父类中实现,那么将影响整个子类,这对于子类较多的类来说,是灾难性的。你肯定就会说,我们在People中设计一个抽象方法move(),然后在子类中实现不可以吗?

当然可以,代码如下:

 People

public abstract class People {

public void eat(){

System.out.println(“all people eat”);

}

public void sleep(){

System.out.println(“all people sleep”);

}

public abstract void show();

public abstract void move();

}

Man

public class Man extends People{

@Override

public void show() {

System.out.println(“I have short hair”);

}

@Override

public void move() {

System.out.println(“on foot”);

}

}

Woman

public class Woman extends People {

@Override

public void show() {

System.out.println(“I have long hair”);

}

@Override

public void move() {

System.out.println(“on foot”);

}

}

Child

public class Child extends People {

@Override

public void show() {

System.out.println(“I have less hair”);

}

@Override

public void move() {

}

}

好了,实现完成。在child类中,move()中我们什么也不做。现在需求来了,我们有一类人懒人。虽然是个大老爷们,但是我不想动,我被床封印了。你会怎么做?重新创建一个LazyMan类继承People,然后实现move(),在move中什么也不做?

你会说怎么不可以???

child和LazyMan中代码代码重复,做到代码重用了吗?什么,实现为空也叫代码重复?

住口。在Man和Woman中move不是已经代码重复了吗?还敢嘴硬。少年还有什么可说的??

你会说,看来不行啊,我们必须求助于其他办法了。对的,我们试试其他办法。

能不能用接口?然后创建多个接口的子类分别实现?

具体实现如下:

 IMoveBehavior

public interface IMoveBehavior {

public void move();

}

 MoveWithFoot

public class MoveWithFoot implements IMoveBehavior {

@Override

public void move() {

System.out.println(“on foot”);

}

}

MoveNothing

public class MoveNothing implements IMoveBehavior{

@Override

public void move() {

System.out.println(“move? no”);

}

}

 来看看我们的People

public abstract class People {

IMoveBehavior moveBehavior;

public void eat(){

System.out.println(“all people eat”);

}

public void sleep(){

System.out.println(“all people sleep”);

}

public abstract void show();

public void moveBehave(){

moveBehavior.move();

}

}

我们在创建IMoveBehavior对象的时候需要知道IMoveBehavior具体指向的是什么,所以我们在People子类的构造函数中来指定。代码如下:

Man

public class Man extends People implements IMoveBehavior{

public Man(IMoveBehavior moveBehavior){

this.moveBehavior = moveBehavior;

}

@Override

public void show() {

System.out.println(“I have short hair”);

}

@Override

public void move() {

System.out.println(“on foot”);

}

}

Woman和Child类似,不贴了。我们写个测试类StrategyTest,看我们的代码复用是否成功?

StrategyTest

public class StrategyTest {

public static void main(String[] args) {

Man niceMan = new Man(new MoveNothing());

niceMan.moveBehave();

}

}

运行结果如下:

如果是勤劳的人,那就 Man niceMan = new Man(new MoveWithFoot());

问题解决,那还有没有什么不妥的地方呢?

我们moveBehavior是在创建的时候进行绑定的,如果我想动态地更改moveBehavior呢?是不是就傻眼了?

于是我们有个接下来的方法:

People

public abstract class People {

IMoveBehavior moveBehavior;

public void setMoveBehavior(IMoveBehavior moveBehavior){

this.moveBehavior = moveBehavior;

}

public void eat(){

System.out.println(“all people eat”);

}

public void sleep(){

System.out.println(“all people sleep”);

}

public abstract void show();

public void moveBehave(){

moveBehavior.move();

}

}

其他类不变。我们将moveBehavior的设置方法暴露出去,可以进行动态设定。来验证一下:

public class StrategyTest {

public static void main(String[] args) {

Man niceMan = new Man();

//给我走

niceMan.setMoveBehavior(new MoveWithFoot());

niceMan.moveBehave();

//不许动

niceMan.setMoveBehavior(new MoveNothing());

niceMan.moveBehave();

}

}

验证结果如下:

几经波折,终于搞好了。这就是策略模式,下面我们来看下较为正式的定义(严肃点,不许笑)。

策略模式:

定义了算法族,分别封装起来,让它们之间可以互相替换, 此模式让算法的变化独立于使用算法的客户。

最后说一个重要的点:我们之前那种做法都是通过继承,面向实现做的,虽然可以得到要求,但是代码复用性不高,如果子类多,那将是灾难。我们要面向接口编程。

原则:少用继承,多用组合。

拓展:

1.假设需求又变了,需要给所有人加上wear(穿衣的方法),但是每种人的穿衣风格不同。男的穿西装,女的穿裙子,小孩穿肚兜,甚至超人内裤外穿。好解决吗?

2.需求又变了,要求move增加骑自行实现。创造出喜欢骑自行车穿裙子的女生,好解决吗?嘿嘿嘿

最后有必要说一下,我文中出现猥琐的语句只是为了提起大家的兴趣,给大家将知识留下深刻的印象,我本人很正直,不信看我眼睛说话。

大家下期见,拜拜!

文章来源于互联网:策略模式(新手推荐)

发表评论