Einführung in OOP

Inhalt der Vorlesung INE2
Objektorientierte Programmierung
Lernziele
■Sie kennen die Grundsätze und Grundbegriffe der objektorientierten
Programmierung anhand von Java
Inhalt
■Objekte und Klassen
■Vererbung
■GUI, Eventhandling
■Applets vs. Applications
■Fehlersuche und Testen
■Exceptionhandling
■Abstrakte Klassen und Interfaces
■Threads
■Dateisystem, IO-Klassen, Streams
■Collections
■ Motivation
■ Objekte und Klassen
■ Kapselung und Geheimnisprinzip
■ Umgang mit einzelnen Objekten
■ Interaktion von Objekten
■ Klassenmethoden und Klassenvariablen
■ Entwurf von Klassen
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
2 von 54
Literaturliste und Links
■Java für Studenten
Grundlagen der Programmierung
Douglas Bell, Mike Parr, Prentice Hall
ISBN 3-8273-7045-0
■Java ist auch eine Insel, Christian Ullenboom, Galileo Computing, OnLineAusgabe: http://openbook.galileocomputing.de/javainsel8/
■Handbuch der Java-Programmierung, Guido Krüger:
on-Line-Ausgabe: http://www.javabuch.de/
■The Java Programming Language
Arnold, Gosling, Holmes
ISBN 0-201-70433-1
■The Java Tutorial, Third Edition
A Short Course on the Basics
Campione, Walrath, Huml
ISBN 0-201-70393-9
Dieses Buch ist auch online verfügbar:
http://java.sun.com/docs/books/tutorial/index.html
■Java API Specifications
http://java.sun.com/reference/api/index.html
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
Motivation
3 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
4 von 54
Motivation
… Einführungsübung
■Kommentare zu PPG-Lösung:
Aufgabe:
Schreiben Sie ein Applet „PlayBalloon“ das 4 Ballone (gefüllte Kreise)
unterschiedlicher Grösse und Farbe an unterschiedlichen Positionen darstellt!
■
Schreiben und verwenden Sie dabei eine Methode „drawBallon(...)“, welche
einen Ballon zeichnet!
■
■
■
Probleme:
■Bei grösserer Anzahl Ballone wird es unübersichtlich
Vorgehen: PPG
■Benötigte Variablen deklarieren
■
■Benötigte Methoden schreiben
■
■
■Hauptprogramm (im init und paint) schreiben
■
Knopf „ok “ Æ Alle Ballone in der Grösse verändert und neu gezeichnet Æ
ActionListener
© A. Meier/M. Braschler/J. Zeman/K. Rege
■
■
5 von 54
… Einführungsübung: OOP-Lösung
■
■
kleine Änderungen haben grosse Auswirkungen an das Programm
Fehleranfällig und unflexibel
schlechte Wart- und Erweiterbarkeit
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
6 von 54
… Einführungsübung: OOP-Lösung
import java.awt.*;
■Bessere Lösung: OOP-Ansatz
■
Die Ballon-Variablen sind im Hauptprogramm deklariert (losgelöst von den Methoden, die sie
verwenden)
Sie müssen immer jeder Methode als Parameter übergeben werden.
Eine Methode „changeSize“ zu schreiben, die den Durchmesser eines bestimmten Ballons
verändert ist schwierig
■Wenn man den z.B. 5 Ballone anzeigen möchte,muss man das Programm an
mehreren Stellen anpassen!!!!!!
Anschliessende Erweiterung:
School of Engineering
So haben wir´s gelernt: Es ist eine sogenannte prozedurale Lösung (PPG)
In der Methode steckt der mehrfach verwendete Code!
Das Ganze ist eigentlich ganz gut programmiert!
So hat man bis zur Einführung der sogenannten OOP programmiert!
Ballone als Objekte einsetzen!
PlayBalloon in einer eigenen Klasse programmieren!
Balloon in einer eigenen Klasse programmieren!
public class Balloon {
Eigene
EigeneKlasse
Klasse„Balloon“
„Balloon“
verändert
verändertseine
seineGrösse
Grösseselber
selberund
und
kann
sich
selber
kann sich selberanzeigen
anzeigen
private int diameter;
private int xCoord, yCoord;
private Color color;
// Methods
-> Die Lösung besteht nun aus 2 Klassen
public void changeSize(int change){
diameter = diameter + change;
■Die eigene Klasse Balloon enthält
■
■
■
■
}
alle Variablen, die das Objekt charakterisieren (d, x, y, farbe).
Mit Veränderung dieser Variablen kann das Objekt jederzeit gezeichnet oder seine Grösse
verändert werden.
Von aussen her kann man auf diese Variablen gar nicht zugreifen (Kapselung,
Geheimnisprinzip).
Alle Methoden, die für die Manipulation des Objektes im Programm notwendig sind.
■ Initialisierung der Eigenschaften Æ Konstruktor-Methode „Balloon“, die beim Erzeugen des
Objektes (mit new) aufgerufen wird
■ Zeichnen des Ballons Æ „draw“
■ Veränderung der Grösse Æ „changeSize“
■ ……….
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
7 von 54
public void draw(Graphics g){
g.setColor(color);
g.fillOval(xCoord, yCoord, diameter, diameter);
}
// Konstruktor
public Balloon(int initialDiameter, int initialX, int initialY, Color initialColor){
diameter = initialDiameter;
xCoord = initialX;
yCoord = initialY;
color
= initialColor;
}
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
8 von 54
… Einführungsübung: OOP-Lösung
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class PlayBalloon extends Applet implements ActionListener {
TextField textfield;
Button button;
Balloon[] balloons;
public void init() {
textfield = new TextField("4");
add(textfield);
button = new Button("
ok
");
Objekte und Klassen
button.addActionListener(this);
add(button);
balloons = new Balloon[4];
balloons[0] = new Balloon (50, 100, 400, Color.GREEN);
balloons[1] = new Balloon (30, 400, 400, Color.RED);
balloons[2] = new Balloon (40, 400, 100, Color.YELLOW);
balloons[3] = new Balloon (90, 200, 150, Color.BLUE);
}
public void actionPerformed(ActionEvent ev) {
int delta = Integer.parseInt(textfield.getText());
for (int i = 0; i < balloons.length; i++) {
balloons[i].changeSize(delta);
}
repaint();
// …Fortsetzung
public void paint(Graphics g) {
for (int i = 0; i < balloons.length; i++) {
balloons[i].draw(g);
}
}
}
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
9 von 54
Objekte und Klassen
School of Engineering
■Beispiel: Ballon-Klasse
■OO-Programme bestehen aus einer Menge von Objekten, die miteinander
kommunizieren/interagieren
■Daten
■
■
■Objekte = Daten und die dazugehörigen Methoden
■
10 von 54
Objekte und Klassen
Objekte
■
© A. Meier/M. Braschler/J. Zeman/K. Rege
Daten (Synonyme: Attribute, Felder) bestimmen die Eigenschaften (unveränderlich) und den
Zustand des Objekts
Methoden bestimmen das Verhalten des Objekts und erlauben den Zugriff auf die internen
Daten
x-,y-Koordinaten
Diameter des Ballons
■Methoden
■
■
Änderung des Diameters
Darstellung des Ballons
x,y Koordinaten
Durchmesser
Klassen
■In vielen OOP-Sprachen ist es nicht möglich, ein Objekt direkt zu erzeugen.
Zuerst muss die Struktur des Objekts angegeben werden (=Bauplan).
Die Deklaration der Struktur heisst Klasse (class)
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
11 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
12 von 54
Klassen
Deklaration einer Klasse
■Objekte können in Java nicht direkt programmiert werden, sondern nur die
Klasse, aus denen zur Laufzeit Objekte erzeugt werden (mittels new)
■Klasse für Ballonobjekte
■Klassendeklaration:
■Die Klasse ist der Bauplan für die Objekte
■Von einer Klasse können beliebig viele Objekte erzeugt (instanziert) werden
■Ein Objekt wird auch als Instanz (engl. instance) der Klasse bezeichnet
■Jedes Java Programm besteht aus mindestens einer Klasse. Bei grösseren
Programmen können es auch tausende sein
public class Balloon{
//Klassenname
private int diameter;
//Instanzvariablen
private int xCoord, yCoord;
private Color color;
//Konstruktor zur Initialisierung
public Balloon (int initialDiameter, int initialX, int initialY, Color initialColor){
diameter = initialDiameter;
xCoord = initialX;
(xCoord, yCoord)
yCoord = initialY;
color = initialColor;
diameter
}
public void changeSize (int change) {
diameter = diameter + change;
}
//Instanzmethode
public void draw (Graphics g) {
//Instanzmethode
g.setColor(color);
g.drawOval (xCoord, yCoord, diameter, diameter);
}
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
13 von 54
Deklaration einer Klasse
Allgemeiner Aufbau einer Klasse
class Klassenname {
Instanzvariablen
Konstruktorendeklaration
Methodendeklaration
}
School of Engineering
■Spezielle Methode einer Klasse, dient zur Initialisierung der Variablen eines
Objekts bei der Erzeugung
Darstellung:
Darstellung:Einrückung
Einrückung
beachten
beachten! !
■
■
■
■
Referenzdatentyp, engl. reference type
■
■Anmerkung: Es gibt in Java drei Arten von Referenzdatentypen:
■
■
Klassentypen
Arrays
Schnittstellentypen (später)
© A. Meier/M. Braschler/J. Zeman/K. Rege
Balloon() {} // Objekt kann Instanziert werden ohne dass Konstruktor angegeben
dieser wird wieder entfernt sobald eigener Konstruktor definiert wurde
■Beispiel: Konstruktor der Balloon-Klasse
public Balloon (int initialDiameter, int initialX, int initialY, Color initialColor){
diameter = initialDiameter;
xCoord = initialX;
yCoord = initialY;
color = initialColor;
}
■Variablen von Referenztypen enthalten nicht Wert sondern Referenz
School of Engineering
Er hat keinen Rückgabewert Æ kein return und keine void
Ein Konstruktor hat eine Parameterliste wie normale Methoden
Der Zugriffsmodifikator ist normalerweise public
■Java definiert für alle Klassen Default-Konstruktor = Konstruktor ohne
Parameter
■Klasse ist ein neuer benutzerdefinierter Datentyp
■
Der Konstruktor wird automatisch aufgerufen, wenn ein Objekt mit new erzeugt wird
Dient zur Initialisierung des Objektzustands
■Der Konstruktor muss den gleichen Namen haben wie die Klasse
■
■
14 von 54
Konstruktor (constructor)
■Konvention Klassenname: Gross beginnen, Substantiv im Singular
■
© A. Meier/M. Braschler/J. Zeman/K. Rege
15 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
16 von 54
Klassen und Dateien in Java
Klassen und Packages
■ Klassen aus anderen Packages werden mittels import sichtbar
■Wie werden die Klassen in Dateien gespeichert?
Æ Eine separate Datei pro Klasse.
■ Es ist üblich auch für eigene Klassen Packages zu definieren
■
■Dabei ist zu beachten:
■
■
■
Jede Klasse muss public sein, da sie sonst nicht verwendet werden kann
Andere verwendete Klassen werden mit import angegeben
■ import java.awt.Button; // die Klasse Button
■ import java.awt.*;
// alle Klassen des Packages java.awt.*
■ Die Klassen sind hierarchisch in Pakete organisiert
■
■
analog zur Organisation eines Verzeichnisbaumes (übersetzte Klassen und Quellen entsprechend)
■ Die Klasse muss sich im analogen Verzeichnisbaum befinden (zwingend!)
package ch.test;
public class HelloWorld {
■Werden mehrere Klassen in eine Datei gespeichert:
■
nur einmal und zuoberst im Programm
Namen ist im Prinzip frei wählbar, aber oft Umkehrung einer URL; z.B. ch.zhaw.rege
Eine Klasse muss public sein und gleich heissen wie Datei
Alle übrigen dürfen nicht public sein
■Der Compiler erzeugt für jede Klasse ein eigenes .class-File mit dem Bytecode
■ Beim Aufruf muss der ganze Pfad mitgegeben werden (Gross/Kleinschreibung!)
■
c:\tmp> java ch.test.HelloWord
■ Die IDE erledigt das automatisch
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
17 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
18 von 54
Kapselung und Geheimnisprinzip
Prinzip der Kapselung (encapsulation)
■Daten und die zugehörigen Methoden werden in einer Einheit
zusammengefasst.
Geheimnisprinzip (information hiding)
■Eine Einheit (Objekt/Klasse) definiert eine klare Schnittstelle nach aussen
Kapselung und Geheimnisprinzip
■Interne Daten (=Attribute) werden versteckt
■
private Attribute speichern Zustand von Objekten
■Schnittstelle bei Objekten:
■
■
public-Methoden: Schnittstelle zu Objekten, ermöglichen Zugang zu den internen Daten
public-Attribute: sollten vermieden werden!!
Die Schnittstelle ist der "Vertrag" zwischen Implementator der Klasse und dem
Verwender (muss nicht dieselbe Person sein)
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
19 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
20 von 54
Kapselung und Geheimnisprinzip
Übung
public oder private??
■Verstecken der Attibuten und Methoden: private
■
■
■
Zugriff auf Variablen/Attribute soll nur über Methoden erfolgen.
Regel: sämtliche Attribute als private deklarieren (Geheimnisprinzip)
Veränderung ausschliesslich mittels Setter-/Getter Methoden: Namenskonvention
Innenansicht
Innenansichtder
derKlasse:
Klasse:
private Color c;
public Color getColor() {
return c;
}
public void setColor(Color c) {
this.c = c;
}
■
private
private int
int diameter;
diameter;
private
private int
int xCoord,
xCoord, yCoord;
yCoord;
public int tuDasNicht;
public int tuDasNicht;
Nicht für den allgemeinen Gebrauch bestimmte Methoden sollen für den Benutzer nicht sichtbar
sein
■Vorteile:
■
■
■
Durch den kontrollierten Zugriff auf die Variablen über Methoden bleiben die Daten der Objekte
konsistent
Vereinfachung (Anwender des Objektes muss nicht jedes Detail können)
Implementation kann jederzeit geändert werden d.h. dadurch wird die Abhängigkeit der
Benützung eines Objekts von seiner Implementation verkleinert
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
21 von 54
Sicht
Sichtvon
vonaussen
aussen(für
(fürden
denBenutzer
Benutzerdes
desObjekts):
Objekts):
public void changeSize (int change) {
public void changeSize (int change) {
int x,y;
int x,y;
...
...
}}
public
public void
void draw
draw (Graphics
(Graphics g)
g) {{
...
...
}
}
public
public void
void changeSize
changeSize (int
(int change)
change)
public
public void
void draw
draw (Graphics
(Graphics g)}
g)}
public
public int
int getTuDasNicht()
getTuDasNicht() {…}
{…}
public
public setTuDasNicht(int
setTuDasNicht(int wert)
wert) {…}
{…}
private
private void
void flaeche(float
flaeche(float d)
d) {{
if
if (d
(d >> 0.0){...}
0.0){...} else
else return;
return;
}}
Zugriff von aussen:
public int getTuDasNicht() {…}
public setTuDasNicht(int wert) {…}
School of Engineering
public
public int
int tuDasNicht;
tuDasNicht;
objektname.tuDasNicht = 20;
objektname.changeSize(+10);
objektname.draw(g);
© A. Meier/M. Braschler/J. Zeman/K. Rege
22 von 54
Deklaration von Objektvariablen
Deklaration:
Instanzvariablen werden
Instanzvariablen werden
in Klasse automatisch zu
in Klasse automatisch zu
null initialisiert
null initialisiert
Balloon myBalloon
null
als
alslokale
lokaleVariablen
Variablen
müssen
müssensie
sieexplizit
explizitzu
zu
null
gesetzt
null gesetztwerden
werden
Es wird eine (Referenz-) Variable vom Typ Balloon deklariert
Umgang mit einzelnen Objekten
■myBalloon zeigt auf null
■Balloon ist eine Klasse. Sie definiert einen Referenz-Datentyp (die Variable
myBalloon ist eine Referenzvariable, d.h. sie enthält nur die Adresse des
(noch zu erzeugenden) Objektes).
■Das Objekt besteht noch nicht!
■Pro memoria: Variablennamen klein beginnen
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
23 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
24 von 54
Erzeugung von Objekten: Instanzierung
null, NullPointerException
■null ist ein Java Schlüsselwort
Ein Objekt mit new erzeugen:
Es bezeichnet ein Objekt, dass nicht existiert (Eine Referenz/Adresse=0)
■
Deklaration:
Instanzierung: new
Balloon myBalloon
null
myBalloon
■Objekt explizit erzeugen und initialisieren:
myBalloon = new Balloon(20,50,50);
■
■
■
■Beispiel von vorher:
Balloon myBalloon;
Balloon
int diameter
int xcoord
int ycoord
Erst jetzt wir ein Objekt der Klasse Balloon erzeugt und Speicherplatz reserviert
Jetzt zeigt myBalloon auf ein Balloon-Objekt
Bei der Erzeugung mit new wird automatisch eine
Contructor-Methode dieser Klasse Aufgerufen
Æ verwendet z.B. für die Initialisierung der Instanzvariablen
(hier: diameter=20, xcoord=50, ycoord=50).
und dann:
myBalloon.changeSize(10);
geht nicht: Æ NullPointerException!!
myBalloon
null
Verwendung
■Wenn nicht sicher, dass Instanziert dann vor dem Zugriff testen:
if (myBalloon != null)myBalloon.changeSize(10);
■Kurzschreibung:
Balloon myBalloon = new Balloon(20,50,50);
■Variablen können/müssen auch explizit auf null gesetzt werden, z.B. wenn als
lokale Variablen gebraucht
myBalloon = null;
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
25 von 54
© A. Meier/M. Braschler/J. Zeman/K. Rege
26 von 54
Wrapper Klassen
this
■ this ist ein Schlüsselwort
■
School of Engineering
■Objekte einfacher Datentypen
Es bezeichnet das "eigene" Objekt
■Einfache Datentypen (boolean, char, int, long, float, double
etc.):
Verwendung
■
■ Wenn zwischen Instanzvariablen und Parameter unterschieden werden muss
■
int x;
■
Variablen einfacher Datentypen sind keine Objekte
Sie sind nach der Deklaration sofort verwendbar
Vordefinierte Operationen (+,-,*,/ etc.)
Wrapper-Klassen
void init (int x) {
this.x = x;
}
■Manchmal möchte man diese Variablen wie Objekte behandeln, z.B. Methode
nur für Objekte vorhanden
■ Wenn eigene Instanz einer Methode übergeben werden soll
■Wrapper classes in Java: Boolean, Character, Integer, Long,
Float, Double
button.addActionListener(this);
■Variablen einfacher Datentypen können in Objekte der entsprechenden
Wrapper-Klasse umgewandelt werden; ab Java 6 automatisch (Boxing)
Integer i = 5; // früher i = new Integer(5);
int k = i;
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
27 von 54
School of Engineering
// früher k = i.intValue();
© A. Meier/M. Braschler/J. Zeman/K. Rege
28 von 54
Vergleich Objekten: equals
toString
■ equals ist eine Methode, die jedes Objekt automatisch besitzt
■ toString ist eine Methode, die jedes Objekt automatisch besitzt
■
sie überprüft ob zwei Objekte den gleichen Wert enthalten
■
■ Test auf Gleichheit am Beispiel Strings
■
sie wandelt das Objekt in einen String um
■ automatisch (implizit) wenn in einem String mit "+" verwendet
häufige gemachter Fehler: verwenden von "==":
String s = "abc"; // new String("abc")
String t = "abc"; // new String("abc")
■
if (s == t) {} : testet auf Gleichheit von Referenz = false
String s = "hallo " + counter
■ explizit wenn toString aufgerufen wird
■
String s = "hallo "+ counter.toString()
■ equals-Methode von String/Objekt verwenden
■ Achtung: strukturierte Typen und Arrays nicht automatisch vernünftige
Stringrepräsentation (-> später)
if (s.equals(t)) {} : teste auf Gleichheit von Wert = true
ss
"abc"
"abc"
s == t;
tt
School of Engineering
s.equals(t);
String[] t = {"hallo","welt"}
String s = ""+ t;
// [Ljava.lang.String;@c55e36
"abc"
"abc"
© A. Meier/M. Braschler/J. Zeman/K. Rege
29 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
30 von 54
Löschen von Objekten
■Objekte können sehr viel Speicherplatz beanspruchen
Æ Nicht mehr benutzte Objekte sollen aus dem Speicher (Heap) entfernt
werden
■Wie/Wann werden Objekte wieder gelöscht?
■Möglichkeit: Der Programmierer löscht sie selber (Fehlerquelle!)
■
in C/C++ mittels free oder delete gelöst
Interaktion von Objekten
■Java hat einen Hintergrundprozess (läuft periodisch), der die nicht mehr
benutzten Objekte löscht
Æ Garbage Collector
■Nicht mehr benutzte Objekte = es gibt keine Referenzen auf das Objekt
■
Tip: es kann von Vorteil sein, Variablen explizit zu null zu setzen
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
31 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
32 von 54
Interaktion von Objekten
Interaktion von Objekten
Programmablauf bei Applets
■Der Browser/Appletviewer erzeugt implizit ein Objekt der Klasse PlayBalloon:
appObj = new PlayBalloon();
■actionPerformed(ActionEvent e) wird jedes Mal aufgerufen, wenn ein
Button gedrückt wird
■paint() wird jedes Mal aufgerufen, wenn das Applet neu gezeichet wird
Æ Ruft die draw–Methode vom myBalloon–Objekt auf
.class
School of Engineering
init
start
paint
yourBalloon
yourBalloon
Objekt
ObjektmyBalloon
myBalloon
r=20,
r=20,x=50,
x=50,x=50
x=50
■Es wird nur die Referenz (Adresse des Objektes)
kopiert, nicht das Objekt selber
Æ myBalloon und yourBalloon zeigen auf das gleiche Objekt!
Anmerkung: Für das Kopieren von Objekten muss man
spezielle Methoden aufrufen
Applet
■
© A. Meier/M. Braschler/J. Zeman/K. Rege
myBalloon
myBalloon
■1. Zuweisung:
Balloon myBalloon = new Balloon(20,50,50);
Balloon yourBalloon = null;
yourBalloon = myBallon;
■Der Browser ruft die Methode init() des Applet-Objekts appObj auf. Dort
werden Buttons und das Balloon-Objekt erzeugt
Browser/AppletViewer
JVM
JVM
■Objekte sind Referenzdatentypen Æ anderes Verhalten als normale Variable
wie int, double
33 von 54
yourBalloon = myBalloon.clone(); // Balloon muss jedoch dafür Cloneable
Interface implementieren und clone() mit public Methode überschreiben (-> später)
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
34 von 54
Methodenaufruf/Returnwert
Eigene Klassen als Referenzdatentypen
■ Klassen sind strukturierte Datentypen
public class MyClass
{
public double a;
private Balloon methodeA(Balloon b){
Instanzvariablen
Instanzvariablen
Ausnahme:
Ausnahme:hier
hierpublic
public
b.changeSize(-10);
return b;
Konstruktur
Konstruktur
■gleich wie Klassenname
■gleich wie Klassenname
public double b;
public MyClass(double a, double b)
{
}
yourBalloon = methodeA(myBallon);
■kein void
■kein void
this.a = a; this.b = b;
}
Beispiel: Es soll eine Methode geschrieben werden, die Buttons erzeugt
}
■ Deklaration der Variablen; Erzeugen des Wertes
MyClass me = new MyClass(4.5,5.1)
MyClass you;
■ Verwendung
you = me;
double d = me.a + me.b;
me
me
Objekt
ObjektButton
Button
double
doublea,a,bb
you
you
you.a = 5.5
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
35 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
36 von 54
Überladen von Methoden
Interaktion von Objekten
Operationen auf Objekten
■Eine Klasse kann mehrere Methoden mit dem gleichen Namen haben!
■Objekte kann man erzeugen (new), zuweisen (=) und als Argument einer
■Voraussetzung ist, das die überladenen Methoden unterschiedliche
Parameterlisten haben
Methode übergeben.
■Die normalen Operatoren ( + - * / > < && ¦¦ etc.) funktionieren nicht mit
Objekten.
■ == und != sind die einzigen Operatoren, die auch für Objekte gültig sind.
Achtung: Diese haben nicht die gleiche Bedeutung wie bei einfachen
Datentypen:
public void moveRight(int distance){
xCoord += distance;
}
public void moveRight(){
xCoord += 20;
}
//Methode 1
//Methode 2
■ Aufruf:
moveRight(293); //Methode 1
moveRight();
//Methode 2
if (myBalloon == yourBalloon) {...}
Typ: der Vergleich mittels == bei Referenztypen gar nicht verwenden
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
37 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
38 von 54
Überladen von Konstruktoren
■ Häufig wird das Überladen von Methoden bei Konstruktoren gebraucht, da dort
der Konstruktorenname gleich dem Klassenname ist
Balloon(Color c) {…}
Balloon(Color c, int size, int x, int y)
{…}
■ Es kann in einem Konstruktor ein andere (derselben Klasse) aufgerufen werden
Klassenmethoden und Klassenvariablen
Balloon (Color c) {
this(c, DEFAULTSIZE,DEFAULTPOSX,DEFAULTPOSY);
…
}
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
39 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
40 von 54
Klassenvariablen: static
Klassenmethoden: static
■ Klassenmethoden gehören zur Klasse, nicht zu den Objekten
■Klassenvariablen gehören zur Klasse, nicht zu den Objekten
■
Klassenvariablen entsprechen globalen Variablen in anderen Sprachen
■ können aufgerufen werden, ohne dass eine Instanz erzeugt wird
■ Beispiel:
■Es gibt nur eine Kopie pro Klassenvariable, egal wie viele Objekte von der
Klasse instanziert wurden
■
■
■
Zugriff: Klassenname.Variablenname
Beispiel in der Balloon-Klasse:
Math.sin(), Math.random()
■ Einschränkung: es kann nicht auf Instanzmethoden, Instanzvariablen zugegriffen
werden.
public static double gravity = 9.81;
public static int balloonCount = 0; //Deklaration
public Balloon (..) {
balloonCount++; // zählt wie viele Ballone erzeugt wurden
}
■Weitere Anwendung, die Sie schon gesehen haben:
■
Konstanten, die in der Klasse deklariert sind: Color.RED, Math.PI
public static final double PI = 3.14……; //final = unveränderbar
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
41 von 54
…Klassenvariablen + Klassenmethoden
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
42 von 54
Instanz vs.
vs. Klasse
43 von 54
Instanzvariablen/-methoden
Klassenvariablen/-methoden
Gehören zum jeweiligen Objekt (1 Kopie pro Instanz)
Gehören zur Klasse, nicht zu den Objekten
(Nur 1 Kopie pro Klasse)
Der Aufruf einer Instanzmethode erfolgt via den
Objektnamen:
myBalloon.changeSize(45);
Der Aufruf einer Klassenmethode erfolgt über den
Klassennamen:
Balloon.setGravity(9.81f);
Der Aufruf einer Instanzvariablen erfolgt via den
Objektnamen
Der Aufruf einer Klassenvariablen erfolgt via den
Klassenname:
Balloon.gravity
Wenn der Wert einer Instanzvariablen geändert wird, so
ändert der Wert der Variablen nur für dieses Objekt
Wenn der Wert einer Klassenvariablen geändert wird, wirkt
sich die Änderung in allen Objekten aus
Es braucht zuerst ein Objekt, um Instanzvariablen oder
–methoden aufzurufen
Es braucht kein Objekt, um Klassenvariablen oder
–methoden aufzurufen
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
44 von 54
Das objektorientierte Programmierparadigma
die gute Idee:
■ die Struktur der Software spiegelt die Realität wieder:
■ klar unterscheidbare Einheiten (Klassen/Objekte)
■ die untereinander Meldungen austauschen i.e.
interagieren
Entwurf von Klassen
Elektrik
Elektrik
Steuerrad
Steuerrad
Motor
Motor
Scheinwerfer
Scheinwerfer
Bremslichter
Bremslichter
Vorderräder
Vorderräder
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
45 von 54
Begriff Objekte und Klassen
School of Engineering
Hinterräder
Hinterräder
© A. Meier/M. Braschler/J. Zeman/K. Rege
Bauplan von Objekten
■ Objekte erlauben in OOP-Programmen die Wirklichkeit im Programm direkt
zu modellieren
Verschiedene ähnliche Objekte zusammenfassen
■
Objekte sind Ausprägungen (Exemplare, Instanzen) eines gemeinsamen
Grundmusters/Vorlage/Bauplans Æ Klasse
■ es ist mühsam die Objekt immer von Grund auf neu zu beschreiben
■
Beispiel: Programm für Simulation von Autos
■ -> erstellen eines "Bauplan" zur Erstellung von Objekten Klasse
Objekt 1:
rotesAuto
Objekt
Objekt2:2:blauesAuto
blauesAuto
Farbe:
Farbe:rot
rot
Preis:
Preis:300'000.300'000.Geschwindigkeit:
Geschwindigkeit:300
300
Tankinhalt:
Tankinhalt:100
100
Farbe:
Farbe:blau
blau
Preis:
Preis:-50.-50.Geschwindigkeit:
Geschwindigkeit:80
80
Tankinhalt:
Tankinhalt:17
17
beschleunigen
beschleunigen
bremsen
bremsen
tanken
tanken
links
linksabbiegen
abbiegen
rechts
rechtsabbiegen
abbiegen
beschleunigen
beschleunigen
bremsen
bremsen
tanken
tanken
links
linksabbiegen
abbiegen
rechts
rechtsabbiegen
abbiegen
School of Engineering
■ anhand dieses Bauplans können Objekte bei Bedarf erzeugt werden
Objekt 2:
blauesAuto
Objekt
Objekt1:1:rotesAuto
rotesAuto
© A. Meier/M. Braschler/J. Zeman/K. Rege
46 von 54
■ Bauplan für Objekte, die zwar gleiches Verhalten aber unterschiedlichen Zustand
haben
Eigenschaften
(Daten, sog.
Attribute)
Die Variablen, in denen der aktuelle Zustand gespeichert wird, werden als
Attribute bezeichnet
Verhalten
(sog. Methoden)
Der Bauplan wird als Klasse bezeichnet
47 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
48 von 54
Die Klasse als Bauplan von Objekten mit
gleichem Verhalten
… Klassen und Erzeugung von Objekten
Klasse:
Klasse: Auto
Auto
Color:
Color:farbe
farbe
double:
double:preis
preis
double:geschwindigkeit
double:geschwindigkeit
double:
tankinhalt
double: tankinhalt
beschleunigen
beschleunigen
bremsen
bremsen
tanken
tanken
linksAbbiegen
linksAbbiegen
rechtsAbbiegen
rechtsAbbiegen
Eigenschaften
(sog. Attribute)
Klasse
Objekt
■
rotesAuto = new Auto(rot, 20, 30, 50, 80);
rotesAuto.linksAbbiegen(); // Methodenaufruf
die Attribute
das Verhalten (durch Methoden)
49 von 54
Objekt = Instanz einer Klasse
■ bei der Instanzierung werden den Attributen konkrete Werte zugewiesen ->
Objekt bekommt einen Zustand
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
Attribute: Zustand und Eigenschaften
Zusammenfassung
■ Zwei Arten von Attributen:
■ Motivation
■ Eigenschaft: i.d.R. Konstant während der Lebensdauer des Objekts
■ Objekte und Klassen
solche die einmal festgelegt werden und dann während der Lebensdauer des Objekts sich nicht
verändern (bei der Instanzierung festgelegt werden)
Bsp: Automarke, Motorleistung
■ Zustand: Variabel
■
■
Mein Auto
■ der Vorgang der Erzeugung von Objekten wird als Instanzierung bezeichnet
■
© A. Meier/M. Braschler/J. Zeman/K. Rege
Instanzierung
■ Klasse beschreibt
Ein konkretes Objekt (Instanz einer zum voraus programmierten Klasse) kann wie folgt
im Programm kreiert und verwendet werden:
■
Attribute
Objekte
■
■
String Marke
Color Farbe
beschleunigen
bremsen
tanken
Bill Gates Ferrari
Die Baupläne kennen mögliche Zuständswertebereiche (= ausgedrückt durch den
Typ) aber keine expliziten Zustandswerte (werden beim Objekt festgelegt)
School of Engineering
Klasse
Methoden
Instanzierung
Verhalten
(sog.
Methoden)
PKW
50 von 54
■ Kapselung und Geheimnisprinzip
■ Umgang mit einzelnen Objekten
■ Interaktion von Objekten
solche die sich verändern können
Bsp: Geschwindigkeit, Tankfüllung
■ Klassenmethoden und Klassenvariablen
■ Entwurf von Klassen
■ Objekte einer Klasse können sich im Zustand und den Eigenschaften
unterscheiden nicht aber im Verhalten
■ Verhalten
■
■
■
Bsp: jedes Auto kann "beschleunigen"
kann durch Zustand beeinflusst sein
Bsp: beschleunigen ist abhängig von der Motorleistung und Tankfüllung
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
51 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
52 von 54
Lösung: Balloon mit PPG
Lösung: Balloon mit PPG
import java.awt.*;
Button button = new Button (" ok ");
import java.applet.*;
int change=10; // Radius-Change
import java.awt.*;
import java.awt.event.*;
public void init() {
setSize(600, 600);
add (button );
button .addActionListener(this);
}
public class Balloon_ppg extends Applet implements ActionListener{
// Eigenschaften Balloon1
int balloon1_d=50;
//Durchmesser
int balloon1_x=100;
// Koordinaten linke ober Ecke
int balloon1_y=400;
Color balloon1_farbe=Color.GREEN;
public void paint(Graphics g) {
drawBallon(g, balloon1_d, balloon1_x,
drawBallon(g, balloon2_d, balloon2_x,
drawBallon(g, balloon3_d, balloon3_x,
drawBallon(g, balloon4_d, balloon4_x,
}
//Farbe
// Eigenschaften Balloon2
int balloon2_d=30;
int balloon2_x=400;
balloon1_y,
balloon2_y,
balloon3_y,
balloon4_y,
balloon1_farbe);
balloon2_farbe);
balloon3_farbe);
balloon4_farbe);
int balloon2_y=400;
Color balloon2_farbe=Color.RED;
private void drawBallon(Graphics g1, int d, int x, int y, Color f){
g1.setColor(f);
g1.fillOval (x, y, d, d);
}
// Eigenschaften Balloon3
int balloon3_d=40;
int balloon3_x=400;
int balloon3_y=100;
public void actionPerformed(ActionEvent e) {
// Grösse ändern und neu Zeichnen: schwierig als allg. Methode
// changeSize zu realisieren
balloon1_d = balloon1_d+change;
balloon2_d = balloon2_d+change;
balloon3_d = balloon3_d+change;
balloon4_d = balloon4_d+change;
repaint();
}
Color balloon3_farbe=Color.YELLOW;
// Eigenschaften Balloon4
int balloon4_d=90;
int balloon4_x=200;
int balloon4_y=150;
Color balloon4_farbe=Color.BLUE;
School of Engineering
}
© A. Meier/M. Braschler/J. Zeman/K. Rege
53 von 54
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
54 von 54