Powerpoint-Präsentation

Implementierung
objektorientierter Modelle
Klaus Becker
2009
2
mit Python, Delphi, Java
3
Teil 1
Python - Würfel
4
Beispiel 1: Würfel
Ziel ist es, ein einfaches System zur Simulation eines Würfels zu entwickeln.
Datenmodell
5
Das Datenmodell ist hier sehr einfach und besteht nur aus einem Objekt einer Klasse Wuerfel.
Klasse
Objekt
Miniwelt
Datenmodell
6
Implementierung des Datenmodells
from random import randint
class Wuerfel(object):
def __init__(self):
self.augen = 1
wuerfel.py
Konstruktor
Attribut
def werfen(self):
self.augen = randint(1, 6)
Methode
def getAugen(self):
return self.augen
Methode
Test des Datenmodells
7
# Datenmodell
from wuerfel import *
wuerfel = Wuerfel()
# Test
for i in range(10):
wuerfel.werfen()
print(wuerfel.getAugen())
Erzeugung der Objekte
Objekte in Aktion
test_wuerfel.py
Datenmodell
8
Benutzeroberfläche zum Datenmodell
from tkinter import *
class GUIWuerfel(object):
def __init__(self, wuerfel):
# Referenzattribute zum Datenmodell
Datenmodell-Objekte
self.wuerfel = wuerfel
# Erzeugung des Fensters
self.fenster = Tk()
GUI-Objekte
self.fenster.title("Würfel")
self.fenster.geometry('120x110')
# Anzeige des Würfels
self.labelWuerfel = Label(master=self.fenster, text="1", background="#FBD975")
self.labelWuerfel.place(x=45, y=40, width=30, height=30)
# Button zum Auswerten
self.buttonWuerfel = Button(master=self.fenster, text="Würfel werfen", \
command=self.Button_Wuerfel_Click)
self.buttonWuerfel.place(x=10, y=80, width=100, height=20)
def Button_Wuerfel_Click(self):
Ereignisverarbeitung
# Verarbeitung der Daten
self.wuerfel.werfen()
# Anzeige der Daten
self.labelWuerfel.config(text=str(self.wuerfel.getAugen()))
guiwuerfel.py
9
Benutzeroberfläche zum Datenmodell
# Datenmodell
from wuerfel import *
wuerfel = Wuerfel()
# GUI
from guiwuerfel import *
guiwuerfel = GUIWuerfel(wuerfel)
guiwuerfel.fenster.mainloop()
Datenmodell-Objekte
GUI-Verwaltungsobjekt
test_guiwuerfel.py
10
Teil 2
Delphi - Würfel
11
Beispiel 1: Würfel
Ziel ist es, ein einfaches System zur Simulation eines Würfels zu entwickeln.
Datenmodell
12
Das Datenmodell ist hier sehr einfach und besteht nur aus einem Objekt einer Klasse Wuerfel.
Klasse
Objekt
Miniwelt
Datenmodell
13
Implementierung des Datenmodells
Vorbereitung:
Neuer Ordner (z.B. "WuerfelOhneGUI")
Datei -> Neu -> Unit
Unit im neuen Ordner abspeichern (z.B. "uWuerfel.pas")
14
Implementierung des Datenmodells
unit uWuerfel;
...
interface
implementation
type
TWuerfel = class
private
Deklaration
augen: integer;
der Attribute
public
und Methoden
constructor create;
procedure werfen;
function getAugen: integer;
end;
...
constructor TWuerfel.create;
begin
augen := 1;
randomize;
end;
Klassen werden als Module
(Programmeinheiten) implementiert, die in
Delphi in zwei Teilen beschrieben werden:
function TWuerfel.getAugen: integer;
begin
result := augen;
end;
Schnittstellenvereinbarung: Deklaration der
Attribute und Methoden
Implementierungsteil: Implementierung der
Methoden
Implementierung
der Attribute und
Methoden
procedure TWuerfel.werfen;
begin
augen := random(6)+1;
end;
uWuerfel.pas
15
Test des Datenmodells
Vorbereitung:
Datei -> Neu -> Konsolen-Anwendung
Projekt im bereits bestehenden ("WuerfelOhneGUI") abspeichern (z.B. "ProjectWuerfel.dpr")
Projekt -> Dem Projekt hinzufügen -> "uWuerfel.pas"
Test des Datenmodells
16
program ProjectWuerfel;
{$APPTYPE CONSOLE}
uses
sysutils,
uWuerfel in 'uWuerfel.pas';
var
wuerfel: Twuerfel;
i: integer;
begin
// Datenmodell
wuerfel := TWuerfel.create;
// Test
for i := 0 to 9 do
begin
wuerfel.werfen;
writeln(wuerfel.getAugen);
end;
readln;
end.
ProjectWuerfel.dpr
Erzeugung der Objekte
Objekte in Aktion
Datenmodell
17
Benutzeroberfläche zum Datenmodell
Vorbereitung:
Neuer Ordner (z.B. "WuerfelMitGUI")
Datei -> Neu -> Anwendung
Projekt im neuen Ordner
("WuerfelMitGUI") abspeichern (z.B.
"ProjectWuerfel.dpr")
Unit "Unit1.pas" umbenennen (z.B.
"uGUI.pas")
Projekt -> Dem Projekt hinzufügen ->
"uWuerfel.pas"
18
Benutzeroberfläche zum Datenmodell
unit uGUI;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, uWuerfel;
Einbindung der Datenmodell-Unit
type
TFGUIWuerfel = class(TForm)
labelWuerfel: TLabel;
buttonWuerfel: TButton;
procedure buttonWuerfelClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private-Deklarationen }
Deklaration des Referenzattributs
wuerfel: TWuerfel;
public
{ Public-Deklarationen }
end;
var
FGUIWuerfel: TFGUIWuerfel;
uGUI.pas
...
19
Benutzeroberfläche zum Datenmodell
...
implementation
{$R *.DFM}
procedure TFGUIWuerfel.buttonWuerfelClick(Sender: TObject);
begin
wuerfel.werfen;
labelWuerfel.Caption := IntToStr(wuerfel.getAugen);
end;
Implementierung der
Ereignisverarbeitung
procedure TFGUIWuerfel.FormCreate(Sender: TObject);
begin
wuerfel := TWuerfel.create;
Erzeugung der
end;
Datenmodell-Objekte
end.
uGUI.pas
20
Benutzeroberfläche zum Datenmodell
...
type
TFGUIWuerfel = class(TForm)
labelWuerfel: TLabel;
buttonWuerfel: TButton;
procedure buttonWuerfelClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private-Deklarationen }
wuerfel: TWuerfel;
public
{ Public-Deklarationen }
end;
...
procedure TFGUIWuerfel.FormCreate(Sender: TObject);
begin
wuerfel := TWuerfel.create;
end;
...
uGUI.pas
21
Teil 3
Java - Würfel
22
Beispiel 1: Würfel
Ziel ist es, ein einfaches System zur Simulation eines Würfels zu entwickeln.
Datenmodell
23
Das Datenmodell ist hier sehr einfach und besteht nur aus einem Objekt einer Klasse Wuerfel.
Klasse
Objekt
Miniwelt
Datenmodell
24
Implementierung des Datenmodells
Vorbereitung:
Neuer Ordner (z.B. "WuerfelOhneGUI")
Datei -> Neu -> Java
Datei im neuen Ordner abspeichern: "Wuerfel.java"
25
Implementierung des Datenmodells
public class Wuerfel
{
// Anfang Attribute
private int augen;
// Ende Attribute
public Wuerfel()
{
}
// Anfang Methoden
Wuerfel.java
Attribute
Konstruktor
Methoden
public void werfen()
{
augen = (int)(Math.random() * 6 + 1);
}
}
public int getAugen()
{
return augen;
}
// Ende Methoden
Beachte:
Der Dateiname (hier: „Wuerfel.java“) muss
mit dem Klassennamen (hier: „Wuerfel“)
übereinstimmen.
Beachte:
In einer Datei kann daher auch nur eine
Klasse implementiert werden.
26
Test des Datenmodells
Vorbereitung:
Datei -> Neu -> Console
Datei im bereits bestehenden ("WuerfelOhneGUI") abspeichern (z.B. "TestWuerfel.java")
Test des Datenmodells
27
public class TestWuerfel {
// Anfang Attribute
// Ende Attribute
}
// Anfang Methoden
public static void main(String[] args) {
Erzeugung
// Datenmodell
der Objekte
Wuerfel wuerfel = new Wuerfel();
// Test
Objekte in
for (int i = 0; i < 10; i = i + 1) {
Aktion
wuerfel.werfen();
System.out.println(wuerfel.getAugen());
};
}
// Ende Methoden
TestWuerfel.java
Datenmodell
28
Benutzeroberfläche zum Datenmodell
Vorbereitung:
Neuer Ordner (z.B. "WuerfelMitGUI")
Datei -> Neu -> Frame
Datei im neuen Ordner ("WuerfelMitGUI") abspeichern (z.B. „GUI.java")
29
Benutzeroberfläche zum Datenmodell
import java.awt.*;
import java.awt.event.*;
Erzeugung der GUIObjekte
public class GUI extends Frame {
// Anfang Attribute
private Label labelWuerfel = new Label();
private Button buttonWuerfel = new Button();
private Wuerfel wuerfel = new Wuerfel();
// Ende Attribute
Erzeugung der
Datenmodell-Objekte
public GUI(String title) {
// Frame-Initialisierung
super(title);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent evt) { System.exit(0); }
});
int frameWidth = 186;
Konfiguration der GUI-Objekte
int frameHeight = 198;
setSize(frameWidth, frameHeight);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
int x = (d.width - getSize().width) / 2;
int y = (d.height - getSize().height) / 2;
GUI.java
…
30
Benutzeroberfläche zum Datenmodell
…
// Anfang Methoden
public void buttonWuerfel_ActionPerformed(ActionEvent evt) {
// Verarbeitung der Daten
Datenmodell-Objekt in Aktion
wuerfel.werfen();
// Anzeige der Daten
labelWuerfel.setText(Integer.toString(wuerfel.getAugen()));
}
// Ende Methoden
}
public static void main(String[] args) {
new GUI("GUI");
Erzeugung des GUIVerwaltungsobjekts
}
GUI.java
31
Benutzeroberfläche zum Datenmodell
...
public class GUI extends Frame {
// Anfang Attribute
private Label labelWuerfel = new Label();
private Button buttonWuerfel = new Button();
private Wuerfel wuerfel = new Wuerfel();
// Ende Attribute
...
public static void main(String[] args) {
new GUI("GUI");
...
GUI.java
32
Teil 4
Python - chuck a luck
33
Beispiel 2: chuck a luck
Ziel ist es, ein System zur Simulation des Spiels "chuck a luck" zu entwickeln.
Datenmodell
34
Das Datenmodell ist komplexer und besteht aus Objekten, die in Beziehung stehen.
1$ 1$
1$ 1$ 1$
1$ 1$ 1$ 1$
Einsatz zahlen
Spielzahl setzen
Würfel werfen
Gewinn auszahlen
Miniwelt
1
4
2
5
3
1$
6
Datenmodell
35
Implementierung des Datenmodells
from random import randint
class Konto(object):
def __init__(self, betrag):
self.stand = betrag
def einzahlen(self, betrag):
self.stand = self.stand + betrag
def abheben(self, betrag):
self.stand = self.stand - betrag
...
class Spiel(object):
def __init__(self):
self.konto = Konto(100)
self.spielzahl = Spielzahl()
self.wuerfelA = Wuerfel()
self.wuerfelB = Wuerfel()
self.wuerfelC = Wuerfel()
...
model_chuckaluck.py
36
Test des Datenmodells
#----------------------------------------------------------# Datenmodell
#----------------------------------------------------------Erzeugung der
from model_chuckaluck import * Datenmodell-Objekte
spiel = Spiel()
#----------------------------------------------------------# Test
#----------------------------------------------------------# Durchführung eines Spiels
spiel.einsatzZahlen()
spiel.spielzahlSetzen(5)
spiel.wuerfelWerfen()
Objekte in Aktion
spiel.gewinnAuszahlen()
# Ausgabe der Spiel
print("Würfel A:", spiel.wuerfelA.augen)
print("Würfel B:", spiel.wuerfelB.augen)
print("Würfel C:", spiel.wuerfelC.augen)
print("Konto:", spiel.konto.stand)
Datenmodell
test_model_chuckaluck.py
Benutzeroberfläche zum Datenmodell
37
from tkinter import *
Datenmodellclass GUIChuckALuck(object):
Objekte
def __init__(self, spiel):
# Referenzattribute zum Datenmodell
self.spiel = spiel
# Erzeugung des Fensters
self.tkFenster = Tk()
self.tkFenster.title("chuck a luck")
self.tkFenster.geometry('350x145')
# Rahmen Überschrift
...
GUI-Objekte
def Button_Einsatz_Click(self):
Ereignisverarbeitung
# Verarbeitung der Daten
self.spiel.einsatzZahlen()
# Anzeige der Daten
self.labelKonto.config(text=str(self.spiel.konto.stand))
...
gui_chuckaluck.py
38
Benutzeroberfläche zum Datenmodell
#----------------------------------------------------------# Datenmodell
#----------------------------------------------------------from model_chuckaluck import *
spiel = Spiel()
#----------------------------------------------------------# GUI-Objekt
#----------------------------------------------------------from gui_chuckaluck import *
guichuckaluck = GUIChuckALuck(spiel)
guichuckaluck.tkFenster.mainloop()
test_gui_chuckaluck.py
39
Teil 5
Delphi - chuck a luck
40
Beispiel 2: chuck a luck
Ziel ist es, ein einfaches System zur Simulation eines Würfels zu entwickeln.
Datenmodell
41
Das Datenmodell ist komplexer und besteht aus Objekten, die in Beziehung stehen.
1$ 1$
1$ 1$ 1$
1$ 1$ 1$ 1$
Einsatz zahlen
Spielzahl setzen
Würfel werfen
Gewinn auszahlen
Miniwelt
1
4
2
5
3
1$
6
Datenmodell
42
Implementierung des Datenmodells
unit uKonto;
...
interface
procedure TKonto.einzahlen(betrag: integer);
begin
stand := stand + betrag;
end;
type
Deklaration
TKonto = class
der Attribute
private
und Methoden
stand: integer;
public
constructor create(betrag: integer);
procedure einzahlen(betrag: integer);
procedure abheben(betrag: integer);
function getStand: integer;
end;
implementation
constructor TKonto.create(betrag: integer);
begin
stand := betrag;
end;
...
procedure TKonto.abheben(betrag: integer);
begin
stand := stand - betrag;
end;
function TKonto.getStand: integer;
begin
result := stand;
end;
Implementierung
der Attribute und
end.
Methoden
uKonto.pas
43
Implementierung des Datenmodells
unit uSpiel;
...
interface
implementation
uses uWuerfel, uKonto, uSpielzahl;
constructor TSpiel.create();
begin
konto := TKonto.create(100);
wuerfelA := TWuerfel.create;
wuerfelB := TWuerfel.create;
wuerfelC := TWuerfel.create;
spielzahl := TSpielzahl.create;
end;
type
Deklaration
TSpiel = class
der Attribute
private
und Methoden
public
spielzahl: TSpielzahl;
konto: TKonto;
wuerfelA: TWuerfel;
wuerfelB: TWuerfel;
wuerfelC: TWuerfel;
constructor create();
procedure einsatzZahlen;
procedure spielzahlSetzen(zahl: integer);
procedure wuerfelWerfen;
procedure gewinnAuszahlen;
end;
...
Implementierung
der Attribute und
Methoden
procedure TSpiel.einsatzZahlen();
begin
konto.abheben(1);
end;
...
uSpiel.pas
44
Test des Datenmodells
program ProjectChuckALuck;
{$APPTYPE CONSOLE}
uses
sysutils,
uSpiel in 'uSpiel.pas';
var
spiel: TSpiel;
begin
Erzeugung der Objekte
// Erzeugung der Datenmodell-Objekte
spiel := TSpiel.create;
// Durchführung eines Spiels
Objekte in Aktion
spiel.einsatzZahlen;
spiel.spielzahlSetzen(5);
spiel.wuerfelWerfen;
spiel.gewinnAuszahlen;
// Ausgabe der Spieldaten
writeln('Wuerfel A:', spiel.wuerfelA.getAugen);
writeln('Wuerfel B:', spiel.wuerfelB.getAugen);
writeln('Wuerfel C:', spiel.wuerfelC.getAugen);
writeln('Konto:', spiel.konto.getStand);
readln;
ProjectChuckALuck.dpr
end.
45
Benutzeroberfläche zum Datenmodell
unit uGUI;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, ExtCtrls, uSpiel;
Einbindung
type
der
TGUI = class(TForm)
DatenmodellPTitel: TPanel;
Unit
...
private
{ Private-Deklarationen }
spiel: TSpiel;
public
{ Public-Deklarationen }
end;
Deklaration des Referenzattributs
var
GUI: TGUI;
...
uGUI.pas
46
Benutzeroberfläche zum Datenmodell
...
implementation
{$R *.DFM}
Erzeugung der
Datenmodell-Objekte
procedure TGUI.FormCreate(Sender: TObject);
begin
spiel := TSpiel.create;
labelKonto.Caption := IntToStr(spiel.konto.getStand)
end;
Implementierung der
Ereignisverarbeitung
procedure TGUI.ButtonEinsatzClick(Sender: TObject);
begin
spiel.einsatzZahlen;
labelKonto.Caption := IntToStr(spiel.konto.getStand);
end;
...
end.
uGUI.pas
47
Teil 6
Java - chuck a luck
48
Beispiel 2: chuck a luck
Ziel ist es, ein einfaches System zur Simulation eines Würfels zu entwickeln.
Datenmodell
49
Das Datenmodell ist komplexer und besteht aus Objekten, die in Beziehung stehen.
1$ 1$
1$ 1$ 1$
1$ 1$ 1$ 1$
Einsatz zahlen
Spielzahl setzen
Würfel werfen
Gewinn auszahlen
Miniwelt
1
4
2
5
3
1$
6
Datenmodell
50
Implementierung des Datenmodells
public class Konto
{
// Anfang Attribute
private int stand = 0;
// Ende Attribute
...
// Anfang Methoden
public void einzahlen(int betrag)
{
stand = stand + betrag;
}
public Konto(int betrag)
{
stand = betrag;
}
public void abheben(int betrag)
{
stand = stand - betrag;
}
…
public int getStand()
{
return stand;
}
}
// Ende Methoden
Konto.java
51
Implementierung des Datenmodells
public class Spiel
{
// Anfang Attribute
public Wuerfel wuerfelA, wuerfelB, wuerfelC;
public Konto konto;
public Spielzahl spielzahl;
// Ende Attribute
public Spiel()
{
wuerfelA = new Wuerfel();
wuerfelB = new Wuerfel();
wuerfelC = new Wuerfel();
konto
= new Konto(100);
spielzahl = new Spielzahl();
}
…
...
// Anfang Methoden
public void einsatzZahlen()
{
konto.abheben(1);
}
...
Spiel.java
52
Test des Datenmodells
public class TestCuckALuck {
}
public static void main(String[] args) {
// Erzeugung der Datenmodell-Objekte
Erzeugung
Spiel spiel = new Spiel();
der Objekte
// Durchführung eines Spiels
spiel.einsatzZahlen();
Objekte in
spiel.spielzahlSetzen(5);
Aktion
spiel.wuerfelWerfen();
spiel.gewinnAuszahlen();
// Ausgabe der Spieldaten
System.out.println("Würfel A: " + Integer.toString(spiel.wuerfelA.getAugen()));
System.out.println("Würfel B: " + Integer.toString(spiel.wuerfelB.getAugen()));
System.out.println("Würfel C: " + Integer.toString(spiel.wuerfelC.getAugen()));
System.out.println("Konto: " + Integer.toString(spiel.konto.getStand()));
}
TestChuckALuck.java
53
Benutzeroberfläche zum Datenmodell
import java.awt.*;
import java.awt.event.*;
public class GUI extends Frame {
public class GUI extends Frame {
// Anfang Attribute
private Label labelUeberschrift = new Label();
Erzeugung der GUIprivate Panel panelKonto = new Panel(null);
Objekte
private Label labelUeberschriftKonto = new Label();
private Button buttonEinsatz = new Button();
private Label labelKonto = new Label();
private Panel panelZahl = new Panel(null);
private CheckboxGroup checkboxGroup1 = new CheckboxGroup();
…
private Panel panelWuerfel = new Panel(null);
private Label labelUeberschriftWuerfel = new Label();
private Button buttonWuerfel = new Button();
private Label labelWuerfelA = new Label();
private Label labelWuerfelB = new Label();
private Label labelWuerfelC = new Label();
private Spiel spiel = new Spiel();
Erzeugung der
// Ende Attribute
GUI.java
Datenmodell-Objekte
…
54
Benutzeroberfläche zum Datenmodell
…
// Anfang Methoden
public String getSelectedRadioButton(CheckboxGroup cg) {
return cg.getSelectedCheckbox().getLabel();
}
public void buttonGewinnAuszahlen_ActionPerformed(ActionEvent evt) {
int gewaehltezahl = Integer.parseInt(this.getSelectedRadioButton(this.checkboxGroup1));
spiel.spielzahlSetzen(gewaehltezahl);
Datenmodell-Objekt in Aktion
spiel.gewinnAuszahlen();
labelKonto.setText(Integer.toString(spiel.konto.getStand()));
}
…
// Ende Methoden
public static void main(String[] args) {
new GUI("GUI");
}
Erzeugung des GUI}
Verwaltungsobjekts
GUI.java
55
Teil 7
Python - Bank
56
Beispiel 3: Bank
Ziel ist es, ein einfaches System zur Verwaltung von Bankkonten zu entwickeln.
57
Datenmodell
Das Datenmodell ist komplexer und besteht aus Objekten, die in Beziehung stehen.
S
Konto-Nr.234126
Blatt 342
Miniwelt
Datenmodell
58
Implementierung des Datenmodells
class Konto(object):
def __init__(self, nummer):
self.nr = nummer
self.stand = 0.0
def einzahlen(self, betrag):
self.stand = self.stand + betrag
def auszahlen(self, betrag):
self.stand = self.stand - betrag
def getNr(self):
return self.nr
def getStand(self):
return self.stand
...
class Bank(object):
def __init__(self):
self.maxKontoNr = -1
self.konten = []
def kontoErzeugen(self, nummer):
self.maxKontoNr = self.maxKontoNr + 1
konto = Konto(self.maxKontoNr)
self.konten = self.konten + [konto]
def getKonto(self, nummer):
return self.konten[nummer]
datenmodell_bank.py
...
datenmodell_bank.py
59
Test des Datenmodells
from datenmodell_bank import *
bank = Bank()
# Konten erzeugen
for i in range(10):
bank.kontoErzeugen(i)
# Einzahlungen und Auszahlungen
bank.getKonto(4).einzahlen(100.0)
bank.getKonto(4).auszahlen(40.0)
bank.getKonto(7).einzahlen(40.0)
# Ausgabe von Daten
Erzeugung der Objekte
for i in range(10):
print('Konto mit Nummer' + str(i) + ': ' + str(bank.getKonto(i).getStand()))
Objekte in Aktion
ProjectBank.dpr
60
Benutzeroberfläche zum Datenmodell
from tkinter import *
Datenmodellclass GUIBank():
Objekte
def __init__(self, bank):
# Referenzattribute zum Datenmodell
self.bank = bank
# Erzeugung des Fensters
self.fenster = Tk()
self.fenster.title("Bank")
GUI-Objekte
self.fenster.geometry('240x165')
# Rahmen PIN
self.rahmenKonto = Frame(master=self.fenster, background="#BDE2F3")
self.rahmenKonto.place(x=10, y=40, width=220, height=85)
# Label mit Aufschrift Konto
Ereignisverarbeitung
self.labelKonto = Label(master=self.rahmenKonto,
background="gray", text="Konto")
self.labelKonto.place(x=0, y=0, width=220, height=20)
...
gui_chuckaluck.py
Benutzeroberfläche zum Datenmodell
61
gui_chuckaluck.py
DatenmodellObjekte
...
def Button_Anzeigen_Click(self):
kontonummer = int(self.entryNummer.get())
self.labelStand.config(text=float(self.bank.getKonto(kontonummer).getStand()))
GUI-Objekte
def Button_Einzahlen_Click(self):
kontonummer = int(self.entryNummer.get())
betrag = float(self.entryBetrag.get())
self.bank.getKonto(kontonummer).einzahlen(betrag)
self.labelStand.config(text=float(self.bank.getKonto(kontonummer).getStand()))
Ereignisverarbeitung
self.entryBetrag.delete(0, END)
def Button_Auszahlen_Click(self):
kontonummer = int(self.entryNummer.get())
betrag = float(self.entryBetrag.get())
self.bank.getKonto(kontonummer).auszahlen(betrag)
self.labelStand.config(text=float(self.bank.getKonto(kontonummer).getStand()))
self.entryBetrag.delete(0, END) ...
62
Benutzeroberfläche zum Datenmodell
#----------------------------------------------------------# Datenmodell
#----------------------------------------------------------from datenmodell_bank import *
bank = Bank()
# Konten erzeugen
for i in range(10):
bank.kontoErzeugen(i)
#----------------------------------------------------------# GUI-Objekt
#----------------------------------------------------------from gui_bank import *
guibank = GUIBank(bank)
guibank.fenster.mainloop()
test_gui_bank.py
63
Teil 5
Delphi - Bank
64
Beispiel 3: Bank
Ziel ist es, ein einfaches System zur Verwaltung von Bankkonten zu entwickeln.
65
Datenmodell
Das Datenmodell ist komplexer und besteht aus Objekten, die in Beziehung stehen.
S
Konto-Nr.234126
Blatt 342
Miniwelt
Datenmodell
66
Implementierung des Datenmodells
unit uKonto;
interface
...
uKonto.pas
type
TKonto = class
private
nr: integer;
stand: real;
public
constructor create(nummer: integer);
procedure einzahlen(betrag: real);
procedure auszahlen(betrag: real);
function getStand: real;
function getNr: integer;
end;
implementation
constructor TKonto.create(nummer: integer);
begin
nr := nummer;
end; ...
procedure TKonto.einzahlen(betrag: real);
begin
stand := stand + betrag;
end;
procedure TKonto.auszahlen(betrag: real);
begin
stand := stand - betrag;
end;
function TKonto.getStand: real;
begin
result := stand;
end;
function TKonto.getNr: integer;
begin
result := nr;
end;
end.
Implementierung des Datenmodells
67
unit uBank;
interface
uses uKonto, classes; {TList}
type
TBank = class
private
maxKontoNr: integer;
konten: TList;
public
constructor create;
procedure kontoErzeugen;
function getKonto(nummer: integer):
TKonto;
end;
implementation
...
uBank.pas
...
constructor TBank.create;
begin
maxKontoNr := -1;
konten := TList.create;
end;
procedure TBank.kontoErzeugen;
var
konto: TKonto;
begin
maxKontoNr := maxKontoNr + 1;
konto := TKonto.create(maxKontoNr);
konten.insert(maxKontoNr, konto);
end;
function TBank.getKonto(nummer: integer):
TKonto;
begin
result := konten[nummer];
end;
end.
68
Test des Datenmodells
program ProjectBank;
{$APPTYPE CONSOLE}
uses
sysutils,
uBank in 'uBank.pas';
var
bank: TBank;
i: integer;
begin
Erzeugung der Objekte
// Erzeugung der Datenmodell-Objekte
bank := TBank.create;
for i := 0 to 9 do
Objekte in Aktion
bank.kontoErzeugen;
// Einzahlungen und Auszahlungen
bank.getKonto(4).einzahlen(100.0);
bank.getKonto(4).auszahlen(40.0);
bank.getKonto(7).einzahlen(40.0);
// Ausgabe von Daten
for i := 0 to 9 do
writeln('Konto mit Nummer' + IntToStr(i) + ': ' + FloatToStr(bank.getKonto(i).getStand));
readln;
ProjectBank.dpr
end.
69
Benutzeroberfläche zum Datenmodell
unit uGUI;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, ExtCtrls, uBank;
Einbindung
type
der
TGUI = class(TForm)
DatenmodellPKonto: TPanel;
Unit
...
private
{ Private-Deklarationen }
bank: TBank;
public
{ Public-Deklarationen }
end;
Deklaration des Referenzattributs
var
GUI: TGUI;
...
uGUI.pas
70
Benutzeroberfläche zum Datenmodell
...
procedure TGUI.FormCreate(Sender: TObject);
var
i: integer;
begin
bank := TBank.create;
for i := 0 to 9 do
bank.kontoErzeugen;
end;
procedure TGUI.BEinzahlenClick(Sender: TObject);
var
betrag: real;
kontonummer: integer;
begin
kontonummer := StrToInt(ENummer.text);
betrag := StrToFloat(EBetrag.Text);
bank.getKonto(kontonummer).einzahlen(betrag);
LStand.Caption := FloatToStr(bank.getKonto(kontonummer).getStand);
EBetrag.Text := '';
end; ...
uGUI.pas
71
Benutzeroberfläche zum Datenmodell
...
procedure TGUI.BAuszahlenClick(Sender: TObject);
var
betrag: real;
kontonummer: integer;
begin
kontonummer := StrToInt(ENummer.text);
betrag := StrToFloat(EBetrag.Text);
bank.getKonto(kontonummer).auszahlen(betrag);
LStand.Caption := FloatToStr(bank.getKonto(kontonummer).getStand);
EBetrag.Text := '';
end;
procedure TGUI.BKontoAnzeigenClick(Sender: TObject);
var
kontonummer: integer;
begin
kontonummer := StrToInt(ENummer.text);
LStand.Caption := FloatToStr(bank.getKonto(kontonummer).getStand);
end; ...
uGUI.pas
72
Teil 6
Java - Bank
73
Beispiel 3: Bank
Ziel ist es, ein einfaches System zur Verwaltung von Bankkonten zu entwickeln.
74
Datenmodell
Das Datenmodell ist komplexer und besteht aus Objekten, die in Beziehung stehen.
S
Konto-Nr.234126
Blatt 342
Miniwelt
Datenmodell
75
Implementierung des Datenmodells
public class Konto
{
// Anfang Attribute
private int nr;
private float stand;
// Ende Attribute
...
Alternativ:
double stand
public void auszahlen(float betrag)
{
stand = stand - betrag;
}
public Konto(int nummer)
{
nr = nummer;
}
public int getNr()
{
return nr;
}
// Anfang Methoden
public float getStand()
{
return stand;
}
// Ende Methoden
public void einzahlen(float betrag)
{
stand = stand + betrag;
}
...
}
Konto.java
76
Implementierung des Datenmodells
import java.util.ArrayList;
public class Bank
{
...
// Anfang Methoden
// Anfang Attribute
private int maxKontoNr;
private ArrayList konten;
// Ende Attribute
public void kontoErzeugen()
{
maxKontoNr = maxKontoNr + 1;
Konto konto = new Konto(maxKontoNr);
konten.add(konto);
}
public Bank()
{
maxKontoNr = -1;
konten = new ArrayList();
}
public Konto getKonto(int nummer)
{
return (Konto) konten.get(nummer);
}
// Ende Methoden
...
}
Bank.java
77
Test des Datenmodells
public class TestBank {
}
public static void main(String[] args) {
// Erzeugung der Objekte
Bank bank = new Bank();
Erzeugung der Objekte
for (int i = 0; i < 10; i = i + 1) {
bank.kontoErzeugen();
};
// Einzahlungen und Auszahlungen
Objekte in Aktion
bank.getKonto(4).einzahlen(100.0f);
bank.getKonto(4).auszahlen(40.0f);
bank.getKonto(7).einzahlen(40.0f);
// Ausgabe der Daten
for (int i = 0; i < 10; i = i + 1) {
System.out.println("Konto mit Numer" + Integer.toString(i) + "i: " +
Float.toString(bank.getKonto(i).getStand()));
}
}
TestBank.java
78
Benutzeroberfläche zum Datenmodell
import java.awt.*;
import java.awt.event.*;
public class GUI extends Frame {
// Anfang Attribute
private Panel pKonto = new Panel(null);
private Label lNummerText = new Label();
private TextField tfNummer = new TextField();
private Label lStandText = new Label();
private Label lStand = new Label();
private Label lKonto = new Label();
private Button bKontoAnzeigen = new Button();
private Button bKontenErzeugen = new Button();
private Button bEinzahlen = new Button();
private Button bAuszahlen = new Button();
private TextField tfBetrag = new TextField();
private Bank bank = new Bank();
// Ende Attribute
…
Erzeugung der
Datenmodell-Objekte
Erzeugung der GUIObjekte
GUI.java
79
Benutzeroberfläche zum Datenmodell
…
public void bKontenErzeugen_ActionPerformed(ActionEvent evt) {
for (int i = 0; i < 10; i = i + 1) {bank.kontoErzeugen();};
}
public void bKontoAnzeigen_ActionPerformed(ActionEvent evt) {
int kontonummer = Integer.parseInt(tfNummer.getText());
lStand.setText(Float.toString(bank.getKonto(kontonummer).getStand()));
}
public void bEinzahlen_ActionPerformed(ActionEvent evt) {
int kontonummer = Integer.parseInt(tfNummer.getText());
float betrag = Float.parseFloat(tfBetrag.getText());
bank.getKonto(kontonummer).einzahlen(betrag);
lStand.setText(Float.toString(bank.getKonto(kontonummer).getStand()));
tfBetrag.setText("");
}
…
}
public static void main(String[] args) {
new GUI("GUI");
}
GUI.java