软件构造系列（七）一种面向可复用和可维护的设计模式

总述

说白了就是合理利用继承，委托，接口以达到最大程度的抽象，这样复用性就会高，然后抽象好改，所以可维护性也会高，多说无益，像往常一样直接举例说明。
现在我们要构造两个人，一个小明，一个小红，每个人有两个操作，吃和睡，小明吃得多，睡得多，小红吃得少，睡得少。那么开始构造，直接上图：

实现

因为接口是蓝图，我们先写吃和睡两个接口：

public interface eat {
 	public void eat();
 }
public interface sleep {
	public void sleep();
}

然后person接口继承吃和睡接口，朴实无华，都交给具体接口来做：

public interface person extends eat,sleep{
}

接着是吃的两个实现类：

//吃得多
public class eatmuch implements eat{
	@Override
 	public void eat() {
  		System.out.println("eatmuch");
 	}
}
//吃得少
public class eatlittle implements eat{
	@Override
 	public void eat() {
  		System.out.println("eatlittle");
 	}
}

睡的两个实现类：

//吃得多
public class sleepmuch implements sleep{
 	@Override
 	public void sleep() {
  		System.out.println("sleepmuch");
 	}
}
//吃得少
public class sleeplittle implements sleep{
 	@Override
 	public void sleep() {
  		System.out.println("sleeplittle");
 	}
}

aperson实现类，注意这里声明吃和睡的接口进行操作，这样就很抽象：

public class aperson implements person{

 	eat eat;//声明eat接口
 	sleep sleep;//声明sleep接口
 	
 	@Override
 	public void eat() {
  		eat.eat();//使用接口的方法来实现，这样后面就可以复用
 	}
 	
 	@Override
 	public void sleep() {
  		sleep.sleep(); 
 	}
}

最后我们写小明和小红的类，这里就很简单了，只用把eat和sleep两个接口具体化：

//小明
public class xiaoming extends aperson{
 	public xiaoming() {//构造时就初始化eat和sleep
  		eat = new eatmuch();//吃得多
  		sleep = new sleepmuch();//睡得多
 	}
}
//小红
public class xiaohong extends aperson{
 	public xiaohong() {
  		eat = new eatlittle();//吃得少
  		sleep = new sleeplittle();//睡得少
 	}
}

构造完毕，让我们来测试一下，完美通过：

person a = new xiaoming();
person b = new xiaohong();
a.eat();//eatmuch
a.sleep();//sleepmuch
b.eat();//eatlittle
b.sleep();//sleeplittle

这个结构还算简单，只有两个纬度，1层调用，我们还可以更多纬度，更多调用，总结一句话，可以交给其他类做的事情，千万不能自己做。

更新

什么，你说我这程序压根没复用性，那我们这里就利用它的可维护性来更新类，让它变得有复用性。
小明觉得自己吃太多了，要减肥，于是他吃得少了。
更新只需改一行代码，把小明的eat接口实例化为eatlittle：

public class xiaoming extends aperson{
  	public xiaoming() {
    		eat = new eatlittle();//更改处
    		sleep = new sleepmuch();
  	}
}

完事了，是不是更新很方便，而且复用了吃得少的代码，这个结构很好用，体现了可复用性和可维护性。