Java Tutorial/Design Pattern/Chain of Responsibility Patterns

Chain of responsibility

   <source lang="java">

// Carries the result data and whether the strategy was successful: class Document {

 public double[] data;
 public Document(double[] data) {
   this.data = data;
 }
 private boolean succeeded;
 public boolean isSuccessful() {
   return succeeded;
 }
 public void setSuccessful(boolean b) {
   succeeded = b;
 }

} interface Format {

 Document doFormat(Document m);

} class EnlargeFont implements Format {

 public Document doFormat(Document m) {
   System.out.println("Trying EnlargeFont algorithm");
   Document r = new Document(new double[] { 1.1, 2.2 }); // Dummy data
   r.setSuccessful(false);
   return r;
 }

} class ChangeColor implements Format {

 public Document doFormat(Document m) {
   System.out.println("Trying ChangeColor algorithm");
   Document r = new Document(new double[] { 3.3, 4.4 }); // Dummy data
   r.setSuccessful(false);
   return r;
 }

} class AddHeader implements Format {

 public Document doFormat(Document m) {
   System.out.println("Trying AddHeader algorithm");
   Document r = new Document(new double[] { 5.5, 6.6 }); // Dummy data
   r.setSuccessful(true);
   return r;
 }

} class AddFooter implements Format {

 public Document doFormat(Document m) {
   System.out.println("Trying AddFooter algorithm");
   Document r = new Document(new double[] { 5.5, 6.6 }); // Dummy data
   r.setSuccessful(true);
   return r;
 }

} class DocumentFormat {

 private static Format[] solutions = { new EnlargeFont(), new ChangeColor(), new AddHeader(),
     new AddFooter(), };
 public static Document solve(Document line) {
   Document r = line;
   for (int i = 0; i < solutions.length; i++) {
     r = solutions[i].doFormat(r);
     if (r.isSuccessful())
       return r;
   }
   throw new RuntimeException("unsolved: " + line);
 }

} public class ChainOfResposibilityDemo {

 public static void main(String args[]) {
   Document line = new Document(new double[] { 1.0, 2.0, 1.0, 2.0, -1.0, 3.0, 4.0, 5.0, 4.0 });
   System.out.println(((Document) DocumentFormat.solve(line)).data);
 }

}</source>

Multiple dispatching

   <source lang="java">

import java.util.Random; class Result {

 private String name;
 private Result(String name) {
   this.name = name;
 }
 public final static Result LessThan = new Result("Less than"), Equal = new Result("equal"),
     GreaterThan = new Result("Greater than");
 public String toString() {
   return name;
 }

} interface Number {

 Result compete(Number it);
 Result eval(One p);
 Result eval(Two s);
 Result eval(Three r);

} class One implements Number {

 public Result compete(Number it) {
   return it.eval(this);
 }
 public Result eval(One p) {
   return Result.GreaterThan;
 }
 public Result eval(Two s) {
   return Result.LessThan;
 }
 public Result eval(Three r) {
   return Result.Equal;
 }
 public String toString() {
   return "One";
 }

} class Two implements Number {

 public Result compete(Number it) {
   return it.eval(this);
 }
 public Result eval(One p) {
   return Result.Equal;
 }
 public Result eval(Two s) {
   return Result.GreaterThan;
 }
 public Result eval(Three r) {
   return Result.LessThan;
 }
 public String toString() {
   return "Two";
 }

} class Three implements Number {

 public Result compete(Number it) {
   return it.eval(this);
 }
 public Result eval(One p) {
   return Result.LessThan;
 }
 public Result eval(Two s) {
   return Result.Equal;
 }
 public Result eval(Three r) {
   return Result.GreaterThan;
 }
 public String toString() {
   return "Three";
 }

} class NumberGenerator {

 private static Random rand = new Random();
 public static Number newItem() {
   switch (rand.nextInt(3)) {
   default:
   case 0:
     return new Two();
   case 1:
     return new One();
   case 2:
     return new Three();
   }
 }

} class Compete {

 public static void match(Number a, Number b) {
   System.out.println(a + " " + a.rupete(b) + " vs. " + b);
 }

} public class MultipleDispathDemo {

 public static void main(String args[]) {
   int SIZE = 20;
   for (int i = 0; i < SIZE; i++)
     Compete.match(NumberGenerator.newItem(), NumberGenerator.newItem());
 }

}</source>

Watch What is Going On with the Chain of Responsibility Patterns

   <source lang="java">

public class MainClass {

 public static void main(String args[]) {
   Application app = new Application();
   IntermediateLayer intermediateLayer = new IntermediateLayer(app);
   FrontEnd frontEnd = new FrontEnd(intermediateLayer);
   frontEnd.getHelp(HelpType.GENERAL_HELP);
 }

} class HelpType {

 public final static int FRONT_END_HELP = 1;
 public final static int INTERMEDIATE_LAYER_HELP = 2;
 public final static int GENERAL_HELP = 3;

} interface HelpInterface {

 public void getHelp(int helpConstant);

} class IntermediateLayer implements HelpInterface {

 HelpInterface successor;
 public IntermediateLayer(HelpInterface s) {
   successor = s;
 }
 public void getHelp(int helpConstant) {
   if (helpConstant != HelpType.INTERMEDIATE_LAYER_HELP) {
     successor.getHelp(helpConstant);
   } else {
     System.out.println("intermediate");
   }
 }

} class FrontEnd implements HelpInterface {

 HelpInterface successor;
 public FrontEnd(HelpInterface s) {
   successor = s;
 }
 public void getHelp(int helpConstant) {
   if (helpConstant != HelpType.FRONT_END_HELP) {
     successor.getHelp(helpConstant);
   } else {
     System.out.println("front end");
   }
 }

} class Application implements HelpInterface {

 public void getHelp(int helpConstant) {
   System.out.println("application");
 }

}</source>