kramann.info
© Guido Kramann

Login: Passwort:










Informatik3
1 Vom_struct_zur_Klasse
..1.1 Vom_struct_zur_Klasse
..1.2 struct_Programm
..1.3 Klassen_Programm
..1.4 Offene_Fragen
..1.5 Historie
..1.6 Objektabstraktion
..1.7 OO_Kundenverwaltung
..1.8 Objektfaehigkeiten
..1.9 Formatierung
..1.10 Motivation
..1.11 Uebung1
..1.12 Uebung2
2 UML
..2.1 Volumenberechnung
..2.2 UML_Klassendiagramm
..2.3 Konstruktor
..2.4 Statische_Variable
3 Strings
..3.1 Klassenbibliotheken
..3.2 stringUML
..3.3 Uebung3
4 Initialisierungen
4 bluej
5 Zeiger_und_Arrays
..5.1 Zeiger
..5.2 Zeiger_und_Funktion
..5.3 Uebung4
6 Vererbung
..6.1 MesswerteUML
..6.2 MesswerteProgramm
..6.3 VererbungsProgramm
..6.4 Vector
..6.5 Uebung
7 Modifikatoren
..7.1 public_Vererbung
..7.2 protected_Vererbung
8 Listen_und_Templates
..8.1 Containertypen
....8.1.1 ListeUML
....8.1.2 ListeProgramm
..8.2 Templates
....8.2.1 Listentemplate
....8.2.2 STLvectorTemplate
..8.3 Uebung5
..8.4 Uebung6
..8.5 Uebung7
9 Java
..9.1 Uebung
..9.2 GettingStarted
..9.3 Animation
..9.4 Hybrid
..9.5 Threads
10 Delegation
11 LayoutProjekt
12 Fenster
13 Uebung
14 Zwischenprojekt
..14.1 Befehle
..14.2 Planung
..14.3 JNI
..14.4 JNIumsetzen
..14.5 Anwendungsklasse
..14.6 GUI01
..14.7 GUI02
15 Rasterlayout
..15.1 Bilder_Packages
..15.2 interfaces
..15.3 ArrayList
..15.4 clone
..15.5 Uebung
16 Nuetzliches
..16.1 Threads
..16.2 Animation
..16.3 RungeKutta
..16.4 Loesungsansatz
..16.5 Internetprogrammierung
....16.5.1 Codegenerierung
....16.5.2 PHP_Programmierung
....16.5.3 PHP_OOP
....16.5.4 Java
17 Algorithmen
..17.1 RungeKutta
..17.2 Loesungsansatz
..17.3 Evoopt
..17.4 Uebung12
..17.5 Uebung8_2014
..17.6 Ausdruecke
18 Uebung10
19 UML_ALT
..19.1 Flaechenberechnung
..19.2 UML_Flaechenberechnung
..19.3 Implementierung
..19.4 ListeUML
..19.5 ListenImplementierung
..19.6 Anwendung

19.3 Objektorientierte Programmlösung

Hier nun die Umsetzung des zuvor mit UML-Klassendiagrammen entworfenen Programms. Es ist wichtig dabei zu sehen, dass die Art und Weise wie Objekte aus den Klassen erzeugt werden und wie dann der Aufruf erfolgt, der zum Berechnen des Gesamtschwerpunktes führt und auch wie die Methoden der Objekte implementiert werden sollen, in dem UML-Entwurf nicht dargestellt wurde und erst hier in der main-Methode entworfen und umgesetzt wird.

Übersichtlichkeit

Andererseits sieht man aber auch, dass durch die hierarchische Anordnung elementarer Methoden über die einzelnen Klassen hinweg, das Hinschreiben der Berechnungen einfach und übersichtlich wird.

Wiederverwendbarkeit

Etwas, das in der Softwareentwicklung sehr zur Kostenersparnis beitragen kann, ist die Wieerverwendbarkeit von Programmteilen. Dies ist aufgrund der Kapselung der Klassen in der OOP viel stärker unterstützt, als in der prozessuralen Programmierung. Die Klasse Vektor in unserem Beispiel kann leicht in einem völlig anderen Zusammenhang verwendet werden, z.B. wenn es darum geht Vielecke auf einer Ebene vorauszuberechnen und zu zeichnen.

#include <iostream>
#define MAXRECHTECK 100;

using namespace std;

class Vektor
{
    public:
        double x;
        double y;

        Vektor()
        {
            x = 0.0;
            y = 0.0;
        }
        Vektor(double inx, double iny)
        {
            x = inx;
            y = iny;
        }
        void malSkalar(double skalar)
        {
            x*=skalar;
            y*=skalar;
        }
        void plusVektor(Vektor vek)
        {
            x+=vek.x;
            y+=vek.y;
        }
        void minusVektor(Vektor vek)
        {
            x-=vek.x;
            y-=vek.y;
        }
};

class Rechteck
{
    public:
        Rechteck()
        {
        }
        Rechteck(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
        {
            ort1.x = x1;
            ort1.y = y1;
            ort2.x = x2;
            ort2.y = y2;
            ort3.x = x3;
            ort3.y = y3;
            ort4.x = x4;
            ort4.y = y4;       
        }
        Vektor getSchwerpunkt()
        {
            Vektor ergebnis;

            ergebnis.plusVektor(ort1);
            ergebnis.plusVektor(ort3);
            ergebnis.malSkalar(0.5);

            return ergebnis;
        }
        double getFlaeche()
        {
            Vektor ergebnis;
            ergebnis.plusVektor(ort3);
            ergebnis.minusVektor(ort1);
            return ergebnis.x*ergebnis.y;
        }
        
    private:
        Vektor  ort1,ort2,ort3,ort4;
        double flaeche;
};

class Werkstueck
{
    private:
        int anzahl;
        Rechteck re[100];
    public:
        Werkstueck()
        {
            anzahl = 0;
        }
        void addRechteck(Rechteck r)
        {
            re[anzahl] = r;
            anzahl++;
        }

        Vektor getSchwerpunkt()
        {
            Vektor sp;
            Vektor merker;
            double nenner;

            for(int i=0;i<anzahl;i++)
            {
                merker = re[i].getSchwerpunkt();
                merker.malSkalar(re[i].getFlaeche());
                sp.plusVektor(merker);
                nenner+=re[i].getFlaeche();
            }    
            sp.malSkalar(1.0/nenner);
            return sp;
        }        
};

int main(void)
{
    Werkstueck meinWerkstueck;

    Rechteck r1(0.0,2.0,4.0,2.0,4.0,5.0,0.0,5.0);
    Rechteck r2(2.0,0.0,4.0,0.0,4.0,2.0,2.0,2.0);
    Rechteck r3(4.0,2.0,7.0,2.0,7.0,3.0,4.0,3.0);
    Rechteck r4(4.0,3.0,6.0,3.0,6.0,7.0,4.0,7.0);
    Rechteck r5(4.0,7.0,7.0,7.0,7.0,8.0,4.0,8.0);

    meinWerkstueck.addRechteck(r1);    
    meinWerkstueck.addRechteck(r2);    
    meinWerkstueck.addRechteck(r3);    
    meinWerkstueck.addRechteck(r4);    
    meinWerkstueck.addRechteck(r5);    

    Vektor schwerpunkt = meinWerkstueck.getSchwerpunkt();

    cout<<"Der Schwerpunkt des Werkstuecks liegt bei xs="<<schwerpunkt.x<<" ys="<<schwerpunkt.y<<endl;

    return 1;
}
 

Code 19.3-1: Objektorientiertes Programm zur Lösung des Schwerpunkt-Problems schwerpunkt_oop.cpp