目录
. 改写设计模式
. 策略模式 (Strategy Pattern)
. 模板方法模式 (Template Method Pattern)
. 观察者模式 (Observer Pattern)
. 责任链模式 (Chain of Responsibility Pattern)
. 简单工厂模式 (Simple Factory Pattern)
. 高阶函数与柯里化
改写设计模式
策略模式 (Strategy Pattern)
1. 改写前
- a) ValidationStrategy.java
- public interface ValidationStrategy {
- boolean execute(String s);
- }
- b) IsNumeric.java
- public class IsNumeric implements ValidationStrategy {
- public boolean execute(String s) {
- return s.matches("\\d+");
- }
- }
- c) IsAllLowerCase.java
- public class IsAllLowerCase implements ValidationStrategy {
- public boolean execute(String s) {
- return s.matches("[a-z]+");
- }
- }
- d) Validator.java
- public class Validator {
- private final ValidationStrategy strategy;
- public Validator(ValidationStrategy v) {
- this.strategy = v;
- }
- public boolean validate(String s) {
- return strategy.execute(s);
- }
- }
- e) Test.java
- public class Test {
- public static void main(String[] args) {
- Validator numericValidator = new Validator(new IsNumeric());
- boolean b1 = numericValidator.validate("aaaa");
- System.out.println(b1); // false
- Validator lowerCaseValidator = new Validator(new IsAllLowerCase());
- boolean b2 = lowerCaseValidator.validate("bbbb");
- System.out.println(b2); // true
- }
- }
2. 改写后
- a) Test.java
- public class Test {
- public static void main(String[] args) {
- Validator numericValidator = new Validator((String s) -> s.matches("\\d+"));
- boolean b1 = numericValidator.validate("aaaa");
- System.out.println(b1); // false
- Validator lowerCaseValidator = new Validator(s -> s.matches("[a-z]+"));
- boolean b2 = lowerCaseValidator.validate("bbbb");
- System.out.println(b2); // true
- }
- }
模板方法模式 (Template Method Pattern)
1. 改写前
- a) Customer.java
- public class Customer {
- private int id;
- private String name;
- public Customer(int id, String name) {
- this.id = id;
- this.name = name;
- }
- public int getId() {
- return id;
- }
- public void setId(int id) {
- this.id = id;
- }
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- }
- b) OnlineBanking.java
- public abstract class OnlineBanking {
- public void processCustomer(int id) {
- Customer c = new Customer(id, "Jhon");
- makeCustomerHappy(c);
- }
- abstract void makeCustomerHappy(Customer c);
- }
2. 改写后
- a) OnlineBankingLambda.java
- import java.util.function.Consumer;
- public class OnlineBankingLambda {
- public void processCustomer(int id, Consumer<Customer> makeCustomerHappy) {
- Customer c = new Customer(id, "Jhon");
- makeCustomerHappy.accept(c);
- }
- }
- b) Test.java
- public class Test {
- public static void main(String[] args) {
- new OnlineBankingLambda().processCustomer(1337, (Customer c) -> System.out.println("Hello" + c.getName()));
- }
- }
观察者模式 (Observer Pattern)
1. 改写前
- a) Observer.java
- public interface Observer {
- void notify(String tweet);
- }
- b) NYTimes.java
- public class NYTimes implements Observer {
- public void notify(String tweet) {
- if (tweet != null && tweet.contains("money")) {
- System.out.println("Breaking news in NY!" + tweet);
- }
- }
- }
- c) Guardian.java
- public class Guardian implements Observer {
- public void notify(String tweet) {
- if (tweet != null && tweet.contains("queen")) {
- System.out.println("Yet another news in London..." + tweet);
- }
- }
- }
- d) LeMonde.java
- public class LeMonde implements Observer {
- public void notify(String tweet) {
- if (tweet != null && tweet.contains("wine")) {
- System.out.println("Today cheese, wine and news!" + tweet);
- }
- }
- }
- e) Subject.java
- public interface Subject {
- void registerObserver(Observer o);
- void notifyObservers(String tweet);
- }
- f) Feed.java
- public class Feed implements Subject {
- private final List<Observer> observers = new ArrayList<>();
- public void registerObserver(Observer o) {
- this.observers.add(o);
- }
- public void notifyObservers(String tweet) {
- observers.forEach(o -> o.notify(tweet));
- }
- }
- g) Test.java
- public class Test {
- public static void main(String[] args) {
- Feed f = new Feed();
- f.registerObserver(new NYTimes());
- f.registerObserver(new Guardian());
- f.registerObserver(new LeMonde());
- f.notifyObservers("The queen said her favourite book is Java 8 in Action!");
- }
- }
2. 改写后
- a) Test.java
- public class Test {
- public static void main(String[] args) {
- Feed f = new Feed();
- f.registerObserver((String tweet) -> {
- if (tweet != null && tweet.contains("money")) {
- System.out.println("Breaking news in NY!" + tweet);
- }
- });
- f.registerObserver((tweet) -> {
- if (tweet != null && tweet.contains("queen")) {
- System.out.println("Yet another news in London..." + tweet);
- }
- });
- f.registerObserver((tweet) -> {
- if (tweet != null && tweet.contains("wine")) {
- System.out.println("Today cheese, wine and news!" + tweet);
- }
- });
- f.notifyObservers("The queen said her favourite book is Java 8 in Action!");
- }
- }
责任链模式 (Chain of Responsibility Pattern)
1. 改写前
- a) ProcessingObject.java
- public abstract class ProcessingObject<T> {
- protected ProcessingObject<T> successor;
- public void setSuccessor(ProcessingObject<T> successor) {
- this.successor = successor;
- }
- public T handle(T input) {
- T r = handleWork(input);
- if (successor != null) {
- return successor.handle(r);
- }
- return r;
- }
- protected abstract T handleWork(T input);
- }
- b) HeaderTextProcessing.java
- public class HeaderTextProcessing extends ProcessingObject<String> {
- public String handleWork(String text) {
- return "From Raoul, Mario and Alan:" + text;
- }
- }
- c) SpellCheckerProcessing.java
- public class SpellCheckerProcessing extends ProcessingObject<String> {
- public String handleWork(String text) {
- return text.replaceAll("labda", "lambda");
- }
- }
- d) Test.java
- public class Test {
- public static void main(String[] args) {
- ProcessingObject<String> p1 = new HeaderTextProcessing();
- ProcessingObject<String> p2 = new SpellCheckerProcessing();
- p1.setSuccessor(p2);
- String result = p1.handle("Aren't labdas really sexy?!!");
- System.out.println(result);
- }
- }
2. 改写后
- a) Test.java
- public class Test {
- public static void main(String[] args) {
- UnaryOperator<String> headerProcessing = (String text) -> "From Raoul, Mario and Alan:" + text;
- UnaryOperator<String> spellCheckerProcessing = (String text) -> text.replaceAll("labda", "lambda");
- Function<String, String> pipeline = headerProcessing.andThen(spellCheckerProcessing);
- String result = pipeline.apply("Aren't labdas really sexy?!!");
- System.out.println(result);
- }
- }
简单工厂模式 (Simple Factory Pattern)
1. 改写前
- a) Product.java
- public interface Product {
- }
- b) Loan.java
- public class Loan implements Product {
- }
- c) Stock.java
- public class Stock implements Product {
- }
- d) Bond.java
- public class Bond implements Product {
- }
- e) ProductFactory.java
- public class ProductFactory {
- public static Product createProduct(String name) {
- switch (name) {
- case "loan":
- return new Loan();
- case "stock":
- return new Stock();
- case "bond":
- return new Bond();
- default:
- throw new RuntimeException("No such product" + name);
- }
- }
- }
- f) Test.java
- public class Test {
- public static void main(String[] args) {
- Product p = ProductFactory.createProduct("loan");
- }
- }
2. 改写后
- a) ProductFactory.java
- import java.util.HashMap;
- import java.util.Map;
- import java.util.function.Supplier;
- public class ProductFactory {
- final static Map<String, Supplier<Product>> map = new HashMap<>();
- static {
- map.put("loan", Loan::new);
- map.put("stock", Stock::new);
- map.put("bond", Bond::new);
- }
- public static Product createProduct(String name) {
- Supplier<Product> p = map.get(name);
- if (p != null) return p.get();
- throw new IllegalArgumentException("No such product" + name);
- }
- }
- b) Test.java
- public class Test {
- public static void main(String[] args) {
- Product p = ProductFactory.createProduct("loan");
- }
- }
高阶函数与柯里化
1. 高阶函数 (Higher-order Function): 满足以下任意一个条件都是高阶函数.
a) 接受至少一个函数作为参数.
b) 返回的结果是一个函数.
2. 柯里化 (Currying): 假设有一个函数 f(x, y) , 柯里化就是把多个参数的函数 f 转化为一个参数的函数 g, 并且函数 g 的返回值一个新函数, 即 f(x, y) = (g(x))(y) .
3. 柯里化好处: 灵活, 复用.
4. 举例
a) 柯里化前
- public class Test {
- public static double converter(double x, double f, double b) {
- return x * f + b;
- }
- public static void main(String[] args) {
- double gbp = converter(1000, 0.6, 0);
- System.out.println(gbp);
- }
- }
b) 柯里化后
- public class Test {
- public static DoubleUnaryOperator curriedConverter(double f, double b) {
- return (double x) -> x * f + b;
- }
- public static void main(String[] args) {
- DoubleUnaryOperator convertCtoF = curriedConverter(9.0 / 5, 32);
- DoubleUnaryOperator convertUSDtoGBP = curriedConverter(0.6, 0);
- DoubleUnaryOperator convertKmtoMi = curriedConverter(0.6214, 0);
- double gbp = convertUSDtoGBP.applyAsDouble(1000);
- System.out.println(gbp);
- }
- }
作者: netoxi
来源: https://www.cnblogs.com/netoxi/p/10346537.html