深圳网站建设 百度一下,西宁高端网站建设,商务网站建设软件,深圳品牌网站制作平台Lambda 重构面向对象的设计模式
策略模式
策略模式包含三部分内容 一个代表某个算法的接口#xff08;它是策略模式的接口#xff09;。 一个或多个该接口的具体实现#xff0c;它们代表了算法的多种实现#xff08;比如#xff0c;实体类ConcreteStrategyA或者Concrete…Lambda 重构面向对象的设计模式
策略模式
策略模式包含三部分内容 一个代表某个算法的接口它是策略模式的接口。 一个或多个该接口的具体实现它们代表了算法的多种实现比如实体类ConcreteStrategyA或者ConcreteStrategyB。 一个或多个使用策略对象的客户
public interface ValidationStrategy { boolean execute(String s);
}public class IsAllLowerCase implements ValidationStrategy { public boolean execute(String s){ return s.matches([a-z]); }
}
public class IsNumeric implements ValidationStrategy { public boolean execute(String s){ return s.matches(\\d); }
}public class Validator{ private final ValidationStrategy strategy; public Validator(ValidationStrategy v){ this.strategy v; } public boolean validate(String s){ return strategy.execute(s); }
}
Validator numericValidator new Validator(new IsNumeric());
boolean b1 numericValidator.validate(aaaa);
Validator lowerCaseValidator new Validator(new IsAllLowerCase ());
boolean b2 lowerCaseValidator.validate(bbbb); Validator numericValidator new Validator((String s) - s.matches([a-z]));
boolean b1 numericValidator.validate(aaaa);
Validator lowerCaseValidator new Validator((String s) - s.matches(\\d));
boolean b2 lowerCaseValidator.validate(bbbb);Lambda表达式避免了采用策略设计模式时僵化的模板代码。如果你仔细分 析一下个中缘由可能会发现Lambda表达式实际已经对部分代码或策略进行了封装而 这就是创建策略设计模式的初衷。因此我们强烈建议对类似的问题你应该尽量使用Lambda 表达式来解决
模板方法
让我们从一个例子着手看看这个模式是如何工作的。假设你需要编写一个简单的在线银行 应用。通常用户需要输入一个用户账户之后应用才能从银行的数据库中得到用户的详细信息 最终完成一些让用户满意的操作。不同分行的在线银行应用让客户满意的方式可能还略有不同 比如给客户的账户发放红利或者仅仅是少发送一些推广文件。你可能通过下面的抽象类方式来 实现在线银行应用
abstract class OnlineBanking { public void processCustomer(int id){ Customer c Database.getCustomerWithId(id); makeCustomerHappy(c); }abstract void makeCustomerHappy(Customer c);
} 使用Lambda表达式
public void processCustomer(int id, ConsumerCustomer makeCustomerHappy){ Customer c Database.getCustomerWithId(id); makeCustomerHappy.accept(c);
} new OnlineBankingLambda().processCustomer(1337, (Customer c) - System.out.println(Hello c.getName()); 观察者模式
interface Observer { void notify(String tweet);
}class NYTimes implements Observer{ public void notify(String tweet) { if(tweet ! null tweet.contains(money)){ System.out.println(Breaking news in NY! tweet); } }
}
class Guardian implements Observer{ public void notify(String tweet) { if(tweet ! null tweet.contains(queen)){ System.out.println(Yet another news in London... tweet); } }
}
class LeMonde implements Observer{ public void notify(String tweet) { if(tweet ! null tweet.contains(wine)){ System.out.println(Today cheese, wine and news! tweet); } }
} interface Subject{ void registerObserver(Observer o); void notifyObservers(String tweet);
} class Feed implements Subject{ private final ListObserver observers new ArrayList(); public void registerObserver(Observer o) { this.observers.add(o); } public void notifyObservers(String tweet) { observers.forEach(o - o.notify(tweet)); }
}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!); 使用Lambda表达式
f.registerObserver((String tweet) - { if(tweet ! null tweet.contains(money)){ System.out.println(Breaking news in NY! tweet); }
});
f.registerObserver((String tweet) - { if(tweet ! null tweet.contains(queen)){ System.out.println(Yet another news in London... tweet); }
}); 那么是否我们随时随地都可以使用Lambda表达式呢答案是否定的我们前文介绍的例 子中Lambda适配得很好那是因为需要执行的动作都很简单因此才能很方便地消除僵化代 码。但是观察者的逻辑有可能十分复杂它们可能还持有状态抑或定义了多个方法诸如此 类。在这些情形下你还是应该继续使用类的方式
责任链模式
通常这种模式是通过定义一个代表处理对象的抽象类来实现的在抽象类中会定义一个字 段来记录后续对象。一旦对象完成它的工作处理对象就会将它的工作转交给它的后继。代码中 这段逻辑看起来是下面这样
public abstract class ProcessingObjectT { protected ProcessingObjectT successor; public void setSuccessor(ProcessingObjectT successor){ this.successor successor;} public T handle(T input){ T r handleWork(input); if(successor ! null){ return successor.handle(r); } return r; } abstract protected T handleWork(T input);
} public class HeaderTextProcessing extends ProcessingObjectString { public String handleWork(String text){ return From Raoul, Mario and Alan: text; }
}
public class SpellCheckerProcessing extends ProcessingObjectString { public String handleWork(String text){ return text.replaceAll(labda, lambda); }
} ProcessingObjectString p1 new HeaderTextProcessing();
ProcessingObjectString p2 new SpellCheckerProcessing();
p1.setSuccessor(p2);
String result p1.handle(Arent labdas really sexy?!!);
System.out.println(result); 使用Lambda表达式
UnaryOperatorString headerProcessing (String text) - From Raoul, Mario and Alan: text;
UnaryOperatorString spellCheckerProcessing (String text) - text.replaceAll(labda, lambda);
FunctionString, String pipeline headerProcessing.andThen(spellCheckerProcessing);
String result pipeline.apply(Arent labdas really sexy?!!)工厂模式
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); } }
}
Product p ProductFactory.createProduct(loan); 使用Lambda表达式
final static MapString, SupplierProduct 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){ SupplierProduct p map.get(name); if(p ! null) return p.get(); throw new IllegalArgumentException(No such product name);
}
