设计模式是个神奇的东西，用得好的话可以让你的代码结构清晰简洁，用得不好则会让结构更加复杂难懂，包括使用过度。下面我打算分好几部分介绍下自己所理解的设计模式。
最近在看一本关于设计模式的书《深入浅出设计模式》，觉得书中讲的很生动形象。我打算用自己的理解结合书中的例子，给大家简单解释一下，适合和我一样的新手，同时欢迎大神批评指正。首先从策略模式开始。下面大家来看一个例子：
现在有抽象父类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增加骑自行实现。创造出喜欢骑自行车穿裙子的女生，好解决吗？嘿嘿嘿
最后有必要说一下，我文中出现猥琐的语句只是为了提起大家的兴趣，给大家将知识留下深刻的印象，我本人很正直，不信看我眼睛说话。
大家下期见，拜拜！
