Klassen und Objekte (Dezember 2005)

Klassen und Objekte
Benjamin Gudehus
Dezember 2005

Einleitung
n Seminar:
– Beantwortung von Fragen
– Zahlreiche Zwischenaufgaben
n Klassen und Objekte
– Diagramme
– Schnittstellen und Sichtbarkeitsbereich
– Kommunikation zwischen Objekten
– Initialisierung durch Konstruktor

Übersicht

Klassen

Seminar
Objekte Erweiterung

Programmidee Klassen

n Programmname: Buchleser
n Objekttypen: Bücher und Leser
n Funktion: Gelesene Seiten eines Lesers
speichern
Buch: Leser:
n Titel n Name
n Seiten n Gelesene Seiten

Klassendiagramm Klassen

Aussage:
n Details über Daten- und
Verhaltensstruktur des Systems
Aufgabe:
n Zusammenstellung von Objekttypen,
deren Inhalte und Beziehungen

[nach M. Jeckle, 2004]


Klasse

Klassenname
Buch Leser


Klasse

Klassenname
Buch Leser

n Klassennamen beginnen stets mit einem
Großbuchstaben
n Benennung: Substantiv im Singular,
zusätzlich kann ein Adjektiv angegeben
werden
n Bsp. Seminar, öffentliche Ausschreibung


Buch Leser

Attribute m_titel m_name
m_seiten m_geles_seiten


Buch Leser


n Attribute sollten immer mit „m_“ beginnen
n Attribute kann man innerhalb jeder
Methode der Klasse mit ihrem Namen
ansprechen


Buch Leser


n Wir wollen die Attribute der Klasse von aussen nur
über ihre Methoden ansprechen.
n getAttributname() – Holt den Wert eines Attributs
n setAttributname() – Setzt den Wert eines Attributs


Buch Leser
m_titel m_name
setTitel(titel) setName(name)
Methoden getTitel() getName()
setSeiten(seiten) setGelesSeiten(seiten)
getSeiten() getGelesSeiten()


Buch Leser
m_titel m_name
Methoden getTitel() getName()

n Welche Grundtypen und Rückgabewerte
benutzen die Elemente der Klassen?


Buch Leser
m_titel : string m_name : string
m_seiten : int m_geles_seiten : int
setTitel(titel : string) : void setName(name : string) : void
getTitel() : string getName() : string
setSeiten(seiten : int) : void setGelesSeiten(seiten : int) : void
getSeiten() : int getGelesSeiten() : int

n WelcheGrundtypen und Rückgabewerte
benutzen die Elemente der Klassen?


Buch Leser
m_titel m_name
getTitel() getName()

Implementation verbergen Klassen

n Klassenersteller:
Erstellen neue Datentypen
n Anwendungsentwickler:
Benutzen die Datentypen in ihrer Anwendung

Ziele für den Klassenersteller :
n Bibliothek (Werkzeugkiste) erstellen
n Alles verbergen, was unnötig ist

[nach B. Eckel, 2000]


Buch Leser
m_titel m_name


Buch Leser
m_titel m_name

Sichtbarkeitsbereich einschränken


Buch Leser
- m_titel - m_name
- m_seiten - m_geles_seiten
+ setTitel(titel) + setName(name)
+ getTitel() + getName()
+ setSeiten(seiten) + setGelesSeiten(seiten)
+ getSeiten() + getGelesSeiten()

n „Private“-Elemente erhalten ein Minus (-)
n „Public“-Elemente erhalten ein Plus (+)


Buch Leser
- m_titel - m_name
Schnittstelle + setSeiten(seiten) + setGelesSeiten(seiten)

n „Private“-Elemente erhalten ein Minus (-)
n „Public“-Elemente erhalten ein Plus (+)


Assoziation

Buch Leser
- m_titel - m_name


Klasse
Assoziation
Klassenname
Buch Leser

Attribute - m_titel - m_name
Methoden + getTitel() + getName()

Fragen (1) Klassen

n Was macht ein „Klassenersteller“ und was
macht ein „Anwendungsentwickler“?
n Was ist bei der Namensgebung von
Klassen und Attributen zu beachten?
n Wie sollte man die Methode benennen, die
das Attribut „m_augenfarbe“ einer Klasse
„Mensch“ zurückgibt?

Projektverzeichnis Klassen

n Buch.h Deklaration (Prototyp)
n Buch.cpp Implementierung

n Leser.h Deklaration (Prototyp)
n Leser.cpp Implementierung

n Main.cpp Haupt-Programm

Projektverzeichnis Klassen

.dsw (Workspace)
.dsp (Projekt)

Fragen (2) Klassen

n Wasist eine Deklaration und was ist eine
Implementation?

Aufgaben (1) Klassen

Aufgabe 1 (5 Minuten Zeit):
Legen Sie ein neues Projekt namens
„buchleser“ an. Dort sollen die folgenden
Dateien enthalten sein:
n Leser.cpp, Leser.h
n Buch.cpp, Buch.h
n Main.cpp

// Leser.cpp: implementation of the Leser class.
// Klassen
//////////////////////////////////////////////////////////////////////
Deklaration / Prototyp
#include "Leser.h"
einbinden

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Konstruktor-Methode
Leser::Leser() implementieren
{

}
Leser::~Leser() Destruktor-Methode
{ implementieren

}

// Leser.h: interface for the Leser class.
// Klassen
//////////////////////////////////////////////////////////////////////

#ifndef _LESER_H_ Include-Wächter
#define _LESER_H_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class Leser Deklaration der Klasse
{
public:
Leser();
virtual ~Leser();

};

#endif // _LESER_H_


Passen Sie den Include-Wächter in den
Header-Dateien buch.h und leser.h an.

#ifndef _LESER_H_
#define _LESER_H_
…
#endif

Klassenprototyp (Buch.h) Klassen

class Buch
{
Buch
private:
- m_titel string m_titel;
- m_seiten
int m_seiten;
+ setTitel(titel)
+ getTitel()
+ setSeiten(seiten) public:
+ getSeiten() void setSeiten( int seiten );
int getSeiten( );

void setTitel( string titel );
string getTitel( );
};


Erstellen Sie die Klassenprototypen in den
Header-Dateien buch.h und leser.h.
Buch Leser
- m_titel - m_name

Implementierung (Buch.cpp) Klassen

#include "buch.h"
void Buch::setSeiten( int seiten ) {
Buch m_seiten = seiten;
- m_titel }
- m_seiten int Buch::getSeiten( ) {
+ setTitel(titel) return m_seiten;
+ getTitel()
+ setSeiten(seiten) }
+ getSeiten() void Buch::setTitel ( string titel ) {
m_titel = titel ;
}
string Buch::getTitel ( ) {
return m_titel ;
}


Schreiben Sie die Implementierung der
Klassen in buch.cpp und leser.cpp.
Buch Leser
- m_titel - m_name

Objekte erstellen (Main.cpp) Objekte

