Softwaredesign: Beispiel: Double Dispatch durch zweimaliges dynamisches Binden

abstract
public
class Zahl {
 
  // DIE eigentliche Additions-Operation
  abstract
  public
  Zahl plus(Zahl z2);
  
  // Hilfsfunktionen
 
  abstract
  protected
  Zahl plusGanzeZahl(GanzeZahl z1);
 
  abstract
  protected
  Zahl plusRationaleZahl(RationaleZahl z1);
 
  abstract
  protected
  Zahl plusReelleZahl(ReelleZahl z1);
}

1. konkrete Ausprägung: GanzeZahl

public
class GanzeZahl extends Zahl {
  int i;
 
  public
  GanzeZahl(int i) {
    this.i = i;
  }
 
 
  // 1.Parameter ist ganze Zahl
  // die Verzweigung ueber die Art des 2.Paramters
 
  public
  Zahl plus(Zahl z2) {
    return
      z2.plusGanzeZahl(this);
  }
 
 
  // die Hilfsfunktionen
 
  // i + i
 
  protected
  Zahl plusGanzeZahl(GanzeZahl z1) {
    return
      new GanzeZahl(z1.i + i);
  }
 
 
  // z/n + i --> (z + i*n)/n
 
  protected
  Zahl plusRationaleZahl(RationaleZahl z1) {
    return
      new RationaleZahl(z1.z + i*z1.n, z1.n);
  }
 
 
  // r + i --> r + (double)i
 
  protected
  Zahl plusReelleZahl(ReelleZahl z1) {
    return
      new ReelleZahl(z1.r + (double)i);
  }
}

2. konkrete Ausprägung: RationaleZahl

public
class RationaleZahl extends Zahl {
  int z;
  int n;
 
  public
  RationaleZahl(int z, int n) {
    this.z = z;
    this.n = n;
  }
 
 
  public
  Zahl plus(Zahl z2) {
    return
      z2.plusRationaleZahl(this);
  }
 
 
  // i + z/n --> (i*n + z)/n
 
  protected
  Zahl plusGanzeZahl(GanzeZahl z1) {
    return
      new RationaleZahl(z + z1.i * n, n);
  }
 
 
  // z1/n1 + z2/n2 --> (z1*n2 + z2*n1)/(n1*n2)
 
  protected
  Zahl plusRationaleZahl(RationaleZahl z1) {
    return
      new RationaleZahl(z1.z * n + z * z1.n, n * z1.n);
  }
 
 
  // r + z/n --> r + (double)z/(double)n
 
  protected
  Zahl plusReelleZahl(ReelleZahl z1) {
    return
      new ReelleZahl(z1.r + (double)z/(double)n);
  }
}

3. konkrete Ausprägung: ReelleZahl

public
class ReelleZahl extends Zahl {
  double r;
 
  public
  ReelleZahl(double r) {
    this.r = r;
  }
 
 
 
  public
  Zahl plus(Zahl z2) {
    return
      z2.plusReelleZahl(this);
  }
 
 
  // i + z/n --> (i*n + z)/n
 
  protected
  Zahl plusGanzeZahl(GanzeZahl z1) {
    return
      new ReelleZahl((double)z1.i + r);
  }
 
 
  // z1/n1 + r --> (double)z1/(double)n1 + r
 
  protected
  Zahl plusRationaleZahl(RationaleZahl z1) {
    return
      new ReelleZahl((double)z1.z/(double)z1.n + r);
  }
 
 
  // r1 + r2
 
  protected
  Zahl plusReelleZahl(ReelleZahl z1) {
    return
      new ReelleZahl(z1.r + r);
  }
}

Beispiel: Double Dispatch durch zweimaliges dynamisches Binden

eine abstrakte Klasse für Zahlen

1. konkrete Ausprägung: GanzeZahl

2. konkrete Ausprägung: RationaleZahl

3. konkrete Ausprägung: ReelleZahl