模板方法模式需要注意抽象类与具体子类之间的协作。它用到了虚函数的多态性技术以及“不用调用我,让我来调用你”的反向控制技术。
public class TemplateMethodPattern{
public static void main(String[] args){
AbstractClass tm=new ConcreteClass();
tm.TemplateMethod();
}
}
//抽象类
abstract class AbstractClass{
public void TemplateMethod() //模板方法{
SpecificMethod();
abstractMethod1();
abstractMethod2();
}
public void SpecificMethod() //具体方法{
System.out.println("抽象类中的具体方法被调用...");
}
public abstract void abstractMethod1(); //抽象方法1
public abstract void abstractMethod2(); //抽象方法2
}
//具体子类
class ConcreteClass extends AbstractClass{
public void abstractMethod1(){
System.out.println("抽象方法1的实现被调用...");
}
public void abstractMethod2(){
System.out.println("抽象方法2的实现被调用...");
}
}
public class HookTemplateMethod{
public static void main(String[] args){
HookAbstractClass tm=new HookConcreteClass();
tm.TemplateMethod();
}
}
//含钩子方法的抽象类
abstract class HookAbstractClass{
//模板方法
public void TemplateMethod(){
abstractMethod1();
HookMethod1();
if(HookMethod2()){
SpecificMethod();
}
abstractMethod2();
}
//具体方法
public void SpecificMethod(){
System.out.println("抽象类中的具体方法被调用...");
}
public void HookMethod1(){} //钩子方法1
//钩子方法2
public boolean HookMethod2(){
return true;
}
public abstract void abstractMethod1(); //抽象方法1
public abstract void abstractMethod2(); //抽象方法2
}
//含钩子方法的具体子类
class HookConcreteClass extends HookAbstractClass{
public void abstractMethod1(){
System.out.println("抽象方法1的实现被调用...");
}
public void abstractMethod2(){
System.out.println("抽象方法2的实现被调用...");
}
public void HookMethod1(){
System.out.println("钩子方法1被重写...");
}
//重写钩子方法2
public boolean HookMethod2(){
return false;
}
}
策略模式是准备一组算法,并将这组算法封装到一系列的策略类里面,作为一个抽象策略类的子类。策略模式的重心不是如何实现算法,而是如何组织这些算法,从而让程序结构更加灵活,具有更好的维护性和扩展性
public class StrategyPattern{
public static void main(String[] args){
Context c=new Context();
Strategy s=new ConcreteStrategyA();
c.setStrategy(s);
c.strategyMethod();
System.out.println("-----------------");
s=new ConcreteStrategyB();
c.setStrategy(s);
c.strategyMethod();
}
}
//抽象策略类
interface Strategy{
public void strategyMethod(); //策略方法
}
//具体策略类A
class ConcreteStrategyA implements Strategy{
public void strategyMethod(){
System.out.println("具体策略A的策略方法被访问!");
}
}
//具体策略类B
class ConcreteStrategyB implements Strategy{
public void strategyMethod(){
System.out.println("具体策略B的策略方法被访问!");
}
}
//环境类
class Context{
private Strategy strategy;
public Strategy getStrategy(){
return strategy;
}
public void setStrategy(Strategy strategy){
this.strategy=strategy;
}
public void strategyMethod(){
strategy.strategyMethod();
}
}
public class CommandPattern{
public static void main(String[] args){
Command cmd=new ConcreteCommand();
Invoker ir=new Invoker(cmd);
System.out.println("客户访问调用者的call()方法...");
ir.call();
}
}
//调用者
class Invoker{
private Command command;
public Invoker(Command command){
this.command=command;
}
public void setCommand(Command command){
this.command=command;
}
public void call(){
System.out.println("调用者执行命令command...");
command.execute();
}
}
//抽象命令
interface Command{
public abstract void execute();
}
//具体命令
class ConcreteCommand implements Command{
private Receiver receiver;
ConcreteCommand(){
receiver=new Receiver();
}
public void execute(){
receiver.action();
}
}
//接收者
class Receiver{
public void action(){
System.out.println("接收者的action()方法被调用...");
}
}
import java.util.ArrayList;
public class CompositeCommandPattern{
public static void main(String[] args){
AbstractCommand cmd1=new ConcreteCommand1();
AbstractCommand cmd2=new ConcreteCommand2();
CompositeInvoker ir=new CompositeInvoker();
ir.add(cmd1);
ir.add(cmd2);
System.out.println("客户访问调用者的execute()方法...");
ir.execute();
}
}
//抽象命令
interface AbstractCommand{
public abstract void execute();
}
//树叶构件: 具体命令1
class ConcreteCommand1 implements AbstractCommand{
private CompositeReceiver receiver;
ConcreteCommand1(){
receiver=new CompositeReceiver();
}
public void execute(){
receiver.action1();
}
}
//树叶构件: 具体命令2
class ConcreteCommand2 implements AbstractCommand{
private CompositeReceiver receiver;
ConcreteCommand2(){
receiver=new CompositeReceiver();
}
public void execute(){
receiver.action2();
}
}
//树枝构件: 调用者
class CompositeInvoker implements AbstractCommand{
private ArrayList children = new ArrayList();
public void add(AbstractCommand c){
children.add(c);
}
public void remove(AbstractCommand c){
children.remove(c);
}
public AbstractCommand getChild(int i){
return children.get(i);
}
public void execute(){
for(Object obj:children){
((AbstractCommand)obj).execute();
}
}
}
//接收者
class CompositeReceiver{
public void action1(){
System.out.println("接收者的action1()方法被调用...");
}
public void action2(){
System.out.println("接收者的action2()方法被调用...");
}
}
在责任链模式中,客户只需要将请求发送到责任链上即可,无须关心请求的处理细节和请求的传递过程,所以责任链将请求的发送者和请求的处理者解耦了
public class ChainOfResponsibilityPattern{
public static void main(String[] args){
//组装责任链
Handler handler1=new ConcreteHandler1();
Handler handler2=new ConcreteHandler2();
handler1.setNext(handler2);
//提交请求
handler1.handleRequest("two");
}
}
//抽象处理者角色
abstract class Handler{
private Handler next;
public void setNext(Handler next){
this.next=next;
}
public Handler getNext(){
return next;
}
//处理请求的方法
public abstract void handleRequest(String request);
}
//具体处理者角色1
class ConcreteHandler1 extends Handler{
public void handleRequest(String request){
if(request.equals("one")) {
System.out.println("具体处理者1负责处理该请求!");
}els{
if(getNext()!=null){
getNext().handleRequest(request);
}else{
System.out.println("没有人处理该请求!");
}
}
}
}
//具体处理者角色2
class ConcreteHandler2 extends Handler{
public void handleRequest(String request){
if(request.equals("two")) {
System.out.println("具体处理者2负责处理该请求!");
}else{
if(getNext()!=null){
getNext().handleRequest(request);
}else{
System.out.println("没有人处理该请求!");
}
}
}
}
更多设计模式的分享,请查看https://blog.csdn.net/pp_l_ly/category_9961646.html