策略模式

模拟鸭子应用

使用继承

 

 

public abstract class Duck {
    public void quack(){
        System.out.println("鸭子呱呱叫");
    }
    public void swim(){
        
        System.out.println("鸭子游泳");
    }
    public abstract void display();
}

public class MallardDuck extends Duck {
    @Override
    public void display() {
        System.out.println("绿色鸭子");
    }
}

public class RedheadDuck extends Duck {
    @Override
    public void display() {
        System.out.println("红头鸭子");
    }
}

 

 

 

 

如果此时需要新增飞行方法

 

 

 

 

 

 

如果此时新增一只橡皮鸭 继承DUCK类 拥有DUCK类的方法

 

 

 

public class RubberDuck extends  Duck {
    // 橡皮鸭不能飞
    
    @Override
    public void display() {
        System.out.println("外观是橡皮鸭");
    }

    @Override
    public void fly() {
        // 覆盖什么都不做
    }
}

 

 并非所有的鸭子都会飞 如果在父类中加上新的行为 会使子类某些不适合该行为的子类也具有该行为 

 继承带来的弊端

 1 代码在多个子类中重复

 2 很难知道所有鸭子全部行为

 3 改变会牵一动发全身 造成其它类不想要的改变

 

 使用接口

 

 

 

如果使用接口虽然解决了飞行问题(只有会飞的鸭子实现Flyable接口) 但是又有新的问题出现  

如果我要修改某个行为 必须修改所有实现该接口的类 如果不小心 可能会造成新的错误

有一个设计原则适用于此处：

找出应用中可能需要改变的地方 把它们独立出来 不要把它和那些不需要改变的代码放一起

要针对接口编程 而不是针对实现编程

 

 

public interface FlyBehavior {
    void fly();
}

public interface QuackBehavior {
    void quack();
}

 

public class FlyNoWay implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("鸭子不会飞");
    }
}



public class FlyWithWings implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("鸭子会飞");
    }
}

public class Quack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("鸭子呱呱叫");
    }
    
}

 

 鸭子类

public abstract class Duck {
     FlyBehavior flyBehavior; // flyBehavior接口
     QuackBehavior quackBehavior; // quackBehavior 接口
    public void Quack(){
        quackBehavior.quack();
    }
    public void Fly(){
        flyBehavior.fly();
    }
    // 由子类实现
    public abstract void display();
}

 

子类

public class MallardDuck extends  Duck {
    public MallardDuck(){
        // 多态
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }
    
    public void display(){
        System.out.println("绿鸭");
    }
}

 

测试

 

public class TestDuck {
    public static void main(String[] args) {
        Duck duck = new MallardDuck();
        duck.Quack();
        duck.Fly();
    }
}

 

如果要新增一个橡胶鸭 只需继承DUCK类

public class RubberDuck extends Duck{
    public RubberDuck(){
        flyBehavior = new FlyNoWay(); // new 不会飞的类
        quackBehavior = new Quack();
    }
    @Override
    public void display() {
        System.out.println("黄色橡胶");
    }
}

 

如果我需要添加新的飞行功能 只需重写FlyBehavior 接口

 

public class SuperFly implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("超级飞行鸭");
    }
}

public class SuperDuck extends Duck {
    public SuperDuck(){
        flyBehavior = new SuperFly();
        quackBehavior = new Quack();
    }
    @Override
    public void display() {
        
    }
}

public class TestDuck {
    public static void main(String[] args) {
        Duck duck = new SuperDuck();
        duck.Quack();
        duck.Fly();
    }
}

具体实现

 

 

 

　　多用组合 少用继承

　　优化

　　

public enum  FlyType {
    NOT_FLY(new FlyNoWay()),
    SUPER_FLY(new SuperFly()),
    Fly_No_Way(new FlyNoWay());
    private FlyBehavior flyBehavior;
    FlyType(FlyBehavior flyBehavior){
        this.flyBehavior = flyBehavior;
    }
    public FlyBehavior getFlyBehavior() {
        return flyBehavior;
    }
}

public abstract class Duck {
     FlyBehavior flyBehavior; // flyBehavior接口
     QuackBehavior quackBehavior; // quackBehavior 接口
    public void Quack(){
        quackBehavior.quack();
    }
    public void Fly(FlyType flyType){
       flyType.getFlyBehavior().fly();
    }
    // 由子类实现
    public abstract void display();
}

public class TestDuck {
    public static void main(String[] args) {
      Duck duck = new RubberDuck();
      duck.Fly(FlyType.NOT_FLY);
    }
}