#include “leser.h"
#include "buch.h“
Leser
- m_name
- m_geles_seiten int main( )
+ setName(name) {
+ getName() // Leser erzeugen
+ setGelesSeiten(seiten)
+ getGelesSeiten() Leser leser1;
leser1.setName( "Gundalf" );
leser1.setGelesSeiten( 0 );
…

Objektdiagramm Objekte

Aussage:
n Zeigt Objekte, Werte und Beziehungs-
ausprägungen
Aufgabe:
n Darstellung einer Momentaufnahme des
Systems zur Laufzeit
[nach M. Jeckle, 2004]


Objektname Klassenname

leser1 : Leser
m_name = „Gundalf“
Werte m_geles_seiten = 0


Objektname Klassenname

leser1 : Leser
Werte m_geles_seiten = 0

n Objektnamen beginnen stets mit einem
Kleinbuchstaben

Objekte erstellen (Main.cpp) Objekte

// Bücher anlegen
Buch
Buch buch1;
- m_titel buch1.setTitel( "Raeuber
- m_seiten Hotzenplotz" );
+ setTitel(titel) buch1.setSeiten( 250 );
+ getTitel()
+ setSeiten(seiten)
+ getSeiten() Buch buch2;
buch2.setTitel( "Kater Mikesch"
);
buch2.setSeiten( 310 );


buch1 : Buch
m_titel = „Räuber Hotzenplotz“ leser1 : Leser
m_seiten = 250
m_geles_seiten = 0
buch2 : Buch
m_titel = „Kater Mikesch“
m_seiten = 310

Gekapseltes Objekt Objekte

buch1 : Buch hole
m_titel = „Räuber Hotzenplotz“ setze Titel Titel
m_seiten = 250
Titel:
„Räuber H.“
Buch Seiten:
- m_titel setze 250 hole
- m_seiten Seiten Seiten

+ setTitel(titel)
+ getTitel()
Zustand
+ setSeiten(seiten)
+ getSeiten()
Verhalten

Gekapseltes Objekt Objekte

buch1 : Buch
m_titel = „Räuber Hotzenplotz“
m_seiten = 250

Buch
- m_titel
- m_seiten
+ setTitel(titel)
+ getTitel()
+ setSeiten(seiten)
+ getSeiten()

[nach H. Balzert, 1999]

Klassen sind Schablonen Objekte

Stempel: setze
hole Objekt
Titel
des
Buch Titel
Titel:
„Räuber H. “ Types
Seiten:
hole
setze 250 hole buch1 : Buch
setze Titel Seiten Seiten
Titel

Typ oder Titel:

Klasse setze
Seiten:
hole
Seiten Seiten

hole
n Stichwort: setze
Titel
Titel:
Titel Objekt
des
„Ausprägung“ „Kater M.“

Seiten:
Types
310
Ein Exemplar
setze hole
n Seiten Seiten buch2 : Buch

Aufgaben (5) Objekte

Erzeugen Sie die Objekte wie beschrieben.

buch1 : Buch
m_seiten = 250
m_geles_seiten = 0
buch2 : Buch
m_seiten = 310

Funktion: Leser liest Buch Objekte

Buch
// Leser liest ein Buch
- m_titel
- m_seiten int buch_s =
+ setTitel(titel) buch1.getSeiten();
+ getTitel()
+ setSeiten(seiten)
+ getSeiten()

Leser
- m_name
- m_geles_seiten
+ setName(name)
+ getName()
+ getGelesSeiten()


buch1 : Buch
m_seiten = 250
m_geles_seiten = 0
buch2 : Buch
m_seiten = 310


Buch
- m_titel
+ setTitel(titel) buch1.getSeiten(); //250
+ getTitel()
+ setSeiten(seiten)
+ getSeiten()

Leser
- m_name
- m_geles_seiten
+ setName(name)
+ getName()
+ getGelesSeiten()


Buch
- m_titel
+ getTitel()
+ setSeiten(seiten) int bisher_s =
+ getSeiten() leser1.getGelesSeiten();
Leser
- m_name
- m_geles_seiten
+ setName(name)
+ getName()
+ getGelesSeiten()


Buch
- m_titel
+ getTitel()
+ getSeiten() leser1.getGelesSeiten(); //0
Leser
- m_name
- m_geles_seiten
+ setName(name)
+ getName()
+ getGelesSeiten()


Buch
- m_titel
+ getTitel()
+ getSeiten() leser1.getGelesSeiten(); //0
Leser int aktuell_s =
- m_name bisher_s + buch_s; //0+250
- m_geles_seiten
leser1.setGelesSeiten(
+ setName(name)
+ getName() aktuell_s); //250
+ getGelesSeiten()


buch1 : Buch
m_seiten = 250
m_geles_seiten = 250
buch2 : Buch
m_seiten = 310

Aufgaben (6) Objekte

Erweitern Sie das Programm entsprechend.

buch1 : Buch
m_seiten = 250
buch2 : Buch
m_seiten = 310

Konstruktor Erweiterung

int main( )
Leser {
- m_name // Leser erzeugen und
- m_geles_seiten
initialisieren
+ setName(name)
+ getName() Leser leser1;
+ getGelesSeiten() leser1.setName( "Gundalf “ );
…
}


int main( )
Leser {
- m_geles_seiten
initialisieren
+ Leser()
+ setName(name) Leser leser1();
+ getName()
+ setGelesSeiten(seiten) leser1.setName( "Gundalf “ );
+ getGelesSeiten()
…
}


int main( )
Leser {
- m_geles_seiten
initialisieren
+ Leser(name, seiten)
+ setName(name) Leser leser1("Gundalf ", 0 );
+ getName()
+ setGelesSeiten(seiten) leser1.setName( "Gundalf “ );
+ getGelesSeiten()
…
}


int main( )
Leser {
- m_geles_seiten
initialisieren
+ setName(name) Leser leser1("Gundalf ", 0 );
+ getName()
+ getGelesSeiten()

…
}


Leser::Leser( string name,
int seiten )
Leser
- m_name {
- m_geles_seiten
m_name = name;
+ setName(name) m_seiten = seiten;
+ getName()
+ setGelesSeiten(seiten) }
+ getGelesSeiten()

Aufgaben (7) Erweiterung


Leser Buch
- m_name - m_titel
- m_geles_seiten - m_seiten
+ Leser(name, seiten) + Buch(titel, seiten)
+ setName(name) + setTitel(titel)
+ getName() + getTitel()
+ setGelesSeiten(seiten) + setSeiten(seiten)
+ getGelesSeiten() + getSeiten()

Funktion: Leser liest Buch Erweiterung

Leser int buch_s =
- m_name buch1.getSeiten();
- m_geles_seiten
int bisher_s =
+ setName(name) leser1.getGelesSeiten();
+ getName()
+ setGelesSeiten(seiten) int aktuell_s =
+ getGelesSeiten() bisher_s + buch_s;
aktuell_s);


Leser int buch_s =
- m_geles_seiten
int bisher_s =
+ setName(name) leser1.getGelesSeiten();
+ getName()
+ setGelesSeiten(seiten) int aktuell_s =
+ getGelesSeiten() bisher_s + buch_s;
+ leseBuch(seiten)
aktuell_s);


Leser int buch_s =
- m_geles_seiten
leser1.leseBuch(buch_s);
+ setName(name)
+ getName()
+ getGelesSeiten()
+ leseBuch(seiten)


void Leser::leseBuch( int seiten)
Leser {
- m_name geles_seiten += seiten;
- m_geles_seiten
}
+ setName(name)
+ getName()
+ getGelesSeiten()
+ leseBuch(seiten)

Aufgaben (8) Erweiterung


Main.cpp: Leser.cpp:

// Leser liest ein Buch void Leser::leseBuch( int seiten)
int buch_s = {
buch1.getSeiten(); geles_seiten += seiten;
}
leser1.leseBuch(buch_s);


void Leser::leseBuch( int seiten)
Leser {
- m_name geles_seiten += seiten;
- m_geles_seiten
}
+ setName(name) void Leser::leseBuch(Buch buch)
+ getName()
+ setGelesSeiten(seiten) {
+ getGelesSeiten()
+ leseBuch(seiten) geles_seiten +=
+ leseBuch(buch) buch.getSeiten()
}

Zusammenfassung
n Klassen entwerfen und implementieren
n Klassen- und Objektdiagramme
n Zugriffsbeschränkung und Schnittstellen
(Geheimnisprinzip)
n Get-Set als Lese -Schreib-Schnittstelle
n Hilfs-Funktion (Modell brechen)
n Konstruktor für die Initialisierung

Klassendiagramm
Klasse
Assoziation
Klassenname
Buch Leser

Attribute - m_titel - m_name
+ Buch(titel, seiten) + Leser(name, seiten)
Methoden + setTitel(titel) + setName(name)
+ leseBuch(seiten)
+ leseBuch(buch)

Objektdiagramm
Objektname

buch1 : Buch Klassenname
m_titel = „Räuber Hotzenplotz“
m_seiten = 250 leser1 : Leser
buch2 : Buch
m_seiten = 310 Werte

Objekt

Literatur
n Helmut Balzert: Lehrbuch Grundlagen der
Informatik, Spektrum Akademischer
Verlag, 1999
n Bruce Eckel: Thinking in C++, Second
Edition, MindView, 2000
n Mario Jeckle u. a.: UML 2 Tutorial, 2003

Damit betrachte ich
diese Präsentation
als beendet!

Klassen und Objekte (Dezember 2005)

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (17)

Klassen und Objekte (Dezember 2005)