设计模式之状态模式/策略模式

一.状态模式

下面代码中，Stage包含一个对Actor的引用，并被初始化为一个HappyActor对象，在执行完change以后，actor又与SadActor进行了动态绑定，从而能够产生不一样的行为，这就在运行期间得到了灵活性。这也称做状态模式

public class NesttyMain {

    static class Actor{
        public void act(){}
    }

    static class HappyActor extends Actor{
        public void act(){
            System.out.println("HappyActor");
        }
    }


    static class SadActor extends Actor{
        public void act(){
            System.out.println("SadActor");
        }
    }
    
    static class Stage{
        private Actor actor = new HappyActor();

        public void change(){
            this.actor = new SadActor();
        }

        public void perform(){
            this.actor.act();
        }

    }

    public static void main(String[] args){

        Stage stage = new Stage();
        stage.perform();
        stage.change();
        stage.perform();
    }


}

二.策略模式

以下面代码，经过继承同一个类，从新process方法，实现了两个不一样的处理器，一个用于将字母大写，一个字母小写，在使用时，经过使用不一样的处理器来处理输入的字符串。这种经过传递参数对象的不一样而具备不一样的行为方法，叫作策略模式

public class NesttyMain {

    static class Processor {
        public Object process(Object obj){
            return obj;
        }
    }

    static class UppercaseProcessor extends Processor {
        public String process(Object str){
            return ((String)str).toUpperCase();
        }
    }


    static class LowerCaseProcessor extends Processor {
        public String process(Object str){
            return ((String)str).toLowerCase();
        }
    }

    static class ProcessApply{


        public void process(Processor processor,Object obj){
            System.out.println(processor.process(obj));
        }

    }

    public static void main(String[] args){

        ProcessApply pa = new ProcessApply();
        String str = "aZ";
        pa.process(new UppercaseProcessor(),str);
        pa.process(new LowerCaseProcessor(),str);
        System.out.println(str.toLowerCase());
        System.out.println(str.toUpperCase());
    }


}