深入浅出设计模式一——Duck设计(策略模式）

 

以下为针对上图所列代码：

package com.lwf.design.learn;

public abstract class Duck {

	Flyable flyable;
	Quackable quackable;
	
	public void swim(){
		System.out.println("duck is swim");
	}
	public abstract void display();
	
	public void setFlayable(Flyable flyable){
		this.flyable = flyable;
	}
	
	public void setQuackable(Quackable quackable){
		this.quackable = quackable;
	}
	
	public void perFormFly(){
		flyable.fly();
	}
	
	public void perFormQuack(){
		quackable.quack();
	}
	
}

 

 

package com.lwf.design.learn;

public class SubDuck extends Duck {

	public SubDuck(){
		flyable = new NomorFly();
		quackable = new GaQuack();
	}
	public void display(){
		System.out.println("subberDuck is display");
	}
	
	
	public static void main(String[] args) {
		SubDuck s = new SubDuck();
		s.display();
		s.swim();
		s.perFormFly();
		s.perFormQuack();
		
		s.setFlayable(new HighFly());
		s.perFormFly();
		
//		Quackable quackable = new GaQuack();
//		s.quackable = quackable;
//		s.perFormQuack();
	}
}

 

 

package com.lwf.design.learn;

public interface Flyable {

	public void fly();
}

 

 

package com.lwf.design.learn;

public interface Quackable {
	public void quack();
}

 

package com.lwf.design.learn;

public class NomorFly implements Flyable {

	public void fly() {
		System.out.println("Normal fly");
	}

}

 

package com.lwf.design.learn;

public class HighFly implements Flyable {

	public void fly() {
		System.out.println("HighFly fly");
	}

}

 

 

package com.lwf.design.learn;

public class GaQuack implements Quackable {

	public void quack() {
		System.out.println("GaQuack");
	}

}

 

 

package com.lwf.design.learn;

public class GuQuack implements Quackable {

	public void quack() {
		System.out.println("GuQuack");
	}

}

 

 

设计原则：

继承会使所有子类都具有所父类一样的特性，如果使用覆盖，那么子类繁多的时候每个类都要使用覆盖。。
接口会使所有子类都实现其方法，如果子类繁多且实现的方法基本一样，那么怎么办？还使用接口吗？如果以后维护，需要更改这一特性，那么所有子类都需要修改，麻烦。
设计原则一：封装变化即找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
实际上就是把会变化的部分取出来并封装起来，以便以后轻易的改动或扩充此部分。
设计原则二：针对接口编程，而不是针对实现编程
具体的在Duck类的设计之中，将Duck与其可能变化的行为分开，即将Fly抽象成接口，并有它自己的实现类。只需在Duck类中增加Fly属性及设置该属性的方法即可。
这样利用了Duck类本身的继承及Fly类的继承特性，实际上这样有了继承的"复用"好处，而没有继承所带来的包袱。

设计原则三：多用组合，少用继承
在Duck类的设计中，类关系存在继承（is-a），组合（has-a）和实现（implements）,使用组合能减少继承带来的包袱，还可以动态的改变行为。对于Duck的飞行行为和叫的行为，我们可以分别看成是算法簇，比如：我们把飞行行为抽象为接口，它可以有多个实现类，这些实现类可以相互替换，从而我们可以动态的改变行为。

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

 

UML图: