HeadFirst 设计模式 第一章

核心思想

• 以变和不变为原则实行设计
• 不变用纵向继承
• 多变用接口面向基类横向多态
• 当变和不变需要结合，用委托对象组合模式

代码

public interface Animal {
    public void makeSound();
}

public interface FlyBehavior {
    public void fly();
}

/*
interface 是面向超类编程，比如上面的animal,有一个makesound方法，针对所有动物，cat,dog都可以建立不同的makesound方法 *
*/


public interface QuackBehavior {
    public void quack();
}


public class Cat implements Animal{
    @Override
    public void makeSound() {
        System.out.println("miaomiao");
    }
}


public class Dog implements Animal {
    @Override
    public void makeSound() {
        bark();
    }
    public void bark(){
        System.out.println("wangwang");
    }
}


public abstract class Duck {
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;
    public Duck(){

    }

    public abstract void display();

    public void performQuack(){
        quackBehavior.quack();
    }

    public void performFly(){
        flyBehavior.fly();
    }

    public void setFlyBehavior(FlyBehavior flybehavior) {
        this.flyBehavior = flybehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }

    public void swim(){
        System.out.println("All ducks float,even decoys!");
    }
}

public class FlyNoWay implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("I cant fly");
    }
}


public class FlyRocketPowered implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("i am flying with a rocket!");
    }
}

public class FlyWithWings implements FlyBehavior{
    public void fly(){
        System.out.println("I am flying!!");
    }
}

public class MallardDuck extends Duck {
    public MallardDuck(){
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }

    public void display() {
        System.out.println(" i am real Mallard Duck");
    }
}


public class ModelDuck extends Duck{
    public ModelDuck() {
        quackBehavior = new MuteQuack();
        flyBehavior = new FlyNoWay();
    }

    @Override
    public void display() {
        System.out.println("I am a model duck!");
    }
}

public class MuteQuack implements QuackBehavior{
    @Override
    public void quack() {
        System.out.println("<<Silence>>");
    }
}

public class MiniDuckSimulator {
    public static void main(String[] args) {
        Duck mallard = new MallardDuck();
        mallard.performQuack();
        mallard.display();
        mallard.performFly();
        mallard.setFlyBehavior(new FlyNoWay());
        mallard.performFly();
        mallard.setQuackBehavior(new MuteQuack());
        mallard.performQuack();

        Duck modelduck = new ModelDuck();
        modelduck.display();
        modelduck.performQuack();
        modelduck.performFly();
        modelduck.setFlyBehavior(new FlyRocketPowered());
        modelduck.performFly();
    }
}


==== another example ====

public interface Action {
    public void doing();
}


public abstract class Person {
    Action action;
    String kind;
    Person(){

    }
    public void display(){
        System.out.println(" i am " + kind + "  person ");
    }
    public void performdoing(){
        action.doing();
    }

    public void setAction(Action action) {
        this.action = action;
    }
}


public class Playball implements Action{
    @Override
    public void doing() {
        System.out.println("i am play ball");
    }
}


public class Swimming implements Action{
    @Override
    public void doing() {
        System.out.println("I am swimming");
    }
}

public class YellowPerson extends Person{
    YellowPerson(){
        kind = "yellow";
        action = new Playball();

        InputStream;
        FileInputStream;
    }

}


public class PersonSimulator {
    public static void main(String[] args) {
        Person yp = new YellowPerson();
        yp.performdoing();
        yp.display();
        yp.setAction(new Swimming());
        yp.performdoing();
    }
}