Softwaredesign: Beispiel: Figuren verarbeiten mit Besucher

abstract
public
class Figur {
 
    abstract
    void besuche(FigurBesucher v);
 
    //--------------------
 
    double attribut(FigurAttribut va) {
        besuche(va);
        return
            va.getRes();
    }
 
    //--------------------
 
    public
    double umfang() {
        return
            attribut(new FigurAttribut() {
 
                public
                void besucheRechteck(Rechteck r) {
                    res += 2 * (r.breite + r.hoehe);
                }
 
                public
                void besucheKreis(Kreis k) {
                    res += 2 * java.lang.Math.PI * k.radius;
                }
 
            });
    }
 
    //--------------------
 
    public
    double flaeche() {
        return
            attribut(new FigurAttribut() {
 
                public
                void besucheRechteck(Rechteck r) {
                    res += r.breite * r.hoehe;
                }
 
                public
                void besucheKreis(Kreis k) {
                    res += java.lang.Math.PI * k.radius * k.radius;
                }
 
            });
    }
 
    //--------------------
 
    public
    Figur kopiere() {
        FigurKopierer fk = new FigurKopierer();
        besuche(fk);
        return
            fk.getRes();
    }
}

die Klasse für Rechtecke: Rechteck

public
class Rechteck extends Figur {
 
    double breite, hoehe;
 
    public Rechteck(double breite,
                    double hoehe) {
 
        this.breite = breite;
        this.hoehe  = hoehe;
    }
 
    void besuche(FigurBesucher v) {
        v.besucheRechteck(this);
    }
 
}

die Klasse für Kreise: Kreis

public
class Kreis extends Figur {
 
    double radius;
 
    public Kreis(double radius) {
        this.radius = radius;
    }
 
    void besuche(FigurBesucher v) {
        v.besucheKreis(this);
    }
 
}

die Klasse für Figuren mit Position: FigurMitPosition

public
class FigurMitPosition extends Figur {
 
    double x,y;
 
    Figur figur;
 
    public FigurMitPosition(double x,
                            double y,
                            Figur figur) {
        this.x     = x;
        this.y     = y;
        this.figur = figur;
    }
 
    void besuche(FigurBesucher v) {
        v.besucheFigurMitPosition(this);
    }
 
}

die Klasse für zusammengesetzte Figuren: KomplexeFigur

public
class KomplexeFigur extends Figur {
 
    Figur[] teile;
 
    public
    KomplexeFigur(Figur[] teile) {
        this.teile = teile;
    }
 
    void besuche(FigurBesucher v) {
        v.besucheKomplexeFigur(this);
    }
 
    
}

die Schnittstelle für die Besucher-Klasse : FigurBesucher

interface FigurBesucher {
 
    void besucheRechteck(Rechteck r);
 
    void besucheKreis(Kreis k);
 
    void besucheFigurMitPosition(FigurMitPosition f);
 
    void besucheKomplexeFigur(KomplexeFigur f);
 
}

die Klasse für den default-Besucher: FigurBesucher0

public
class FigurBesucher0 implements FigurBesucher {
 
    public
    void besucheRechteck(Rechteck r) {}
 
    public
    void besucheKreis(Kreis k) {}
 
    public
    void besucheFigurMitPosition(FigurMitPosition f) {
        f.figur.besuche(this);
    }
 
    public
    void besucheKomplexeFigur(KomplexeFigur f) {
        for ( int i = 0;
              i < f.teile.length;
              ++i ) {
            f.teile[i].besuche(this);
        }
    }
}

eine Klasse für die Berechnung eines Figuren-Attributs: FigurAttribut

public
class FigurAttribut extends FigurBesucher0 {
    protected
    double res = 0;
 
    public
    double getRes() {
        return
            res;
    }
}

die Klasse für das tiefe Kopieren einer Figur: FigurKopierer

public
class FigurKopierer implements FigurBesucher {
 
    private
    Figur res;
 
    public
    Figur getRes() {
        return
            res;
    }
 
    //--------------------
 
    public
    void besucheRechteck(Rechteck r) {
        res = new Rechteck(r.hoehe, r.breite);
    }
 
    public
    void besucheKreis(Kreis k) {
        res = new Kreis(k.radius);
    }
 
    public
    void besucheFigurMitPosition(FigurMitPosition f) {
        f.figur.besuche(this);
        res = new FigurMitPosition(f.x,f.y,res);
    }
 
    public
    void besucheKomplexeFigur(KomplexeFigur f) {
        Figur[] teile = new Figur[f.teile.length];
 
        for ( int i = 0;
              i < f.teile.length;
              ++i ) {
            f.teile[i].besuche(this);
            teile[i] = res;
        }
 
        res = new KomplexeFigur(teile);
    }
}

der Besucher in Haskell

module Figur where
data Figur = Rechteck { breite :: Double
                      , hoehe  :: Double
                      }
           | Kreis    { radius :: Double
                      }
           | MitPos   { x :: Double
                      , y :: Double
                      , f :: Figur
                      }
           | Komplex  { teile :: [Figur] }
-- ----------------------------------------
visit :: (Double -> Double        -> res) ->
         (Double                  -> res) ->
         (Double -> Double -> res -> res) ->
         ([res]                   -> res) ->
         Figur -> res
visit pRechteck pKreis pMitPos pKomplex = go
  where
    go (Rechteck b h) = pRechteck b h
    go (Kreis    r  ) = pKreis    r
    go (MitPos x y f) = pMitPos   x y (go f)
    go (Komplex   fs) = pKomplex (map go fs)
-- ----------------------------------------
    
umfang :: Figur -> Double
umfang = visit
         (\ b h -> 2 * b * h)
         (\ r -> 2 * pi * r)
         (\ x y u -> u)
         sum
flaeche :: Figur -> Double
flaeche = visit
          (\ b h -> b * h)
          (\ r -> pi * r^2)
          (\ x y f -> f)
          sum
-- die id-Funktion
klonen :: Figur -> Figur
klonen = visit Rechteck Kreis MitPos Komplex

Beispiel: Figuren verarbeiten mit Besucher

die abstrakte Klasse: Figur