设计实现一个鸭子模拟器,要让鸭子实现不同的飞行动作和不同的鸭叫声或者不同的颜色,我们该怎么做呢?
1、如果用继承来实现,那么我们的代码将会变得非常的复杂,而且代码的后期维护将会变得很困难(我想再加个新的特征怎么办?又要把所有的对象都实现一遍?)
2、如果用接口来实现,因为接口无法实现方法,我们必须在所有的子类中一个一个的实现他们,这将导致代码大量的重复,这简直不能忍。
设计原则1:封装变化
把应用中的可能需要变化的地方单独拿出来,与那些不会变化的代码独立开来。
把需要变化的代码封装起来,这样就可以轻易改变他们,而不会影响其他不会变化的代码。
这样的代码的耦合性就大大的降低了,这也是面向对象设计的核心之一。
设计原则2:面向接口编程,而不是面向实现编程
我们这里可以把鸭子的飞行动作、叫声和颜色分为三组类(注意是组,不是个)
每一组类都写一个接口,其中有一个对应的方法,然后这组类中的所有类都实现这个接口。类似下面这样:
接口 FlyBehavior :
public interface FlyBehavior {
public void fly();
}
实现FlyBehavior 的类:
①实现了所有有翅膀的鸭子的飞行动作
public class FlyWithWings implements FlyBehavior{
@Override
public void fly(){
System.out.println("I'm flying");
}
}
②实现了所有不会飞的鸭子的动作
public class FlyNoWay implements FlyBehavior{
public void fly(){
System.out.println("I can't fly");
}
}
接口QuackBehavior:
public interface QuackBehavior {
public void quack();
}
实现QuackBehavior的类
①真的呱呱叫
public class Quack implements QuackBehavior{
public void quack(){
System.out.println("I'm quack");
}
}
②名为呱呱叫,其实什么也不做
public class MuteQuack implements QuackBehavior{
public void quack(){
System.out.println("<< Silence >>");
}
}
③名为呱呱叫,其实是吱吱叫
public class Squeak implements QuackBehavior{
public void quack(){
System.out.println("Squeak");
}
}
通过以上代码可以发现,实现接口的类中实现的方法都是一个具体的方法,比如鸭子的飞行动作就分别通过两个类来实现的,这样就可以动态的改变鸭子的行为了,而不会影响到其他的代码。
设计原则3:多用组合,少用继承
现在通过组合的方式来整合鸭子的行为
先写一个Duck类,也就是鸭子的父类。
public class Duck {
//实例变量,鸭子通过调用他们的实现类来控制鸭子的行为
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public Duck(){
}
public void swim(){
System.out.println("All ducks can swim");
}
/**
* 通过引用对象调用鸭子飞行动作的方法
*/
public void performFly(){
flyBehavior.fly();
}
/**
* 通过引用对象调用鸭子叫的方法
*/
public void performQuack(){
quackBehavior.quack();
}
}
再来实现一个具体的鸭子,也就是Duck的子类
public class MallarDuck extends Duck{
public MallarDuck(){
/**
* 给父类中已经定义的对象赋一个实例
* 选择一个需要实现的行为对应的实现类
*/
flyBehavior = new FlyWithWings();
quackBehavior = new Quack();
}
}
最后加一个主类来测试我们写的代码:
public class MainTest {
public static void main(String[] args){
Duck mallarDuck = new MallarDuck();
mallarDuck.performFly();
mallarDuck.performQuack();
}
}
测试结果:
这里我们已经低耦合地实现了一个会飞会叫的鸭子。但是我们能不能动态的改变鸭子的行为呢?比如我想让不会叫的鸭子变得会叫。
答案是可以的。我们在Duck类中再增加两个方法来动态改变鸭子控制行为的接口对象。
public void setFly(FlyBehavior fb){
this.flyBehavior = fb;
}
public void setQuack(QuackBehavior qb){
this.quackBehavior = qb;
}
改变一下具体的鸭子类:
public class MallarDuck extends Duck{
public MallarDuck(){
/**
* 给父类中已经定义的对象赋一个实例
* 选择一个需要实现的行为对应的实现类
*/
flyBehavior = new FlyWithWings();
quackBehavior = new MuteQuack(); //鸭子不会叫
}
}
再来测试一下代码:
public class MainTest {
public static void main(String[] args){
Duck mallarDuck = new MallarDuck();
mallarDuck.performFly();
mallarDuck.performQuack();
//通过动态改变接口对象,来动态改变鸭子的行为
mallarDuck.setQuack(new Quack());
mallarDuck.performQuack();
}
}
测试结果:
看到没,鸭子从不会叫,动态的改变成了一个会叫的鸭子。
这就是设计模式之一的策略模式,可以提供很多种算法给客户使用,而客户不需要关心它的内部实现。
正式定义是:
定义了一个算法族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化独立于使用算法的客户。