Java Einführung - Michael Hahsler

Java Einführung
Teil 2: Objektorientierung
Michael Hahsler
Java Einführung
Objektorientierte
Grundkonzepte
Inhalt
• Verständnis der grundlegenden
Konzepte der Objektorientierung:
•
•
•
•
•
•
Objekte
Nachrichten
Kapselung
Klassen und Instanzen
Vererbung
Polymorphismus
• Darstellung in UML
Grundzüge der Programmierung - Hahsler
2
Objekte
• „Dinge“ aus der realen Welt
(Gegenstände, Personen, Rechte,...)
• Haben eine Identität und besitzen:
• Eigenschaften (Attribute)
• Verhalten (Operationen)
• Kommunizieren mit anderen Objekten durch
Nachrichten
Grundzüge der Programmierung - Hahsler
3
Nachrichten und Methoden
• Nachrichten sind Signale von einem Objekt an ein
anderes.
• Nachrichten lösen Verhalten (Operationen) des
anderen Objekts aus.
Nachricht
trinken
(einen Schluck)
Michael
1. Dose
Grundzüge der Programmierung - Hahsler
4
Kapselung (Encapsualtion, Data Hiding)
• Objekte können Attribute und Operationen (und damit
Komplexität) verbergen.
• Operationen werden vor dem Zugriff von außen
geschützt.
• Die allgemein zugänglichen Operationen nennt man
Interface
Wieviel Flüssigkeit ist in dieser Dose?
Kann jeder diese Dose verschließen?
Grundzüge der Programmierung - Hahsler
5
Klassen (-definition)
• Bauplan für ähnliche Objekte.
• Beschreibt Operationen und Attribute die eine
Instanz bekommt.
• Instanzen werden aus Klassen erzeugt
Instanzierung
Volumen = x
Instanz Nr. 1
Instanz Nr. 2
Klassendefinition
Grundzüge der Programmierung - Hahsler
6
Generalisierung,
Vererbung (Inheritance)
• Hierarchische Beziehung zwischen Klassen mit ähnlichen
Eigenschaften.
• Kinder (Subklassen) erben die Eigenschaften von Eltern
(Superklassen).
• Stellt ein gemeinsames Interface sicher.
Ich kenne das Interface eines
Behälters (Superklasse)
Behälter
Subklassen erben, erweitern
oder überschreiben
Eigenschaften
Dose
Häferl
Gießkanne
Grundzüge der Programmierung - Hahsler
7
Polymorphismus
(Griechisch: Vielgestaltigkeit)
• Subklassen können auch als Instanz der Superklasse
(Behälter) behandelt werden, da sie durch die Vererbung
ein gemeinsames Interface haben.
Behälter
Dose
Häferl
Ich verwende einen Behälter
Gießkanne
Jede Art von Behälter hat das
gleiche Interface. Einige
Operationen reagiert aber bei
unterschiedlichen
Behältertypen ein bisschen
anders!
Grundzüge der Programmierung - Hahsler
8
Modellierung und Abstraktion
• Eigenschaften und Verhalten müssen modelliert
werden.
• Modellierung ist Vereinfachung!
• Modellierung ist Einschränkung!
• Was ist das Wesentliche?
Hängt vom Zweck ab!
Ist diese Nutzung eines Häferls
durch das Modell vorgesehen?
Grundzüge der Programmierung - Hahsler
9
Vorteile der Objekt-Orientierung
• Objekte in Programmen entsprechen realen Objekten
(von Analyse bis zur Implementierung)
• Modularität durch die Kapselung in Objekte
• Wiederverwendung von Objektbibliotheken (Interfaces)
• Geringere Kosten bei Wartung weil der Programmcode
übersichtlicher wird.
Grundzüge der Programmierung - Hahsler
10
Die Unified Modeling Language
• UML ist eine von der OMG standardisierte
Notation zur Darstellung und Entwicklung
von objekt-orientierten Systemen
• Die Notation enthält unter anderem Diagramme für die
Beschreibung von:
• Anforderungen (Use Case Diagram)
• Verhalten/Ablauf (Sequence D., Communication D.)
• Logischer Aufbau des Systems (Klassendiagramm)
Grundzüge der Programmierung - Hahsler
11
Darstellung von Klassen in
UML Diagrammen
Klassen sind die Baupläne für Objekte (Instanzen)
Darstellung in UML
Klassenname
oder
Klassenname
Beispiel einer Klasse in UML
PKW
Farbe
Leistung
Geschwindigkeit
....
Attribute
Methoden
Beschleunigen()
Bremsen()
Lenken()
...
Klasse
Grundzüge der Programmierung - Hahsler
W59777: PKW
Rot
50km
Objekte (Instanzen)
12
Elemente Klassendiagramm I
Klassen
Klassenname
Beziehungen (Paths/Associations): für die Übermittlung von
Nachrichten (Messages = Aufruf von Methoden)
Klasse A
spricht mit
Klasse B
Richtung der Beziehungen (Navigability): Nachrichten
können nur in diese Richtung gehen
Klasse A
spricht mit
Klasse B
Grundzüge der Programmierung - Hahsler
13
Elemente Klassendiagramm II
Kardinalitäten (Multiplicity): Anzahl der möglichen Instanzen
Klasse A 1
spricht mit
0..* Klasse B
Aggregation (Aggregation/Composition): Besteht-aus Beziehung
Auto
besteht aus
*
1
Einzelteil
oder
Auto
Einzelteil *
Generalisierung (Generalization): is-a Beziehung -> Vererbung in
Java
Einzelteil
Motor
Karosserie
...
Grundzüge der Programmierung - Hahsler
14
Elemente Klassendiagramm III
Abhängigkeiten (Dependencies)
benötigt
Klasse A
Klasse B
Anmerkungen oder Einschränkung
PKW ist nur fahrttüchtig
mit: Räder, Karosserie,...
PKW
Grundzüge der Programmierung - Hahsler
15
Beispiel: Klassendiagramm
PKW ist nur fahrttüchtig
mit: Räder, Karosserie,...
besteht aus
PKW
1
Einzelteil
*
0..*
verwendet
1
Motor
besteht aus
Fahrzeughalter
Karosserieteil
...
1
4
Zylinder
Grundzüge der Programmierung - Hahsler
16
Was Sie nach dieser Einheit
wissen sollten...
• Was sind Objekte, Instanzen und Klassen?
• Was sind die wichtigsten Konzepte der
Objektorientierung und was bedeuten Sie?
• Wie werden Klassen in UML Klassendiagrammen
dargestellt?
Grundzüge der Programmierung - Hahsler
17
Java Einführung
Klassendefinitionen
Inhalt dieser Einheit
• Java-Syntax
•
•
•
•
Klassen definieren
Objekte instanziieren
Instanzvariable deklarieren
Klassenvariable deklarieren
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Klassen definieren
In der Problemanalyse haben Sie die geeigneten
Klassen, ihre Eigenschaften und ihr Verhalten
festgelegt. Diese implementieren Sie dann im
Quellcode.
class
class KlassenName
KlassenName {{
KlassenName
variablenDeklarationen;
variablenDeklarationen;
-Variablen
+Methoden()
methodenDeklarationen;
methodenDeklarationen;
}}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Neue Klasse definieren
(Bsp. Point)
Klassendefinition
class
class Point
Point {{
Name der Klasse
Variablendefinition
double
double x,
x, y;
y;
}}
Namen der Variablen
Datentyp der Variablen
• Klasse Point definiert einen Punkte in der Ebene.
• Point besitzt zwei Variable: x und y.
• Die Variablen sind vom „primitiven Typ“ double (reelle Zahlen).
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Vom Diagramm zum Quellcode
(Bsp. Point)
Das Klassendiagramm wird in einen kompilierbaren
Java-Quellcode umgewandelt:
Point
class
class Point
Point {{
-x : double
-y : double
double
double x,
x, y;
y;
}}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Instanzvariablen
(Member Variables)
• Ein Objekt speichert seine Zustände (Eigenschaften) in
Instanzvariablen.
• Alle Objekte einer Klasse haben die selben (Typ und Anzahl)
Instanzvariablen.
• Eine Variable ist eine Dateneinheit von einem bestimmten
Datentyp und hat einen Namen.
• Datentyp und Name werden in der Klasse deklariert.
• Der Name ermöglicht den Zugriff auf den Inhalt der Variablen
(Abfrage und Änderung).
• Die Werte der Variablen können während der Laufzeit geändert
werden.
• Instanzvariablen werden am Beginn der Klassendefinition
definiert
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
Instanzvariablen II
(Member Variables)
• Instanzvariablen werden am Beginn der Klassendefinition
definiert
Instanzvariablen
Point
-x : double
-y : double
class
class Point
Point {{
double
double x,
x, y;
y;
}}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Objekte einer Klasse erzeugen
(Bsp. Point)
• Objekte (Instanzen) einer Klasse werden mit der Methode
new erzeugt (=instantiiert):
KlassenName objektName =
new KlassenName(Initialisierungswerte);
z.B. Instanzen der Klasse Point:
Point lowerLeft = new Point();
Point upperRight= new Point();
Point centerPoint = new Point();
• Jedes erzeugte Objekt ist eindeutig und hat eigene Kopien
der Variablen (x und y). Sie werden daher auch
Instanzvariablen genannt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
Zugriff auf Instanzvariable
(Bsp. Point)
upperRight
(1280,1024)
ObjektName.VariablenName
lowerLeft.x = 0.0;
lowerLeft.y = 0.0;
upperRight.x = 1280.0;
upperRight.y = 1024.0;
centerPoint.x = 640.0;
centerPoint.y = 512.0;
x
centerPoint
(640,512)
y
lowerLeft
(0,0)
Jedes Objekt (Instanz) hat ein eigenes x und y.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
Beispiel
class Point {double x, y; }
class UsePoint {
public static void main (String[] arg) {
Point lowerLeft = new Point();
lowerLeft.x = 3.7;
lowerLeft.y = 5.9;
System.out.println(lowerLeft.x + “,“
lowerLeft.y);
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
+
10
Arrays von Instanzen
• Deklaration
ClassName[] name = new ClassName[n]; // n … Anzahl
• Zugriff auf Instanzvariablen einzelner Instanzen in einem Array erfolgt
mittels Indizierung auf einzelne Felder und Angabe des
Variablennamens.
name[Index].variablenName = Wert
• z.B. ein Array, das 52 Point-Instanzen aufnehmen kann
Point[] points = new Point[52]; // Array erzeugen
points[0] = new Point(); // Eine Instanz erzeugen!
points[0].x = 1.0;
points[0].y = 10.0;
... bzw.
int i = 0;
System.out.println(points[i].x + ", " +
points[i].y);
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Lernkontrolle
• Implementieren Sie eine umfangreiche Klasse
“Mitarbeiter“. Überlegen Sie sich, welche Variablen
für diese Klasse sinnvoll sind und definieren Sie ein
Array, in welchem 50 Mitarbeiter gespeichert werden
können.
• Ihr Programm soll zu bestimmten Feldern einen Teil
der gespeicherten Daten ausgeben.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Lernkontrolle
• Implementieren Sie eine Klasse
“Lehrveranstaltung“. Überlegen Sie sich, welche
Variablen für diese Klasse sinnvoll sind.
• Erzeugen Sie zwei Objekte dieser Klasse, die zwei
der Lehrveranstaltungen repräsentieren, die Sie
dieses Semester besuchen. Ihr Programm soll die
Bezeichnung und die Nummer dieser
Lehrveranstaltung ausgeben.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
Nach dieser Einheit sollten Sie wissen, ...
• wie man in Java Klassen deklariert.
• wie man innerhalb einer Klasse Variablen deklariert
und diesen primitive Datentypen zuweist.
• wie man in Java aus vordefinierten Klassen Objekte
erzeugt.
• was der Unterschied zwischen Klassen- und
Instanzvariablen ist.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
14
Java Einführung
Einfache Klassen
Kapitel 10
Inhalt
•
•
•
•
•
Deklaration von Klassen
Erzeugung und Zerstörung von Instanzen
Der Punkt-Operator
Instanznamen
Instanzen als Argument oder Rückgabewert
Grundzüge der Programmierung - Hahsler
2
Deklaration einer Klasse
(Klassendefinition)
Date
day : int
month : String
year : int
class Date {
int day;
String month;
int year;
}
Die Klasse Date hier ist nur als Beispiel gedacht!
Wird ein Datum in Java verwendet, sollten die Klassen
Date und DateFormat der Java API (in java.util)
verwendet werden.
Grundzüge der Programmierung - Hahsler
3
Erzeugung und Freigabe von
Instanzen
• Deklaration und Erzeugung von Instanzen
x
Instanz
Date x, y;
x = new Date();
y
day
month
year
• Freigabe von Instanzen
Garbage Collection: Sobald kein Zeiger mehr
auf das Objekt zeigt (Reference Count)
x = null; // x zeigt jetzt auf nichts!
Grundzüge der Programmierung - Hahsler
4
Der Punkt-Operator
• Verwendung der Klassenvariablen (PunktOperator)
Date x = new Date();
x
x.day = 13;
x.month = "November";
x.year = 2001;
Instanz
day
November month
year
2001
13
Achtung: month ist vom Typ String und daher
kein primitiver Datentyp!
Grundzüge der Programmierung - Hahsler
5
Instanznamen
• Zuweisung von Instanznamen
Date x, y;
x = new Date();
x
Instanz
20
y = x;
y.day = 20;
y
day
month
year
Zuweisung ist nur bei gleichem Datentyp
(Klassennamen) erlaubt!
Grundzüge der Programmierung - Hahsler
6
Instanzen als Argumente
in Date.java:
class Date { int day; String month; int year; }
in UseDate.java:
class UseDate {
public static void main (String[] args) {
Date x = new Date();
x.day=13; x.month="November"; x.year=2003;
printDate(x);
}
public static void printDate (Date aDate) {
System.out.println(aDate.day+". "+aDate.month+
" "+aDate.year);
}
}
Grundzüge der Programmierung - Hahsler
7
Objekte als Rückgabewerte
in Time.java:
class Time { int h, m, s; /*hours,minutes,seconds*/ }
in UseTime.java:
class UseTime {
static Time convert (int seconds){
Time t = new Time();
t.h = seconds / 3600;
t.m = (seconds % 3600) / 60;
t.s = seconds % 60;
return t;
}
Objekte können nach
der Erzeugung wie
Variablen verwendet
werden. Durch new
unterliegen sie nicht
den Regeln des Scopes
sondern der Garbage
Collection!
public static void main (String[] args) {
Time theTime = convert(12345);
}
}
Grundzüge der Programmierung - Hahsler
8
Java Einführung
Methoden in Klassen
Lehrziel der Einheit
• Methoden
•
•
•
•
•
Signatur (=Deklaration) einer Methode
Zugriff/Sichtbarkeit
Rückgabewerte
Parameter
Aufruf von Methoden (Nachrichten)
• Information Hiding
• Konstruktoren
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Klassendefinition
In der Designphase wurden
• die Eigenschaften (Variablen) und
• das Verhalten (Methoden) definiert.
Im Folgenden wird das Implementieren der
Methoden behandelt.
KlassenName
class
class KlassenName
KlassenName {{
variablenDeklarationen;
variablenDeklarationen;
methodenDeklarationen(){
methodenDeklarationen(){
-Variablen
+Methoden()
}}
}}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Methoden
• Objekte interagieren miteinander durch das gegenseitige Aufrufen von
Methoden (=Nachrichtenaustausch).
• Methoden sind Programmteile, die bestimmte Teilaufgaben lösen (und
sollten nach diesen selbstsprechend benannt werden).
• Eine Methode (Nachricht) besteht aus zwei Teilen:
• der Signatur (bzw. Methodendeklaration), die Angaben über
Sichtbarkeit, Rückgabetyp, Name der Methode und Parameter
macht.
• dem Methodenrumpf, in dem die Deklarationen der lokalen
Variablen und die eigentlichen Anweisungen stehen.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Zweck von Methoden
• Zustand eines Objektes abfragen
point1.getX();
aString.length();
• Aufforderung an ein Objekt, etwas zu tun
(z.B. Instanzvariable verändern)
point1.setInvisible(true);
aString.toUpperCase();
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Methodendeklaration
Methodenname
Zugriff/Sichtbarkeit
Bezeichner des
Parameters
public double setX(double xValue)
Typ des Rückgabewerts
Typ des
Parameters
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
Beispiel zu Methode
class Point {
public double x, y;
//Methodendeklaration:
public double distance(Point pkt) {
double xdiff = x - pkt.x;
double ydiff = y - pkt.y;
return Math.sqrt(xdiff*xdiff +ydiff*ydiff);
}
...
//Methodenaufruf:
Class PointTester {
public static void main(String[] args) {
Point lowerLeft = new Point(); lowerLeft.x = 0.1; …
Point upperRigth = new Point(); upperRight.x = 0.1; …
double d = lowerLeft.distance(upperRight);
}
danach enthält Variable d die Euklidische Distanz zwischen lowerLeft und upperRight.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Variablenzugriff
• Innerhalb der Methode einer Instanz können die eigenen Variablen und
Methoden direkt (d.h. ohne Angabe des Instanznamens) aufgerufen
werden.
• z.B. Variable x in der Instanz lowerLeft bei Aufruf
lowerLeft.distance(upperRight)
Instanz lowerLeft
Instanz upperRight
x, y
x, y
public double distance(Point pkt)
{
double xdiff = x - pkt.x;
double ydiff = y - pkt.y;
return Math.sqrt(xdiff*xdiff
+ydiff*ydiff);
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
Standardvariable „this“
• this ist eine Referenz zum aktuellen Objekt, oder
anders ausgedrückt
• this ist eine Referenz auf die aktuelle Instanz der
Klasse in der man sich gerade befindet.
• Über this kann auf alle Variablen und Methoden der
Instanz zugegriffen werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
this 2
class Point {
double x,y;
void setX(double x) {
this.x = x;
Instanzvariablenname
Parametername
//Instanzvariable x wird gesetzt
}} …
Innerhalb einer Methode überschreiben bei Namenskonflikten
(=gleicher Bezeichnung) die Parameternamen die Variablennamen
der Klasse.
Lösung: Verwendung von this oder anderen Parameterbezeichner
wählen, z.B. newName.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
10
Statische Elemente
• Variablen und Methoden, die nicht zu einer bestimmten Instanz
sonder zur Klasse gehören.
• Statische Variablen/Methoden sind auch dann verfügbar, wenn noch
keine Instanz der Klasse erzeugt wurde.
• Statische Variablen/Methoden können über den Klassennamen
aufgerufen werden.
• Deklaration durch das Schlüsselwort: static
• Bsp:
class Point {
double x, y;
static int count;
}
• Point.count kann dann zum Beispiel benutzt werden um die
Anzahl der Instanzen von Punkt zu speichern. Auf diese Variable
kann von jeder Instanz der Klasse Point aus zugegriffen werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Statische Elemente
Programmaufbau
class Programm {
public static void main(String[] args) …
• Jede Applikation braucht eine Klasse, wo die Applikation startet. Diese
Klasse hat eine main-Methode. Das Programm startet mit dieser
Klasse bei der main-Methode.
• Der main-Methode werden die Eigenschaften public und static
zugewiesen.
• static bedeutet, wie wir wissen, dass keine Instanz der Klasse
angelegt werden muss. Und zu Beginn einer Applikation existieren ja
auch noch keine Instanzen.
• public bedeutet hier, dass die Java Virtual Machine die MainMethode des Programms aufrufen darf, um das Programm zu starten.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Konstruktoren
Jede Klasse benötigt einen oder mehrere Konstruktoren.
Konstruktoren:
• reservieren den Speicherplatz für eine neu zu erzeugende
Instanz,
• weisen den Instanzvariablen initiale Werte zu,
• haben denselben Namen wie die Klasse,
• werden wie Methoden deklariert, aber ohne Rückgabewert
KlassenName(Parameter){..}.
Zu einer Klasse können mehrere Konstruktoren mit verschiedenen
Parametern deklariert werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
Konstruktoren
Beispielklasse Student
class Student {
private String matrNr;
private String name;
private int semester;
Student(String name, String matrNr) {
this.name = name;
this.matrNr = matrNr;
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
14
Konstruktoren - Anwendung
• Jedes Objekt der Klasse Student kann nun durch den
Konstruktor mit zwei Werten initialisiert werden:
• Eine Zeichenkette, um den Namen zu initialisieren.
• Eine Zahl um die Matrikelnummer zu setzen.
Student myStudent =
new Student("Else Maier", "0524343");
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
15
Spezialisierte Konstruktoren
Zweiter Konstruktor (in Klassendefinition) mit anderer Anzahl bzw. anderen
Typen von Parametern:
Student(String name, String matrNr, int semester){
this(name, matrNr);
this.semester=semester;
}
Aufruf (aus einem Programm):
Student myStudent =
new Student("Else Maier", "9324343", 5);
• Abhängig von der Parameterzahl und ihren Datentypen wird der entsprechende
Konstruktor aufgerufen.
• Innerhalb dieses Konstruktors wird der erste Konstruktor über this(...);
aufgerufen.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
16
Spezialisierte Konstruktoren
Beispielklasse Student
class Student {
private String name, matrNr;
private int semester;
Student(String studName, String studMatrNr) { //Konstruktor 1
name = studName;
matrNr = studMatrNr;
}
Student(String name, String matrNr, int semester) {
// Konstruktor 2
this(name, matrNr); //Aufruf Konstruktor 1
this.semester=semester;
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
17
Default-Konstruktor
//Konstruktor 1 verwenden
Student s1 =
new Student("Petra Schmidt", "0051998");
//Konstruktor 2 verwenden
Student s2 =
new Student("Peter Baum", "9988764", 2);
• Wenn kein Konstruktor erstellt wurde, wird von Java
default-mäßig ein Konstruktor (ohne Parameter) zur Verfügung
gestellt.
Student s = new Student();
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
18
Zugriffskontrolle
In JAVA gibt es drei Attribute und eine Standardeinstellung, die den
Gültigkeitsbereich von Klassen, Variablen und Methoden regeln, d.h.
festlegen, ob bzw. welche anderen Objekte auf eine Klasse, Variable
oder Methode der programmierten Klasse zugreifen können:
• private
• protected
• public
• package (Standardeinstellung)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
19
Zugriffskontrolle 2
Grundsätzlich: alle Methoden oder Variablen können innerhalb der Klasse, in
der sie geschrieben sind, verwendet oder aufgerufen werden.
•
Methoden oder Variablen können nur innerhalb der eigenen Klasse
verwendet oder aufgerufen werden.
keine Angabe (=Standardeinstellung)
Methoden oder Variablen sind innerhalb der Eigenen Klasse und innerhalb
ihres Pakets* zugreifbar.
• protected
Wie Standardeintellung. Zusätzlich können abgeleite Klassen** (auch
außerhalb des Pakets*) diese Methoden und Variablen verwenden.
• public
Methoden oder Variablen lassen sich generell von allen anderen Klassen
und Paketen aus aufrufen (Interface von Klassen in Paketen).
Einschränkung nimmt zu
• private
* Pakete sind Sammlungen von zusammengehörigen Klassen.
** Vererbung wird später behandelt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
20
Zugriffskontrolle 3
class Student {
private String name;
}
// ...
class Uni {
public static void main(String[] args) {
Student stud1 = new Student();
stud1.name = “Peter“; /* Zugriff außerhalb der Klasse
Student auf private-Variable nicht möglich, kann nur innerhalb
der Klasse Student gesetzt werden */
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
21
Information Hiding
• Verstecken der Implementierung einer Klasse
hinter den Methoden, die auf ihre internen
Daten ausgeführt werden.
• Das heißt: kein direkter Zugriff auf die
Variablen, sondern nur via Methodenaufruf:
stud1.setName("Peter Meyer");
String name = stud1.getName();
• Dieses wichtige Konzept der ooP wird auch
„Data Encapsulation“ (Datenkapselung)
genannt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
22
Information Hiding - Code 1
Die Deklaration der
Variablen als private
verhindert den
unerwünschten Zugriff auf
die Variablen von
außerhalb der Klasse.
class
Student
{
private String
name;
private int
matNr;
...
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
23
Information Hiding - Code 2
Auf die Variablen kann nur
über die Methoden get
und set zugegriffen
werden. Diese Methoden
müssen public
deklariert werden.
...
public String getName()
{
return name;
}
public int getMatNr()
{
return matNr;
}
...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
24
Information Hiding - Code 3
...
public void setName(String name)
{
this.name = name;
}
public void setMatNr(String matNr)
{
this.matNr = matNr;
}
Mit den Methoden set… können den
entsprechenden Variablen Werte
zugewiesen werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
25
Klasse Student gesamt
class Student {
private String name;
private int matNr;
Student(String name, int matNr){
this.name = name; this.matNr = matNr;
}
}
public String getName(){ return name; }
public int getMatNr(){ return matNr;}
/* keine set-Methoden: Die Variablen
können nur gelesen werden */
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
26
Information Hiding - Vorteile
• Die Implementierung der Daten kann verändert
werden, ohne dass Programmcode außerhalb der
Klasse geändert werden muss.
• Der Zugriff auf die verschiedenen Variablen kann
eingeschränkt werden. Dies verhindert sowohl
Datenmanipulationen als auch irrtümliche
Veränderung oder Abfrage der Daten. Außerdem
können damit die Programmierfehler eingeschränkt
werden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
27
Nach dieser Einheit sollten Sie
...
• die Zugriffskontrolle von Methoden kennen,
• die Signatur verschiedener Methoden
interpretieren können,
• die Bedeutung der Konstruktoren kennen,
• Methoden implementieren können,
• Information Hiding und statische Methoden
kennen und anwenden können.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
28
Java Einführung
Objektorientierung
Kapitel 11
Inhalt
•
•
•
•
Methoden in Klassen
Aufruf der Methoden
Konstruktoren
Statische Komponenten
Grundzüge der Programmierung - Hahsler
2
Klassen
• Klassen fügen
Name
• Attribute und
• Methoden
Attribute
zu einer logischen Einheit zusammen.
Methoden
• Klassen sind die Grundbausteine der
objektorientierten Programmierung.
Grundzüge der Programmierung - Hahsler
3
Methoden in Klassen
Fraction
int n
int d
class Fraction {
public int n; // Zaehler
public int d; // Nenner
public void set (int nn, int dd){
void set (int n, int d)
void add (Fraction f)
void subtract (Fraction f)
void multiply (Fraction f)
void divide (Fraction f)
n=nn; d=dd;
}
public void add (Fraction f){
n = n*f.d + f.n*d;
d = d*f.d;
}
public void substract(Fra..
...
Grundzüge der Programmierung - Hahsler
}
4
Aufruf von Methoden in Klassen I
Fraction a = new Fraction();
a.set(1,2);
Instanz a
...
void set (int nn, int dd) {
n = nn;
d = dd;
}...
Instanzvariablen können in den Methoden auch mit this
angesprochen werden. Z.B. kann die Methode set so
aussehen:
void set (int n, int d) {
this.n = n; this.d = d;
}
Grundzüge der Programmierung - Hahsler
5
Aufruf von Methoden in Klassen II
Fraction a = new Fraction();
a.n=1; a.d=2;
Fraction b = new Fraction();
b.n=3; b.d=5;
Instanz a
a.add(b);
...
void add (Fraction f) {
n = n*f.d + f.n*d;
d = d*f.d;
}...
Die Instanz a enthält nun das Ergebnis der Addition.
Grundzüge der Programmierung - Hahsler
6
Konstruktoren
• Wenn ein Instanz erzeugt wird, werden alle
Klassenvariablen automatisch erzeugt und erhalten
folgende Werte:
• Zahlen: 0 oder 0.0
• Referenzen (Strings, Arraynamen, Instanznamen): null
• Boolean: false
• Bei der Erzeugung wir eine spezielle Methode aufgerufen
(Konstruktor, gleicher Name wie die Klasse, kann
Argumente haben). In dieser Methode können die Werte
der Instanzvariablen initialisiert werden.
Grundzüge der Programmierung - Hahsler
7
Definition von Konstruktoren
class Fraction{
int n,d;
Fraction () { // Default-Konstruktor
n=0; d=1;
}
Fraction (int n, int d) {
this.n = n; // this bezeichnet die Klassenvariablen
this.d = d;
}
Fraction (Fraction toCopy) { // Copy-Konstrukor*
this.n = toCopy.n;
this.d = toCopy.d;
}
...
}
* Java unterstützt die Methode .clone() der Klasse Object
Grundzüge der Programmierung - Hahsler
8
Verwendung von Konstruktoren
• Aufruf: Default Konstruktor
Fraction c = new Fraction(); // 0/1
• Aufruf: Konstruktor mit Argumenten
Fraction d = new Fraction(3,7); // 3/7
Grundzüge der Programmierung - Hahsler
9
Statische Komponenten
• Variablen und Methoden die mit dem
Schlüsselwort static deklariert werden:
• Existieren nur 1x (pro Klasse pro Programm)
• Existieren auch ohne dass eine Instanz der Klasse
erzeugt werden muss
• Können auch über den Klassennamen angesprochen
werden Class.field bzw. Class.method()
Grundzüge der Programmierung - Hahsler
10
Bsp: Statische Komponenten II
class MyProg {
static void print (String s){
Out.println(s);
}
public static void main (String[] arg) {
for (int i=0; i<arg.length; i++) {
print(arg[i]);
}
}
}
Die Methode main wird beim Programmstart mit dem Array aus Strings
aufgerufen. Z.B. java MyProg Hallo, wie geht es?
Grundzüge der Programmierung - Hahsler
11
Die Klasse Object in Java
• In Java wird jede Klasse von Object abgeleitet und erbt
daher einige Methoden.
Object
String toString()
Object clone()
boolean equals(Object obj)
Fraction
String
...
siehe java.lang.Object in der API Spezifikation
Grundzüge der Programmierung - Hahsler
12
toString()
Automatische Konversion zu
String
class Fraction {
int n, d;
…
public String
toString() {
return("fraction(" +
d + "/" + n + ")")
}
}
class TestFraction {
public static void
main(String[] args) {
f1 = new
Fraction(1,2);
System.out.println(f1);
}
}
Grundzüge der Programmierung - Hahsler
13
Java Einführung
HelloNewWorld
oder
HelloWorld - revised
Das original Programm
Klasse
Block
Methode
class HelloWorld {
public static void main (String[]
args)
{
Kommentar
// Hello world ausgeben
System.out.println(“Hello world“);
}
Anweisung
}
Grundzüge der Programmierung - Hahsler
2
Das Problem
• Das Programm ist nicht 'sehr' objekt-orientiert
• Es verwendet keine Klassen, Methoden und
Nachrichten!
Grundzüge der Programmierung - Hahsler
3
Das neue Design
HelloNewWorld
Mouth
+main()
+shout(message)
Grundzüge der Programmierung - Hahsler
4
Implementierung Mouth
Die Datei Mouth.java:
class Mouth {
// Konstruktor
Mouth () {
System.out.println("Hello, I am a new mouth!");
}
// Methoden
public void shout(String aMessage) {
System.out.println("The mouth shouts: "+aMessage);
}
}
Grundzüge der Programmierung - Hahsler
5
Implementierung
HelloNewWorld
Die Datei HelloNewWorld.java:
class HelloNewWorld {
public static void main (String[] args)
{
// Neue Instanz von Mouth
Mouth OurMouth = new Mouth();
// Methode shout aufrufen
OurMouth.shout("Hello New World!");
}
}
Grundzüge der Programmierung - Hahsler
6
Kompilierung
javac HelloNewWorld.java
• durch diesen Befehl wird die Datei
HelloNewWorld.java übersetzt. Da der Kompiler
feststellt, dass auch die Klasse Mouth benötigt wird,
wird diese im aktuellen Verzeichnis gesucht und auch
übersetzt.
• Ergebnis:
• HelloNewWorld.class
• Mouth.class
• Ausführung: java HelloNewWorld
Grundzüge der Programmierung - Hahsler
7
Java Einführung
Objekt-Datentypen
und Strings
Kapitel 8 und 9
Inhalt
• Was sind Objekt-Datentypen
• Sonderheiten bei Zuweisung und Vergleich
• Zeichenketten (Strings)
•
•
•
•
Zeichencodes
Char, Char-Arrays und Strings
String-Operationen
String-Konversion
Grundzüge der Programmierung - Hahsler
2
Objekt-Datentyp
• Jede Klasse in Java stellt einen sogenannten
Objektdaten-Typ (Benuzerdefinierter Datentyp)
dar.
• Die Instanzen verhalten sich meist wie primitive
Datentypen, es gibt jedoch wichtige
Unterschiede!
Grundzüge der Programmierung - Hahsler
3
Bsp: Date
class Date {
int day;
String month;
int year;
}
Date
int day
String month
int year
Date kann nach der Deklaration wie
ein Datentyp verwendet werden.
Grundzüge der Programmierung - Hahsler
4
Erzeugung und Freigabe
• Deklaration und Erzeugung von Instanzen
x
Objekt
Date x, y;
x = new Date();
y
day
month
year
• Freigabe von Objekten
Garbage Collection: Sobald kein Zeiger mehr
auf das Objekt zeigt (Reference Count)
x = null; // x zeigt jetzt auf nichts!
Grundzüge der Programmierung - Hahsler
5
Punkt-Operator
• Verwendung der Klassenvariablen (PunktOperator)
Date x = new Date();
x
x.day = 13;
x.month = "November";
x.year = 2001;
Objekt
day
November month
year
2001
13
Achtung: month ist vom Typ String und daher
eigentlich ein Array.
Grundzüge der Programmierung - Hahsler
6
Zuweisung
• Zuweisung von Objektnamen
Date x, y;
x = new Date();
x
Objekt
20
y = x;
y.day = 20;
y
day
month
year
• Es wird nur die Referenz kopiert, nicht der Wert!
• Zuweisung ist nur bei gleichem Datentyp
(Klassennamen) erlaubt!
Grundzüge der Programmierung - Hahsler
7
Vergleich
x
Instanz
20
Date x,
x = new
y = new
y.day =
y;
Date();
Date();
20; x.day = 20;
y
day
month
year
Instanz
20
day
month
year
if (x==y) {
System.out.println("x ist gleich y");
}
• Vergleich ergibt immer falsch, weil die Zeiger
verglichen werden!
Grundzüge der Programmierung - Hahsler
8
Übergabe als Parameter
Date addOneDay (Date b){
b.day++;
return b;
b
}
a
Instanz
19 20
c
...
Date a = new Date(); a.day=19;
Date c = addOneDay(a); // a hat jetzt
Grundzüge der Programmierung - Hahsler
day
month
year
auch 20!
9
Zeichenketten in Java (Strings)
• Zeichenketten bestehen aus einzelnen Zeichen.
• Diese Zeichen sind vom primitiven Datentyp
char
• Zeichenketten können als Array von char
erzeugt werden, oder
• als eigener Objekt-Datentyp String (ist in den
Bibliotheken von Java vorhanden unter
java.lang.String)
Grundzüge der Programmierung - Hahsler
10
Zeichenkonstanten und -codes
'a', 'A', '?' ...
Zeichen werden in Java codiert als:
• ASCII (American Standard Code of Information Interchange): 128
Zeichen, benutzt 7 Bit, keine Umlaute...
Darstellung: Zahl (Hex oder Dezimal)
• Unicode: benutzt 2 Byte, 65536 Zeichen, ersten 128 sind
identisch mit ASCII (siehe: www.unicode.org )
Darstellung: \unnnn ... nnnn ist der Code in Hex
Grundzüge der Programmierung - Hahsler
11
Zeichenvariable (Primitiver Datentyp)
• Deklaration
char ch;
• Zuweisung
ch = 'a';
• Kompatibilität mit int
char ch2 = 'x';
int i = ch2; // ok, Code
ch2 = (char) (i+1);
in int-Variable
Grundzüge der Programmierung - Hahsler
12
Standardfunktionen für Zeichen
• Auswahl von Java-Bibliothek Standardfunktionen:
if (Character.isLetter(ch)) ... // Unicode?
if (Character.isDigit(ch)) ... // Digit?
ch=Character.toUpperCase(ch); // Groß
ch=Character.toLowerCase(ch); // Klein
siehe: java.lang.Character
Grundzüge der Programmierung - Hahsler
13
char-Arrays
• Eine Kette von Zeichen. Deklaration:
char[] s1 = new char[20];
char[] s2 = {'a','b','c'};
• Zugriff auf einzelne Zeichen:
s2[1]='x'; // ersetzt 'b' durch 'x'
Grundzüge der Programmierung - Hahsler
14
Strings - Zeichenketten (Objekt-Datentyp)
• Char-Arrays sind relativ umständlich zu
verwenden.
• Da Zeichenketten häufig vorkommen, stellt Java
einen eigenen Bibliothekstyp mit dem Namen
String (in java.lang) zur Verfügung.
Grundzüge der Programmierung - Hahsler
15
String-Konstanten
• Zeichenfolge zwischen doppelten Hochkommas
"Hello, I am a String!"
"Alice\t2000\nBob\t1500"
"Das \"-Zeichen "
"Griechische Symbol (pi): \u03c0"
• Achtung: Unterschied zwischen 'x' und "x"
Grundzüge der Programmierung - Hahsler
16
Datentyp String
• Deklaration
String a, b;
• Zuweisung
a = "Hallo";
b = a;
a
Hallo
b
• Achtung: Strings verhalten sich wie Arrays. Der
Name ist nur ein Zeiger auf das "String-Objekt"
Grundzüge der Programmierung - Hahsler
17
Verkettung von Strings
• Verkettung
String a = "Hallo";
a = a + " Welt!"; // einfache Verkettung
• Andere Datentypen (z.Bsp: int) werden zu String
konvertiert
int i = 12;
String b = "Es ist " + i;
System.out.println("i hat den Wert " + i);
Grundzüge der Programmierung - Hahsler
18
Vergleich von Strings
String s = new String("Hallo");
if (s=="Hallo") { ...
// Fehler: Referenzen werden verglichen!
if (s.equals("Hello")) { ...
/* die richtige Funktion (siehe:
java.lang.String) */
Grundzüge der Programmierung - Hahsler
19
Stringoperationen
• die Java-Bibliothek definiert eine Reihe nützlicher
Funktionen für Strings (siehe: java.lang.String)
String s = "a long string"; string s2;
int i; char ch;
i = s.length();
// bei Arrays kein ()!
ch = s.charAt(3);
i = s.indexOf("ng");
s2= s.substring(2,6)
if (s.startsWith("abc")) {....
Grundzüge der Programmierung - Hahsler
20
java.lang.StringBuffer
• Strings haben nach der Erzeugung eine fixe Länge. Zum
zeichenweisen Aufbau eines Strings ist dies ungeeignet.
int i; // x kann sein char,int,float...
StringBuffer b = new StringBuffer("Hallo");
b.append("rld");
i= b.length();
b.insert(4,"o W");
b.delete(0,4);
// an Stelle 4 einfügen
// Zeichen von 0-4 löschen
b.replace(1,3,"abc");
/* Zeichen 1-3 durch "abc"
ersetzen */
Grundzüge der Programmierung - Hahsler
21
Stringkonversionen
Oft müssen Strings in andere Datentypen
konvertiert werden oder umgekehrt:
int i = Integer.parseInt("123");
float f = Float.parseFloat("3.14");
String s = String.valueOf(x);
char[] a = s.toCharArray();
Grundzüge der Programmierung - Hahsler
22
Nach dieser Einheit sollten Sie
wissen, ...
• was der Unterschied zwischen primitiven und
Objekt-Datentypen ist
• wie Objekt-Datentypen erzeugt, verwendet uns
als Parameter übergeben werden
• wie Strings in Java funktionieren
Grundzüge der Programmierung - Hahsler
23
Java Einführung
Umsetzung von Beziehungen
zwischen Klassen
Kapitel 7
Inhalt
• Wiederholung:
Klassendiagramm in UML
• Java-Umsetzung von
• Generalisierung
• Komposition
• Assoziationen
Grundzüge der Programmierung - Hahsler
2
Das Klassendiagramm
• Zweck der Darstellung
• Logischen Aufbau des Systems
• Statischen Aspekte
• Zusammenhänge und Beziehungen zwischen den
Komponenten
Grundzüge der Programmierung - Hahsler
3
Klassen in UML
Klassen sind die Baupläne für Objekte (Instanzen)
Darstellung in UML
Klassenname
oder
Klassenname
Beispiel einer Klasse in UML
PKW
Farbe
Leistung
Geschwindigkeit
....
Attribute
Methoden
Beschleunigen()
Bremsen()
Lenken()
...
Klasse
Grundzüge der Programmierung - Hahsler
W59777: PKW
Rot
50km
Objekte (Instanzen)
4
Elemente Klassendiagramm I
• Klassen
Klassenname
• Beziehungen (Paths/Associations): für die Übermittlung
von Nachrichten (Messages = Aufruf von Methoden)
Klasse A
spricht mit
Klasse B
• Richtung der Beziehungen (Navigability): Nachrichten
können nur in diese Richtung gehen
Klasse A
spricht mit
Klasse B
Grundzüge der Programmierung - Hahsler
5
Elemente Klassendiagramm II
• Kardinalitäten (Multiplicity): Anzahl der möglichen Instanzen
Klasse A 1
spricht mit
0..* Klasse B
• Aggregation (Aggregation/Composition): Besteht-aus Beziehung
besteht aus
Auto
1
*
Einzelteile
• Generalisierung (Generalization): is-a Beziehung -> Vererbung in
Java
Einzelteil
Motor
Karosserie
...
Grundzüge der Programmierung - Hahsler
6
Elemente Klassendiagramm III
• Abhängigkeiten (Dependencies)
benötigt
Klasse A
Klasse B
• Anmerkungen oder Einschränkung
PKW ist nur fahrttüchtig
mit: Räder, Karosserie,...
PKW
Grundzüge der Programmierung - Hahsler
7
Beispiel: Klassendiagramm
PKW ist nur fahrttüchtig
mit: Räder, Karosserie,...
besteht aus
PKW
1
Einzelteil
*
0..*
verwendet
1
Motor
besteht aus
Fahrzeughalter
Karosserieteil
...
1
4
Zylinder
Grundzüge der Programmierung - Hahsler
8
Umsetzung von Generalisierung
Einzelteil
Vererbung
Motor
Karosserie
...
abstract class Einzelteil {
// muss nicht unbedingt abstract sein!
...
}
class Motor extends Einzelteil {
...
}
Grundzüge der Programmierung - Hahsler
9
Umsetzung von Komposition I
PKW
besteht aus
1
Rad
4
class Rad {...}
class PKW {
Rad liVoRad, reVoRad, liHiRad, reHiRad; //Instanznamen
PKW() {
/* Erzeugung der Instanzen der Räder */
liVoRad
reVoRad
liHiRad
reHiRad
=
=
=
=
new
new
new
new
Rad();
Rad();
Rad();
Rad();
}
}
Grundzüge der Programmierung - Hahsler
10
Umsetzung von Komposition II
PKW
besteht aus
1
Einzelteil
*
class Einzelteil {...}
class PKW {
final int ANZAHL=100; // besteht aus 100 Teilen
Einzelteil[] dieEinzelteile; /* Implementierung als Array
von Instanznamen (auch als Container moeglich) */
PKW() {
dieEinzelteile = new Einzelteil[ANZAHL]; /* Array
erzeugen */
for(int i=0;i<ANZAHL; i++) {
dieEinzelteile[i] = new Einzelteil(); /* Erzeugung
der Instanzen der Einzelteile */
}
}
}
Grundzüge der Programmierung - Hahsler
11
Umsetzung einer Assoziation
class PKW {...}
class Fahrzeughalter {
PKW
PKW meinPKW; // nur Instanzname
...
1
void PKWkaufen(PKW einPKW) {
verwendet
1
meinPKW=einPKW; // Referenz auf die Inst. setzen
}
}
Fahrzeughalter
class Michael {
public static void main(String[] args) {
PKW PKW1 = new PKW(); // PKW erzeugen
Fahrzeughalter michael = new Fahrzeughalter();
michael.PWKkaufen(PKW1);
// PKW an den Farzeughalter uebergeben
}
}
Grundzüge der Programmierung - Hahsler
12
Umsetzung von komplexeren
Assoziationen
• Assoziationen mit höherer (>1) Kardinalität
• Es muss ein Container (z.B. Array, Liste) verwendet
werden.
• Assoziationen mit Navigierbarkeit in beide
Richtungen:
• Jede Seite muss eine Referenz der anderen Seite
haben.
Achtung: Problem mit Inkonsistenz!
Grundzüge der Programmierung - Hahsler
13
Übung
• Implementieren Sie das gesamte Klassendiagramm.
Überlegen Sie sich sinnvolle Attribute und Methoden
sowie Einzelteile (mindestens 4).
besteht aus
PKW
1
Einzelteil
*
0..*
verwendet
1
Motor
besteht aus
Fahrzeughalter
Karosserie
...
1
4
Zylinder
Grundzüge der Programmierung - Hahsler
14
Nach dieser Einheit sollten Sie
wissen, ...
• wie Beziehungen in UML-Klassendiagrammen
dargestellt werden
• welche Arten von Beziehungen es gibt
• wie diese Beziehungen in Java umgesetzt
werden können.
Grundzüge der Programmierung - Hahsler
15