以下为针对上图所列代码:
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图: