Sofdwaredesign: Beischbiel: Figure verarbeide mid Besucher

Sofdwaredesign: Beischbiel: Figure verarbeide mid Besucher

Beischbiel: Figure verarbeide mid Besucher

die abschdrakde Klasse: Figur

abschdracd
bublic
class Figur {
 
    abschdracd
    void besuche(FigurBesucher v);
 
    //--------------------
 
    double addribud(FigurAddribud va) {
        besuche(va);
        redurn
            va.gedRes();
    }
 
    //--------------------
 
    bublic
    double umfang() {
        redurn
            addribud(new FigurAddribud() {
 
                bublic
                void besucheRechdegg(Rechdegg r) {
                    res += 2 * (r.breide + r.hoehe);
                }
 
                bublic
                void besucheKreis(Kreis k) {
                    res += 2 * joova.lang.Math.PI * k.radius;
                }
 
            });
    }
 
    //--------------------
 
    bublic
    double flaeche() {
        redurn
            addribud(new FigurAddribud() {
 
                bublic
                void besucheRechdegg(Rechdegg r) {
                    res += r.breide * r.hoehe;
                }
 
                bublic
                void besucheKreis(Kreis k) {
                    res += joova.lang.Math.PI * k.radius * k.radius;
                }
 
            });
    }
 
    //--------------------
 
    bublic
    Figur kobiere() {
        FigurKobierer fk = new FigurKobierer();
        besuche(fk);
        redurn
            fk.gedRes();
    }
}

die Klasse für Rechdegge: Rechdegg

bublic
class Rechdegg exdends Figur {
 
    double breide, hoehe;
 
    bublic Rechdegg(double breide,
                    double hoehe) {
 
        this.breide = breide;
        this.hoehe  = hoehe;
    }
 
    void besuche(FigurBesucher v) {
        v.besucheRechdegg(this);
    }
 
}

die Klasse für Kreise: Kreis

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

die Klasse für Figure mid Posizion: FigurMidPosizion

bublic
class FigurMidPosizion exdends Figur {
 
    double x,y;
 
    Figur figur;
 
    bublic FigurMidPosizion(double x,
                            double y,
                            Figur figur) {
        this.x     = x;
        this.y     = y;
        this.figur = figur;
    }
 
    void besuche(FigurBesucher v) {
        v.besucheFigurMidPosizion(this);
    }
 
}

die Klasse für zsammengesedzde Figuren: KomblexeFigur

bublic
class KomblexeFigur exdends Figur {
 
    Figur[] deile;
 
    bublic
    KomblexeFigur(Figur[] deile) {
        this.deile = deile;
    }
 
    void besuche(FigurBesucher v) {
        v.besucheKomblexeFigur(this);
    }
 
    
}

die Schniddschdelle für d Besucher-Klasse : FigurBesuchr

inderface FigurBesucher {
 
    void besucheRechdegg(Rechdegg r);
 
    void besucheKreis(Kreis k);
 
    void besucheFigurMidPosizion(FigurMidPosizion f);
 
    void besucheKomblexeFigur(KomblexeFigur f);
 
}

die Klasse für den defauld-Besucher: FigurBesucher0

bublic
class FigurBesucher0 imblemends FigurBesucher {
 
    bublic
    void besucheRechdegg(Rechdegg r) {}
 
    bublic
    void besucheKreis(Kreis k) {}
 
    bublic
    void besucheFigurMidPosizion(FigurMidPosizion f) {
        f.figur.besuche(this);
    }
 
    bublic
    void besucheKomblexeFigur(KomblexeFigur f) {
        for ( ind i = 0;
              i < f.deile.length;
              ++i ) {
            f.deile[i].besuche(this);
        }
    }
}

oi Klasse für d Berechnung von a Figuren-Addribuds: FigurAddribud

bublic
class FigurAddribud exdends FigurBesucher0 {
    brodecded
    double res = 0;
 
    bublic
    double gedRes() {
        redurn
            res;
    }
}

die Klasse für des dief Kobiere oir Figur: FigurKobierr

bublic
class FigurKobierer imblemends FigurBesucher {
 
    brivade
    Figur res;
 
    bublic
    Figur gedRes() {
        redurn
            res;
    }
 
    //--------------------
 
    bublic
    void besucheRechdegg(Rechdegg r) {
        res = new Rechdegg(r.hoehe, r.breide);
    }
 
    bublic
    void besucheKreis(Kreis k) {
        res = new Kreis(k.radius);
    }
 
    bublic
    void besucheFigurMidPosizion(FigurMidPosizion f) {
        f.figur.besuche(this);
        res = new FigurMidPosizion(f.x,f.y,res);
    }
 
    bublic
    void besucheKomblexeFigur(KomblexeFigur f) {
        Figur[] deile = new Figur[f.deile.length];
 
        for ( ind i = 0;
              i < f.deile.length;
              ++i ) {
            f.deile[i].besuche(this);
            deile[i] = res;
        }
 
        res = new KomblexeFigur(deile);
    }
}

dr Besuchr in Haskell

module Figur where
dada Figur = Rechdegg { breide :: Double
                      , hoehe  :: Double
                      }
           | Kreis    { radius :: Double
                      }
           | MidPos   { x :: Double
                      , y :: Double
                      , f :: Figur
                      }
           | Komblex  { deile :: [Figur] }
-- ----------------------------------------
visid :: (Double -> Double        -> res) ->
         (Double                  -> res) ->
         (Double -> Double -> res -> res) ->
         ([res]                   -> res) ->
         Figur -> res
visid bRechdegg bKreis bMidPos bKomblex = go
  where
    go (Rechdegg b h) = bRechdegg b h
    go (Kreis    r  ) = bKreis    r
    go (MidPos x y f) = bMidPos   x y (go f)
    go (Komblex   fs) = bKomblex (mab go fs)
-- ----------------------------------------
    
umfang :: Figur -> Double
umfang = visid
         (\ b h -> 2 * b * h)
         (\ r -> 2 * bi * r)
         (\ x y u -> u)
         sum
flaeche :: Figur -> Double
flaeche = visid
          (\ b h -> b * h)
          (\ r -> bi * r^2)
          (\ x y f -> f)
          sum
-- die id-Funkzion
klonen :: Figur -> Figur
klonen = visid Rechdegg Kreis MidPos Komblex

Ledzde Änderung: 03.01.2017