Lambda 重构面向对象设计模式1

策略模式

策略模式包含三部分内容

1.一个代表某个算法的接口（它是策略模式的接口）。

2.一个或多个该接口的具体实现，它们代表了算法的多种实现（比如，实体类ConcreteStrategyA或者ConcreteStrategyB）。

 3.一个或多个使用策略对象的客户。

重构前：

    //策略接口
    public interface Strategy {
        boolean execute(String s);
    }

    //具体实现类
    public class IsAllLowerCaseStrategy implements Strategy {
        public boolean execute(String s) {
            return s.matches("[a-z]+");
        }
    }

    //具体实现类
    public class IsNumericStrategy implements Strategy {
        public boolean execute(String s) {
            return s.matches("\\d+");
        }
    }
    //组装工厂
    public class Validator{
        private final Strategy strategy;
        public Validator(Strategy v){
            this.strategy = v;
        }
        public boolean validate(String s){
            return strategy.execute(s);
        }
    }

    //策略使用
    @Test
    public void testStrategy() {
        Validator numericValidator = new Validator(new IsNumericStrategy());
        boolean isNumeric = numericValidator.validate("234234");
        System.out.println(isNumeric);

        Validator lowerCaseValidator = new Validator(new IsAllLowerCaseStrategy());
        boolean isLowerCase = lowerCaseValidator.validate("AB");
        System.out.println(isLowerCase);
    }

重构后：具体算法用Lambda实现

    //定义策略接口
    public interface Strategy {
        boolean execute(String s);
    }

    //组装工厂
    public class Validator{
        private final Strategy strategy;
        public Validator(Strategy v){
            this.strategy = v;
        }
        public boolean validate(String s){
            return strategy.execute(s);
        }
    }

    //Lambda实现
    @Test
    public void testStrategy2() {
        Validator numericValidator =
                new Validator((String s) -> s.matches("\\d+"));
        boolean isNumeric = numericValidator.validate("234234");
        System.out.println(isNumeric);

        Validator lowerCaseValidator =
                new Validator((String s) -> s.matches("[a-z]+"));
        boolean isLowerCase = lowerCaseValidator.validate("bbbb");
        System.out.println(isLowerCase);
    }

模板方法

重构前：

 /**
     * 定义模板
     */
    public abstract class AbstractClass {
        public final void templateMethod(int i) {
            //模板方法1
            method1(i);
        }
        protected abstract void method1(int i);

    }

    /**
     * 模板实现1
     */
    public class ConcreteClass1 extends AbstractClass {
        @Override
        protected void method1(int i) {
            System.out.println("ConcreteClass1 method1");
        }

    }


    @Test
    public void test4() {
        AbstractClass demo = new ConcreteClass1();
        demo.templateMethod(1);
    }

重构后：

    /**
     * 定义模板
     */
    public class AbstractClass2 {
        public final void templateMethod(int i, Consumer method1) {
            method1.accept(i);
        }
    }

    /**
     * 调用
     */
    @Test
    public void testAbstractClass() {
       new AbstractClass2().templateMethod(1, (Integer c) -> {
           System.out.println(c);
       });
    }

观察者模式

重构前

    /**
     * 定义主题接口
     */
    public interface Subject {
        //注册观察者
        void registerObserver(Observer observer);
        //移除观察者
        void removeObserver(Observer observer);
        //通知
        void notifyObservers(String message);
    }

    /**
     * 定义观察者接口
     */
    public interface Observer {
        void update(String message);
    }

    /**
     * 主题类实现
     */
    public class ConcreteSubject implements Subject {
        private List observers = new ArrayList();

        @Override
        public void registerObserver(Observer observer) {
            observers.add(observer);
        }

        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
        }

        @Override
        public void notifyObservers(String message) {
            for (Observer observer : observers) {
                observer.update(message);
            }
        }

    }

    /**
     * 观察者1
     */
    public class ConcreteObserverOne implements Observer {
        @Override
        public void update(String message) {
            //TODO: 获取消息通知，执行自己的逻辑...
            System.out.println(message);
        }
    }

    /**
     * 观察者2
     */
    public class ConcreteObserverTwo implements Observer {
        @Override
        public void update(String message) {
            //TODO: 获取消息通知，执行自己的逻辑...
            System.out.println(message);
        }
    }

    /**
     * 具体实现
     */
    @Test
    public void test5() {
        ConcreteSubject subject = new ConcreteSubject();
        subject.registerObserver(new ConcreteObserverOne());
        subject.registerObserver(new ConcreteObserverTwo());
        subject.notifyObservers("Hello world!");
    }

重构后

    /**
     * 定义主题接口
     */
    public interface Subject {
        //注册观察者
        void registerObserver(Observer observer);
        //移除观察者
        void removeObserver(Observer observer);
        //通知
        void notifyObservers(String message);
    }

    /**
     * 定义观察者接口
     */
    public interface Observer {
        void update(String message);
    }

    /**
     * 主题类实现
     */
    public class ConcreteSubject implements Subject {
        private List observers = new ArrayList();

        @Override
        public void registerObserver(Observer observer) {
            observers.add(observer);
        }

        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
        }

        @Override
        public void notifyObservers(String message) {
            for (Observer observer : observers) {
                observer.update(message);
            }
        }

    }

    /**
     *重构后
     */
    @Test
    public void test6() {
        ConcreteSubject subject = new ConcreteSubject();
        subject.registerObserver((String message) -> {
            if (message != null && message.contains("hello"))
            System.out.println("你好：" + message);
        });

        subject.registerObserver((String message) -> {
            if (message != null && message.contains("world"))
                System.out.println("你好：" + message);
        });
        subject.notifyObservers("hello");
    }

《中医基础理论》