java 常用设计模式（1）

　　第三种方法：用接口改进.

　　我们把容易引起变化的部分提取出来并封装之，来应付以后的变法。虽然代码量加大了，但可用性提高了，耦合度也降低了。

　　我们把Duck中的fly方法和quack提取出来。

public interface Flyable{
public void fly();
}
public interface Quackable{
public void quack();
}
后Duck的设计成为：
public class Duck{
public void swim(){   //游泳
System.out.println(" 游泳");
}
public  abstract void display(); /*因为外观不一样，让子类自 己去决定了。*/
}
而MallardDuck，RedheadDuck，DisabledDuck 可以写成为：
//野鸭
public class MallardDuck extends Duck  implements Flyable，Quackable{
public void display(){
System.out.println("野鸭的颜色...");
}
public void fly(){
//实现该方法
}
public void quack(){
//实现该方法
}
}
//红头鸭
public class RedheadDuck extends Duck implements Flyable，Quackable{
public void display(){
System.out.println("红头鸭的颜色...");
}
public void fly(){
//实现该方法
}
public void quack(){
//实现该方法
}
}
//残废鸭 只实现Quackable（能叫不能飞）
public class DisabledDuck extends Duck implements Quackable{
public void display(){
System.out.println("残废鸭的颜色...");
}
public void quack(){
//实现该方法
}
}

　　>>>>>>点评:

　　好处:

　　这样已设计，我们的程序降低了它们之间的耦合。

　　不足:

　　Flyable和 Quackable接口一开始似乎还挺不错的，解决了问题（只有会飞到鸭子才实现 Flyable），但是Java接口不具有实现代码，所以实现接口无法达到代码的复用。

　　第四种方法：对上面各方式的总结:

　　继承的好处:让共同部分，可以复用.避免重复编程.

　　继承的不好:耦合性高.一旦超类添加一个新方法，子类都继承，拥有此方法，

　　若子类相当部分不实现此方法，则要进行大批量修改.

　　继承时，子类不可继承其它类了.

　　接口的好处:解决了继承耦合性高的问题.

　　且可让实现类，继承或实现其它类或接口.

　　接口的不好:不能真正实现代码的复用.可用以下的策略模式来解决.

　　------------------------- strategy(策略模式) -------------------------

　　我们有一个设计原则：

　　找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；

　　找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 -->important.

　　现在，为了要分开“变化和不变化的部分”，我们准备建立两组类（完全远离Duck类），一个是"fly"相关的，另一个

　　是“quack”相关的，每一组类将实现各自的动作。比方说，我们可能有一个类实现“呱呱叫”，另一个类实现“吱吱

　　叫”，还有一个类实现“安静”。

　　首先写两个接口。FlyBehavior(飞行行为)和QuackBehavior（叫的行为）.

public interface FlyBehavior{
public void fly();
}
public interface QuackBehavior{
public void quack();
}
我们在定义一些针对FlyBehavior的具体实现。
public class FlyWithWings implements FlyBehavior{
public void  fly(){
//实现了所有有翅膀的鸭子飞行行为。
}
}
public class FlyNoWay implements FlyBehavior{
public void  fly(){
//什么都不做，不会飞
}
}
针对QuackBehavior的几种具体实现。
public class Quack implements QuackBehavior{
public void quack(){
//实现呱呱叫的鸭子
}
}
public class Squeak implements QuackBehavior{
public void quack(){
//实现吱吱叫的鸭子
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
//什么都不做，不会叫
}
}

　　点评一:

　　这样的设计，可以让飞行和呱呱叫的动作被其他的对象复用，因为这些行为已经与鸭子类无关了。而我们增加一些新的行为，不会影响到既有的行为类，也不会影响“使用”到飞行行为的鸭子类。

　　后我们看看Duck 如何设计。

public class Duck{        --------->在抽象类中，声明各接口，定义各接口对应的方法.
FlyBehavior flyBehavior;//接口
QuackBehavior quackBehavior;//接口
public Duck(){}
public abstract void display();
public void swim(){
//实现游泳的行为
}
public void performFly(){
flyBehavior.fly();  -->由于是接口，会根据继承类实现的方式，而调用相应的方法.
}
public void performQuack(){
quackBehavior.quack();();
}
}

　　看看MallardDuck如何实现。

　　----->通过构造方法，生成'飞'，'叫'具体实现类的实例，从而指定'飞'，'叫'的具体属性

public class MallardDuck extends Duck{
public MallardDuck {
flyBehavior = new FlyWithWings ();
quackBehavior = new Quack();
//因为MallardDuck 继承了Duck，所有具有flyBehavior 与quackBehavior 实例变量}
public void display(){
//实现
}
}

　　这样满足了即可以飞，又可以叫，同时展现自己的颜色了。

　　这样的设计我们可以看到是把flyBehavior ，quackBehavior 的实例化写在子类了。我们还可以动态的来决定。

　　我们只需在Duck中加上两个方法。