Übungsbeginn: 17.4. (B-Woche) bzw. 23.4. (A-Woche)Erstes Übungsblatt: 11.4. im Netz (Lernserver)Abgabe der Lösungen jeweils 2 Wochen nach Ausgabe,5 Minuten vor der Vorlesung
Ausnahme: erste Abgabe erst am 2.5.
Übungsschein: mindestens 60% der erreichbarenPunkte
Prüfungsklausur
im Juli, Termin wird noch bekannt gegebenZulassungsbedingungen:
(1) Übungsschein ´Digitale Informationsverarbeitung´ und(2) Übungsschein ´Programmierung und Programmiersprachen´
Organisatorisches
Programmierung und Programmiersprachen
Dr. Claudia LeopoldInstitut für Informatik
Abt. Parallelverarbeitung undKomplexe Systeme
Webseite zur Vorlesung (über Lernserver erreichbar):http://www.informatik.uni-leipzig.de/~leopold/grundPS.html
[email protected]äude, Zi. 2-40
Inhalt (Plan)
1. Objektorientierte Programmierung und Modellierung
-> Hauptteil
2. Parallele und verteilte Programmierung
3. Skriptsprachen
4. Maschinennahe Programmierung
einschl. Aspekte der Implementierung höhererProgrammiersprachen
5. Zusammenfassender Überblick zu Programmier-sprachen
Fortsetzung des in der Vorlesung ´Digitale Informationsverarbeitung´begonnenen Überblicks zu Programmiersprachen
ÜbungenMo (A/B)
Mo (A/B)
Mo (A/B)
Di (A/B)
Mi (A/B)
Fr (A/B)
Fr (A/B)
11.15 - 12.45
13.15 - 14.45
15.15 - 16.45
9.15 - 10.45
7.30 - 9.00
7.30 - 9.00
7.30 - 9.00
SR 3-11
SR 3-11
SR 3-11
SR 3-05
HS 8
SR 3-11
SR 3-01
Herr Dr. Richter
Herr Dr. Richter
Herr Dr. Richter
Herr Dr. Richter
Herr Wittig
Herr Wittig
Herr Dr. Gräbe
Verbindliche Anmeldung durch Eintragen in die Liste.
Adressen der Übungsleiter:[email protected] bzw. wittig@...
1. Objektorientierte
Programmierung und
Modellierung
LiteraturWolfgang Küchlin, Andreas Weber: Einführung in die Informatik:Objektorientiert mit Java, Springer-Verlag, 2000, Kapitel 3,7,8.
Bernd Oesterreich: Objektorientierte Softwareentwicklung:Analyse und Design mit der Unified Modeling Language,4. Auflage, Oldenbourg Verlag, 1999.
Bert W. Sebesta: Concepts of Programming Languages, 4. Auflage,Addison-Wesley, 1999.
Java-Lehrbuch, zum Beispiel:
Guido Krüger: Go to Java 2, 2. Auflage, Addison-Wesley, 1999.
Stefan Middendorf, Reiner Singer: Java: Programmierhandbuchund Referenz, 2. Auflage, dpunkt-Verlag, 1999.
James Gosling et al.: The Java Language Specification, 2. Auflage,Sun Press, 2000, online verfügbar.
Weitere Literatur wird im Laufe der Vorlesung genannt.
Programmierung und Modellierung
Objektorientierung wurde besonders für die Entwicklungkomplexer Softwaresysteme konzipiert
-> Modellierung und Programmierung bilden Einheit
Programmierung Softwareentwicklung
Planmäßiges, systematischesVorgehenArbeitsteilige EntwicklungUmfangreiche ProgrammeAnalyse/Design vor eigentlicherImplementierung
Vorteile OO (vs. imperativ, funktional, logisch):Beschreibung komplexer, dynamischer Systeme
Erweiterte Möglichkeiten zur Strukturierung von Programmen
Gliederung
1.1. Grundlegende Konzepte der Objektorientierung
1.2. Objektorientierte Modellierung (UML)
1.3. Einführung in Java
1.4. Objektorientierte Programmierung in Java
1.5. Weitere Aspekte der Java-Programmierung
Ausnahmen
Generisches Programmieren
Objektorientierung
OO modelliert die reale Welt als System inter-agierender Objekte
Objekt = gedankliche oder reale Einheit in derUmwelt und/oder in Software
Grundlegende Konzepte:
Datenkapselung
Nachrichtenaustausch
Bilden von Klassen
Vererbung
Polymorphie
Dynamisches Binden
1.1. Grundlegende Konzepte der
Objektorientierung
Beispiel: Objekt
rectangle1
Attribute: x
y
width
height
Methoden: draw()
delete()
move()
10
20
120
75
Modifikatoren: private, public
Datenkapselung
Objekt umfaßt
Attribute (Zustandsvariablen, Felder, Daten) und
Methoden (Operationen, Funktionen)
Abstrakter DatentypZusammenfassung von Daten und Operationen über diesenDaten
Implementierung der Datenstrukturen und Operationen istaußerhalb des Objektes nicht sichtbar
Zugriff auf Daten nur über Operationen (get, set und andere)
Konzept existiert auch in nicht-objektorientierten Sprachen(z.B. Modula-2)
Nachrichtenaustausch
Objekte
Nachrichten
Vorteile der Datenkapselung
Klar definierte Schnittstellen unterstützen arbeits-teilige Programmentwicklung (Programmieren imGroßen)
Implementierungsdetails nur innerhalb desObjektes sichtbar -> Implementierung kann ohneAnpassung der übrigen Programmteile geändertwerden (bei gleicher Signatur)
Erleichtert Debugging, da Fehler besser lokalisierbar
Klasse= Zusammenfassung gleichartiger Objekte
gleiche Attribute, aber unterschiedliche Attributwerte
gleiche Methoden
Klasse umfaßt
Attribute, aber keine Attributwerte (Ausnahme: Klassenvariablen)
Methoden
Objekte
Osterei Klasse
Nachrichten
Aufbau einer Nachricht
Empfänger Methodenname Argumente
Beispiele: rect.move(20,0), rect.delete()
Senden einer Nachricht bewirkt Aufruf der entsprechendenMethode des Zielobjektes
Nachrichtenaustausch dient
Übermittlung von Informationen
Inanspruchnahme von Diensten (Client/Server)
Instanzierung
Vorgehen bei objektorientierter Programmierung:
1. Definition einer Klasseeinschließlich Implementierung der Methoden
2. Instanzierung
= ´Ableiten´ von Objekten aus der Klasse
Attribute werden angelegt und initialisiert (zumBeispiel mit default-Werten)
Methoden (einschließlich Implementierung)werden ausKlassendefinition übernommen
Objekte heißen Exemplar oder Instanz der Klasse
Klasse beschreibt Typ des Objekts.
Beispiel: Klasseclass Rectangle{
private int x, y, width, height;
public void move(int dx, int dy) {x = x + dx;y = y + dy;
}
public void draw() {...}
public void delete() {...}
}
Beispiel: Vererbung
blaues Rechteck
Attribute: x
y
width
height
Methoden: draw()
delete()
move()
ink
refill()
10
20
120
75
blue
VererbungBei der Definition von Klassen kann man bereitsdefinierte Klassen als Basis verwenden.
Vorteile: Wiederverwendung von Programmcode,hierarchische Strukturierung von Programmen,Erweiterbarkeit
Beispiel: class coloredRectangle extends Rectangle{
ink: Color;
public void refill(newInk:Color) {ink = newInk;
}}
Oberklasse (Superklasse, Basisklasse): RectangleUnterklasse (Subklasse, abgeleitete Klasse): coloredRectangle
Überladen von Methoden
= Definition von Methoden mit gleichem Namen,aber unterschiedlicher Signatur
Beispiel:
public void scale(factor: float) {x = x * factor; y = y * factor;
}
public void scale(factorX: float, factorY: float) {x = x * factorX; y = y * factorY;
}
Aufruf bewirkt Ausführung der Methode mit denpassenden Parametern
scale(1.3) vs. scale(1.2, 3.7)
Überschreiben von Methoden
In der Oberklasse bereits implementierte Methoden könnenin der Unterklasse mit einer neuen Implementierungüberschrieben werden (engl.: override).
Beide Methoden haben dann den gleichen Namen und diegleiche Signatur.
Beispiel:Reimplementierung der Methode draw in coloredRectangle
Aufruf der Methode bewirkt:Für Objekte der Oberklasse wird die Methode der Oberklasseausgeführt.Für Objekte der Unterklasse wird die Methode der Unterklasseausgeführt.
Dynamische Polymorphie
Variable kann für Objekte verschiedener Klassenstehen, sofern eine - eventuell mehrstufige -Vererbungsbeziehung besteht .
Beispiel:
rect: Rectangle;
rect := new Rectangle();rect.draw(); - Aufruf der Methode aus Klasse Rectangle
rect := new coloredRectangle();rect.draw(); - Aufruf der Methode aus Klasse coloredRectangle
Polymorphie (Vielgestaltigkeit)
= Methode (gegeben durch Name) kann sich an Kontextanpassen
Unterscheiden:
statische Polymorphie (Überladen)
auch in nicht-objektorientierten Sprachen, z.B. ´/´ für intund float
dynamische Polymorphie (Überschreiben)
Verhalten der Methode sollte nur angepaßt, aber nichtgrundsätzlich geändert werden (Gefahr von Programmier-fehlern)
Arbeiten mit Objekten
Allgemeine Operationen für Objekte:Erzeugen
Vergleich
Zuweisung
evtl. Löschen (z.B. in C++)
Erzeugenvon Objekten:
durch Konstruktor = spezielle Methode der jeweiligenKlasse
eventuell überladen
in Java existiert impliziter Konstruktor
Dynamische Bindung
= Verknüpfung zwischen Methodenaufruf undauszuführendem Programmcode erfolgt erst zur Laufzeit
Statische Bindung = Verknüpfung erfolgt zurÜbersetzungszeit, durch den Compiler
Vorteil statische Bindung: Geschwindigkeit (schnellereProgrammausführung)
Vorteil dynamische Bindung: Keine Fallunterscheidungnötig ->
bessere Lesbarkeit
Programm leichter zu modifizieren
Art der Bindung ist durch Programmiersprache festgelegt,evtl. mit Einflußmöglichkeit durch Programmierer
Objektidentität vs. Objektgleichheit
rect1: Rectangle := new Rectangle();rect2: Rectangle := new Rectangle();
rect1 := rect2;
o Rectanglerect1
o Rectanglerect12
o Rectanglerect1
o Rectanglerect12
Objektgleichheit(gleiche Initialisierungoder kopieren der Attr.)
Objektidentität(zuweisen)
Zuweisung von Objekten
An Variablen mit Typ der Oberklasse können Objekte derUnterklasse zugewiesen werden, aber nicht umgekehrt
Beispiel:
rect: Rectangle := new Rectangle();cRect: coloredRectangle := new coloredRectangle();
rect := cRect; - zulässigcRect := rect; - verboten
Unterscheiden: deklarierter Typ - tatsächlicher Typeiner Variablen
Vorteile OO
Strukturierung der Programme sehr gut unterstützt
Wiederverwendung, Erweiterbarkeit
siehe auch: abstrakter Datentyp, dynamische Bindung,abstrakte Klasse
Nachteile OO
Hoher Einarbeitungsaufwand (OO-Denkweise,Klassenbibliotheken)
Wegen dynamischer Speicherverwaltung ofthöherer Speicherbedarf und längere Laufzeit
Abstrakte KlassenEnthalten deklarierte, aber noch nicht implementierteMethoden
Instanzierung nicht möglich
Deklarierte Methoden müssen in jeder Unterklassevorhanden sein, werden aber unterschiedlichimplementiert
Vorteile: einheitliche Schnittstelle, Client kann unabhängigvon Server programmiert werden
Rechteck
Beispiel:Geometrische Figur
berechneFläche
Kreis Dreieck
Vom Problem zum Programm
AnalyseEinarbeitung in Anwendungsgebiet
Beschreiben von Anwendungsfällen
Erstellen eines objektorientierten Modells der realen Welt
Spezifikation der Funktionalität des künftigen Softwaresystems
Annahme einer perfekten Technik
EntwurfÜbertragung des Modells der realen Welt in die Welt der Software
Berücksichtigung der vorhandenen Technik und Programmier-sprache
Algorithmische Beschreibung der Funktionalität
ImplementierungSoftware-Architektur wird zum realen Programm
PPS 1.2-2
1.2. Objektorientierte Modellierung
PPS 1.2-1
Geschichte der UML
Ca. 1989-1994 Forschungsarbeiten zu objektorientiertenModellierungsansätzen
Darauf aufbauend ab 1994/95 Entwicklung der UMLdurch Grady Booch, Jim Rumbaughund Ivar Jacobson(Firma: Rational Software)
Seit 1995 Unterstützung durch Object ManagementGroup (OMG) - Entwicklung eines Standards
1996: Version 0.9 Aktuell: Version 1.3
1997: Version 1.0 In Arbeit: Version 2.0
OMG umfaßt >800 Firmen
-> UML ist weit verbreitet
PPS 1.2-4
Unified Modeling Language (UML)Sprache und grafische Notation zur Spezifikation,Visualisierung, Konstruktion und Dokumentation von(Software)systemen
Durchgängige Unterstützung für Analyse und Designdurch aufeinander abgestimmte Modelltypen
Anwendungsfalldiagramm
Klassendiagramm
Kollaborationsdiagramm
Sequenzdiagramm
und andere
Geeignet für objektorientierte Softwareentwicklung
UML ist keine Programmiersprache!Aber ex. Werkzeuge, die automatische Codeerzeugung unterstützen
Vorgehensmodell ist nicht Bestandteil der UML PPS 1.2-3
ObjekteMitunter werden in Klassendiagrammen auch Objektedargestellt.
Zur Unterscheidung von Klassennamen werden Objektnamenunterstrichen.
Evtl. Angabe von zugehöriger Klasse und Attributwerten
Beispiele:
:Rechteck
rect: Rechteck
x = 0y = 0
rect
Rechteck rect<< instance of >>
PPS 1.2-6
Klassendiagramm
Beschreibt Klassen und ihre statischen Beziehungenuntereinander
Beziehungen zwischen Klassen stehen stellvertretend fürBeziehungen zwischen Objekten
Darstellung von Klassen kann unterschiedlich detaillierterfolgen (evtl. Angabe von Typ, Initialwert, Zusicherungen):
anzeigen()
verschieben()
löschen()
x: int = 0
breite: int {breite>0}
höhe: int {höhe<=breite}
anzeigen()
verschieben(dx:int, dy:int)
löschen()
Rechteck Rechteck
Rechteck
Rechteck
xy
width
Aggregation
auch: Teil-Ganzes-Beziehung, Hat-Beziehung
Eine Aggregation ist die Zusammensetzung einesObjektes aus einer Menge von Teilobjekten
ist Spezialfall der Assoziation
Unternehmen1besteht aus Mitarbeiter
1..*Abteilung
11..*besteht aus
besteht aus Mitarbeiter1..*
Abteilung1..* arbeitet für
PPS 1.2-8
Assoziationen
Assoziationen beschreiben allgemeine Beziehungenzwischen Objektenwerden auch Benutzt-Beziehungen genanntmöglich: ungerichtete, bidirektionale Beziehungen
Person Schrank1 0..*besitzt
Firma Person0..1 0..*beschäftigtarbeitgeber arbeitnehmer
Firma Person0..1 0..*beschäftigt
arbeitet bei
PPS 1.2-7
Methodenaufrufe bei Aggregationen
Typische Programmstruktur:
Methoden zur Zusammenarbeit mit anderen (´fremden´)Objekten werden vom Gesamtobjekt zur Verfügunggestellt
Der Aufruf einer solchen Methode bewirkt den Aufrufgeeigneter Methoden der Teilobjekte.
Dazu enthält die Implementierung der Methode desGesamtobjekts entsprechende Methodenaufrufe an dieTeilobjekte. (im Klassendiagramm nicht sichtbar)
PPS 1.2-10
Beispiel: Der Warenwert eines Einkaufskorbes berechnet sich alsSumme der Einzelpreise.
Komposition
Spezialfall der Aggregation, bei dem die Einzelteile vomAggregat existenzabhängig sind
Markierung durch ausgefüllte Raute
PPS 1.2-9
hatVorderseite
Zettel 1
Rückseite
hat1
1
1
Mehrgliedrige Assoziation
PPS 1.2-12
Zug
datumzugnummer
Platz
wagennrplatznr
Fahrgast
name
1 1..*
1..*
Reservierung
Assoziationen zwischen > 3 Klassen analog
Gleiche Klasse kann mehrfach an einer Assoziationbeteiligt sein
Rekursive Assoziation
PPS 1.2-11
Direkte Rekursion: Mitarbeitersachbearbeiter
manager
*
1
Indirekte Rekursion:
führt
namezimmernummer
Patient
Person
*
hat
familien-angehöriger
1
Attributierte Assoziation
Assoziation, der Eigenschaften zugeordnet sind
diese Eigenschaften charakterisieren weder die eine nochdie andere Klasse, sondern die Assoziation selbst
Modellierung durch Assoziationsklasse
PPS 1.2-14
Unternehmenname
anschrift
Mitarbeitername
anschrift
1..*1..*
Arbeitsverhältnis
von: Datumbis: Datum
Implementierung von Assoziationen
meist mittels Attributen in den beteiligten Klassen
häufig: Attributname = Rollenname in der Assoziation
gegebenenfalls Verwendung von Arrays oder anderenSammlungsklassen
PPS 1.2-13
Person Schrank1 0..*besitzteigentümer
class Person{
...Schrank[] einrichtung;...
}
class Schrank{
...Person eigentümer;...
}
einrichtung
Vererbung - Notation
PPS 1.2-16
Unterklasse5Unterklasse1
Oberklasse
Unterklasse3Unterklasse2 Unterklasse4
Diskriminator1 Diskriminator3
Diskriminator2
Diskriminator muss nicht angegeben werden
auch bei gleichem Diskriminator sind Einzelpfeilezulässig
Vererbung
auch: Ist-BeziehungUnterklasse ist Spezialisierung der Oberklasse
Objekte abgeleiteter Klassen sollen jederzeit anstelle vonObjekten ihrer Basisklasse eingesetzt werden können
Oberklasse ist Generalisierung der UnterklasseUnterscheidungsmerkmal zwischen Ober- und Unterklasse:DiskriminatorDiskriminator ist ´virtuelles Attribut´ (durch Zugehörigkeitzur einen oder anderen Unterklasse wird eine Eigenschaftdes Objekts beschrieben)Zuordnung der Attribute und Methoden zur Ober- oderUnterklasse sollte nach inhaltlichen Gesichtspunktenerfolgen (nicht: maximale Wiederverwendung)
PPS 1.2-15
Quadrat/Rechteck-Problem I
PPS 1.2-18
Nachteile:
Redundanz (b ist überflüssig)
Zusicherung verwendet Attributeder Oberklasse -> Einhaltungdurch Methoden der Oberklassenicht garantiert (Zusicherungdort nicht bekannt)
Rechtecka {a>0}b {b>0}
setKanten(na,nb)anzeigen()entfernen()
Quadrat
{a=b}
Vererbung - Beispiel
PPS 1.2-17
GeomFigur{abstrakt}
x,y: intsichtbar: bool
anzeigen() {abstrakt}entfernen() {abstrakt}verschiebeZu(nx,ny)
Rechtecka {a>0}b {b>0}
setKanten(a,b)anzeigen()entfernen()
Dreiecka {0<a<b+c}b {0<b<a+c}c {0<c<a+b}
setKanten(a,b,c)anzeigen()entfernen()
Figurenform
Kreisradius {radius > 0}
setRadius(r)anzeigen()entfernen()
Quadrat/Rechteck-Problem III
PPS 1.2-20
Beste Variante, hat trotzdem Nachteilder Redundanz
Günstig: Keine Unterscheidung zwischenRechtecken, die aufgrund ihrer Kantenlänge ´zufällig´Quadrate sind und´richtigen´ (entsprechend klassifizierten) Quadraten
Rechtecka {a>0}b {b>0}
setKanten(a,b)anzeigen()entfernen()
isQuadrat():bool
Quadrat/Rechteck-Problem II
PPS 1.2-19
Quadrata {a>0}
setA(na)anzeigen()entfernen()
Rechteck
b {b>0}setB(nb)
anzeigen()entfernen()
Nachteile:
ex. kein Diskriminator
Zuweisung q=r ist zulässig, aberinhaltlich nicht sinnvoll
-> fehleranfällig
->Ungeeignete Modellierung
Mehrfachvererbung
PPS 1.2-22
Klasse kann mehr als eine Oberklasse besitzen
Einfachvererbung - Klassenhierarchie,Mehrfachvererbung - azyklischer Graph
Fahrzeug
Wasser-fahrzeug
WindgetriebenesFahrzeug
Segelboot
name
Mehrfachvererbung ist problematisch
Klassenhierarchien
PPS 1.2-21
GeomFigur Strecke
2dimGeomFigur
3dimGeomFigur
Kreis
abstrakte Klasse
konkrete Klasse
Rechteck
Dreieck
Kugel
Quader
Vom Problem zum Modell
1) Grammatikalische Inspektion der Spezifikation
Substantive - Klassen, Objekte
Verben - Methoden
´hat ein´, ´besteht aus´ - Aggregationen
´ist ein´ - Vererbungsbeziehungen
2) CRC-Karten
Class-Responsibilities-Collaborators =
Klasse - Verantwortlichkeiten - Beteiligte
3) Analyse von Anwendungsfällen
engl.: use case
PPS 1.2-24
Klassenattribute
Beschreiben Eigenschaft der Klasse
Alle Objekte der Klasse haben Zugriff auf dieses Attribut(lesen den gleichen Wert)
weiterhin ex. Klassenmethoden
PPS 1.2-23
HausanzHäuser
adresse
getAnzHäuser()getAdresse
Beschreibung eines Anwendungsfalls
Umfaßt (teils optional):
Akteure
Vor- und Nachbedingungen, Invarianten
Nicht-funktionale Anforderungen (z.B. Antwortzeit, Priorität)
Ablaufbeschreibung (wichtigster Teil, stets vorhanden)
Ausnahmen, Fehlersituationen
Variationen
Dienste (notwendige Klassen, Methoden - für späteres Design)
Verfasser, verwendete Materialien
Offene Fragen, Alternativen, Entwurfsentscheidungen
Verweise auf verwandte Diagramme
PPS 1.2-26
Anwendungsfall
beschreibt externes Systemverhalten in begrenzterArbeitssituation
beschreibt was das System leisten soll, aber nicht wie
Anwendungsfall umfaßt meist mehrere Varianten, die alsSzenarien bezeichnet werden
Anwendungsfall wird durch Akteur (häufig Nutzer inbestimmter Rolle) initiiert und führt zu außerhalb desSystems sichtbarem Ergebnis
Einsatz in Analysephase: Erfassen der Aufgabenstellungund Abstimmung mit dem Auftraggeber
PPS 1.2-25
Anwendungsfalldiagramm
Übersicht zu den verschiedenen Anwendungsfällen
beschreibt Beziehungen zwischen Akteuren undAnwendungsfällen
PPS 1.2-28
Buchausleihe
. .| (
. .| (
Nutzer
. .| (
Besucher
Bibliothekar
recherchieren
verlängern
ausleihen
registrieren
Anwendungsfall - Beispiel
Af2 Vertrag schließen und Kfz-Übergabe
Akteure:
Kunde, Kundenbetreuer
Auslöser:
Kunde möchte sein reserviertes Kfz abholen
Ablauf:
1. Reservierung identifizieren
2. Vertrag erstellen
3. Kfz übergeben
PPS 1.2-27
Zustandsdiagramm
zeigt für ein Objekt die Folge der möglichen Zuständeund Zustandsübergänge
Beschreibung durch endlichen Automat
PPS 1.2-30
Beispiel: Objekt = Ticket
Verfügbar Reserviert Verkauft
ausgeben
abgelaufen
reserv.
absagen
kaufen
zurückgeben
Benutzt.
Verhaltensdiagramme
beschreiben zeitabhängiges Verhalten des Systems
unterscheiden:
Zustandsdiagramm
Zustände und Zustandsübergänge des einzelnen Objekts
Aktivitätsdiagramm
Beschreibung von Abläufen in verschiedenem Kontext
Kollaborationsdiagramm
Zusammenarbeit zwischen Objekten, Betonung Beziehungen
Sequenzdiagramm
Zusammenarbeit zwischen Objekten, Betonung Zeit
PPS 1.2-29
Kollaborationsdiagramm
beschreibt Zusammenarbeit zwischen Objekten inbegrenzter Situation (z.B. Anwendungsfall)
beschreibt Nachrichtenaustausch einschließlichDatenaustausch (Argumente der Methoden)
im Gegensatz zum Sequenzdiagramm stehen dieBeziehungen zwischen den Objekten und nicht derzeitliche Verlauf im Vordergrund
für den Nachrichtenaustausch benötigt der Sender einenVerweis auf den Empfänger :
Assoziation vom Sender zum Empfänger
Verweis wird durch Nachrichtenaustausch übermittelt
Empfänger ist neu erzeugtes Objekt
Empfänger = SenderPPS 1.2-32
Aktivitätsdiagramm
PPS 1.2-31
zur Beschreibung von Abläufen in verschiedenem Kontext
beschreibt Ausführungsreihenfolge von Aktivitäten
parallel oder sequentiell
nächste Aktivität kann vom Ergebnis der vorherigenabhängen
Aktivitäten können Methoden oder komplexereOperationen sein
eventuell Zuordnung der Aktivitäten zur ausführendenKlasse
Kollaborationsdiagramm - Notation
Syntax der Nachrichtenbezeichnung:
[vorgängerBedingung /][sequenzausdruck] : [antwort :=]methodenname (parameterliste)
sequenzausdruck beschreibt Reihenfolge der NachrichtenNachrichten, die während der Bearbeitung der Nachricht Nummer xgesendet werden, erhalten Nummern x.1, x.2 usw.
vorgängerBedingung ist Aufzählung der Nachrichten, dievorher gesendet werden müssen (Bsp. 2.3, 3.1/ 4.2:)
´*´ bezeichnet wiederholtes Senden der gleichenNachricht
Paralleles Senden: 1.2.*||[i:=1..n]:
Bedingtes Senden: 1.2.* [i>5]:
PPS 1.2-34
PPS 1.2-33
Kollaborationsdiagramm - Beispiel
... :Reservierung
:Bestellung
:Bestell-position
1:reserviere(b)
1.1.*[i=1..*]: bpos:=gibBestellPos()
parameter b<< >>
1.1.1: artikel:=gibArtikel()
:Lager1.1.2: anzahl:=gibAnzahl()
1.1.3: bpos:=reserviere(artikel,anzahl)
local bpos<< >>
Sequenzdiagramm - Beispiel
PPS 1.2-36
:Reservierung b:Bestellung bpos:Bestell-position
:Lager
reserviere(b)* gibBestellPos()
bpos
* gibArtikel()
* gibAnzahl()
reserviere(artikel, anzahl)
artikel
anzahl
Sequenzdiagramm
stellt gleiche Information wie Kollaborationsdiagrammdar, aber mit Betonung des zeitlichen Ablaufs
PPS 1.2-35
objekt 1
objekt 2new()
delete()
nachricht()
antwort
objekt 1
Selbstdelegation
Zusammenfassung Modellierung
wird überwiegend in Analyse/Design-Phasen eingesetzt
objektorientierte Modellierung ist eine Form derModellierung
Modelle sind abstrakte Beschreibungen
der realen Welt
existierender Software
zu konstruierender Software
verschiedene Modelltypen beschreiben verschiedeneAspekte des Systems und ergänzen einander
Vorgehensmodell bestimmt, welche Modelltypen inwelcher Reihenfolge wie detailliert erstellt werden(nicht Bestandteil der UML)
PPS 1.2-38
Formen des Nachrichtenaustauschs
Synchronmit Rückantwort (auch: sequentiell, Normalfall in
objektorientierter Programmierung): Sender wartet, bisMethodenausführung beendet
Synchron ohne Rückantwort: Sender wartet, bisEmpfänger die Nachricht angenommen hat
Asynchron: Nachricht wird an Warteschlange desEmpfängers geschickt, Sender arbeitet sofort weiter
Eingeschränkt: Abbruch, falls der Empfänger dieNachricht nicht sofort annimmt
Zeitabhängig: Abbruch, falls der Empfänger die Nachrichtnicht innerhalb einer vorgegebenen Zeit annimmt
PPS 1.2-37
Objektorientierte Programmiersprachen
erste Ideen gehen zurück auf Simula 67(Datenabstraktion, Klassen)
erste und rein objektorientierte Sprache: Smalltalk 80
C++: Erweiterung von C um objektorientierte Konstrukte,erste Version 1984 (danach weiterentwickelt),umfangreiche Sprache, weit verbreitet
Eiffel (ca. 1990): integriert Zusicherungen, einfacher alsC++, relativ geringe praktische Bedeutung
CLOS (1988): integriert objektorientiertes undfunktionales Programmieren
Weitere Sprachen: Ada 95, Oberon, Modula-3, ...
PPS 1.3-2
1.3. Einführung in Java
PPS 1.3-1
Vorteile von Java
PortabilitätJava Virtual Machine JVM, Java Bytecodealle Datentypen in Java sind exakt festgelegt
Unterstützung für Code-Mobilität (Applets)
ObjektorientierungC-ähnliche Syntax (keine Zeiger, aber Verweise)
RobustheitGarbage Collection, AusnahmebehandlungEinschränkung automatischer Typkonvertierung
SicherheitskonzeptUnterstützung für Nebenläufigkeit (Threads)
Unterstützung für grafische OberflächenUmfangreiche Klassenbibliothek
PPS 1.3-4
Entwicklung von Java
1991-1992 Green-Projekt (James Gosling, PatrickNaughton), Ziel: Entwicklung von Hard-/Software fürKonsumelektronik -> Interpreter Oak
1992 Firmengründung zur Vermarktung des PrototypsStar Seven (*7) -> erfolglos
1994 Web Browser HotJava, verwendet Oak
1995 Umbenennung von Oak in Java, Integration inNetscape Navigator
1996 Java Development Kit 1.0, Gründung von JavaSoft
rasantes Wachstum des Interesses an Java
1998 JDK 1.2, neue Bezeichnung Java 2 Platform
2000 JDK 1.3 (Kestrel-Projekt), GeschwindigkeitsgewinnPPS 1.3-3
Beispiel: Hello World
Erstellen der Datei Hello.javapublic class Hello {
public static void main(String args[]) {System.out.println("Hello World!");
}}
Übersetzen des Quelltextesjavac Hello.java -> Hello.class
Ausführen des Programmsjava Hello
PPS 1.3-6
Das JVM-Konzept
PPS 1.3-5
Programm
Bytecode
Compiler (javac)
Interpreter (java)Just-In-Time Compiler
Rechner Rechner
Interpreter(JIT Compiler)
Lexikalische Elemente 2
PPS 1.3-8
Kommentare// Einzeiliger Kommentar bis Zeilenende
/* MehrzeiligeKommentare dürfen nicht geschachteltwerden */
/*** Dokumentationskommentare für javadoc* beschreiben Methoden etc. verbal und kennzeichnen* Parameter und Rückgabewerte.* <i> HTML </i> ist zulässig.* /
Weitere Unterschiede zu C:Kein Präprozessor -> kein #define, #include, #ifdef
Zeilen können nicht mit \ verkettet werden
Lexikalische Elemente 1
Unicode
Zeichen werden in 2 Byte kodiert
Kompatibel zu ASCII-Zeichensatz
char/String-Konstanten sowie Bezeichner im Programm dürfenUmlaute und Sonderzeichen enthalten
Bsp.: übertrag und \u00FCbertrag sind identisch
PPS 1.3-7
Bezeichner
sollten mit Buchstabe, dürfen auch mit ´_´ oder ´$´ beginnen
Schlüsselwörter sind nicht zulässig
Klassennamen groß, z.B. EineKlasse
Variablen-, Attribut- und Methodennamen klein, z.B. eineMethode
Konstantennamen vollständig groß, z.B. LIMIT
C- vs Java-Datentypen
PPS 1.3-10
in Java nicht vorhanden:
Zeiger
Aufzählungstypen (enum)
Verbundtypen (struct und union)
Bitfelder
Typdefinitionen
sizeof-Operator
unsigned, short int, long int
Neu in JavabooleanNaN = Not A Number (undefiniert, entsteht bei Division durch 0)
POSITIVE_INFINITY, NEGATIVE_INFINITY
Primitive Datentypen
PPS 1.3-9
Variablen haben stets einen definierten Wert:
Attribute werden mit 0 (bzw. 0.0 etc.) initialisiert
Lokale Variablen -> Datenflußanalyse durch Compiler
boolean
char
byte
short
int
long
float
double
1 bit
16 bits
8 bits
16 bits
32 bits
64 bits
32 bits
64 bits
true, false
Unicode-Zeichen
ganze Zahl m. Vorz.
- " -
- " -
- " -
Fließkommazahl
- " -
Zeichenketten
Zeichenketten sind Objekte der Klassenjava.lang.String - konstante Zeichenketten, oderjava.lang.StringBuffer - veränderliche Zeichenketten
PPS 1.3-12
Bsp.: String s1 = "Meine "; // oder: new String("Meine ");
StringBuffer s2 = new StringBuffer("Zeichenkette");
Verkettung und Automatische Konvertierung:for (int i=1; i<10; i++)
System.out.println(s1+i+"-te"+s2);
Methoden für String: length(), charAt(), equals(), etc.
Methoden für StringBuffer: length(), append(), insert(), etc.
ArraysArrays sind spezielle Objekte -> werden zur Laufzeit mit newerzeugtLänge wird beim Erzeugen (zur Laufzeit!) festgelegt und kanndanach nicht mehr verändert werdenZur Laufzeit geprüft: 0 <= indexausdruck < array.lengthAutomatische InitialisierungBilden von Unterklassen nicht möglichIndextyp ist int
PPS 1.3-11
int[] a;a = new int[100];
Bsp. 1:
boolean[][] b;b = new boolean[n][m];
Bsp. 2:
//Deklaration// Erzeugung
int[] a = {5,9,2,3};int[][] b= { {0}, {1,2}, {1,2,3} }
Bsp. 3:
Ausdrücke und Operatoren
Ähnlich C:
Arithmetische Operatoren
Vergleichsoperatoren (Ergebnistyp boolean, auch fürObjekte)
Logische Operatoren (für boolean)
&& bzw. || stehen für Kurzschlußauswertung
& bzw. | stehen für vollständige Auswertung
Bitoperatoren
Zuweisungsoperatoren (=, += etc., erzeugen Ergebnis)
Bedingter Ausdruck (a>0 ? b=a : b=-a)
Operatoren für Objekte: instanceof, new, Zugriff (.)
PPS 1.3-14
Typkonvertierung
PPS 1.3-13
Einschränkende Konvertierung erfordert explizites Casting:double x=3.0, y=2.0;int i = (int) (x/y);
Erweiternde Konvertierungen:
Erweiternde Konvertierung erfolgt automatisch bei:
Zuweisungen
arithmetischen Operationen
Methodenaufruf (aktuelle vs formale Parameter)
byte
char
short int long float double
Blöcke und Variablendeklarationen
PPS 1.3-16
Jede Variable hat einen (statischen) Typ
Lokale Variablen dürfen in Blöcken deklariert werden
Lokale Variablen dürfen sich nicht gegenseitigverdecken!
Das Verdecken von Instanz-/Klassenvariablen durchlokale Variablen und Parameter ist dagegen zulässig
Unterscheiden: Instanzvariablen (Attribute)Klassenvariablen (Klassenattribute)Lokale Variablen, Parameter
Konstanten werden durch das Schlüsselwort finalgekennzeichnet, z.B. final int LIMIT = 100;
Anweisungen
Ähnlich C:
Block
Variablendeklaration
Ausdruck (nur: ++, --, Zuweisung, Methodenaufruf,new)
if, switch (nur boolesche Bedingungen)
while, do-while (nur boolesche Bedingungen)
for
Variablendeklarationen, Komma-Operator zulässig
nur boolesche Bedingungen
break, continue (auch mit Label)
return (Compiler prüft Vorhandensein)
PPS 1.3-15
Definition von Klassen
[public] class Klassenname {
Attribut- und Methodendefinitionen
}
mit public: Filename = Klassenname.java
ohne public: Zugriff nur innerhalb des Files (Pakets)möglich
PPS 1.4-2
class Point {int x, y, color;void moveTo(int newX, int newY) {
x=newX; y=newY;}
}
Beispiel:
1.4. Objektorientierte
Programmierung in Java
PPS 1.4-1
Programmstruktur
Betrachten im weiteren Anwendungen (Applikationen);daneben existieren Applets
Ein (einfaches) Java-Quellprogramm umfaßt mehrerejava-Dateien, die jeweils in class-Dateien übersetztwerden (z.B. javac *.java)
In einer Datei (z.B. in Start.java) muß eine Methode mitder Signatur
public static void main(String[] args)
deklariert sein
Bei Aufruf von java Start wird diese Methode aktiviert
main kann dann Objekte anderer Klassen erzeugen unddurch Senden von Nachrichten in die Berechnungeinbeziehen
PPS 1.4-4
Erzeugen von Objekten
PPS 1.4-3
Objekterzeugung bewirkt:Allokierung von SpeicherplatzRückgabe eines VerweisesAufruf eines Konstruktors zur Initialisierung des Objekts
//Klassendeklaration siehe vorige FoliePoint punktA; //ObjektdeklarationpunktA = new Point(); //Objekterzeugung
Beispiel:
Erforderlich: 1) Klassendefinition2) Objektdeklaration (analog Variablendekl.)3) Objekterzeugung (new)
Parameterübergabe
Java verwendet call-by-value (Wertübergabe)Primitive Datentypen können nicht verändert werden
bei Objekten können nur Attribute verändert werden, nichtdas Objekt selbst
Lokale Zuweisungen können durch final verboten werden
PPS 1.4-6
void beispiel (int number, final int number2, Point punkt) {number = 7;// außerhalb der Methode nicht geändertnumber2 = 8; // Fehlermeldungpunkt.x = 3; // Änderung auch außerhalbpunkt = new Point(); // außerhalb keine Änderungpunkt.x = 5;// außerhalb keine Änderung
}
Instanzvariablen und -methoden
In Java können nur Methoden Programmcode enthalten;globale Funktionen (wie in C) gibt es nicht
Im Gegensatz zu Funktionen beziehen sichInstanzmethoden stets auf ein Objekt und damit aufaktuelle Attributwerte
PPS 1.4-5
Zugriff auf Instanzvariablen und -methoden erfolgtdurch Anwendung des Punkt-Operators auf das Objekt,z.B. punktA.color, punktA.moveTo(3,4)
Zur Unterscheidung von Klassenvariablen/-methodenwerden Attribute in Java häufig als Instanzvariablen undMethoden als Instanzmethoden bezeichnet
Konstruktoren
PPS 1.4-8
Konstruktoren haben den gleichen Namen wie die Klasse
Konstruktoren haben keinen Ergebnistyp
In einer Klasse können mehrere (überladene)Konstruktoren definiert sein
Falls ein Konstruktor einen anderen Konstruktor aufruft,so muß dieser Aufruf die erste Anweisung desKonstruktors sein
Ist für eine Klasse kein Konstruktor definiert, so wird einimpliziter Konstruktor verwendet
Arrays als Parameter
Bei formalen Parametern kann die Länge des Arrays offengelassen werden:
PPS 1.4-7
int sum(int[] a) {int erg = 0;for (int i=0; i<a.length; i++)
erg += a[i];return erg;
}
int [] myFeld;myFeld = new int[10];int sum = sum(myFeld);
Beispiel: Konstruktoren
class Point {
int x, y, color;
Point(int x, int y) {
this.x = x; this.y = y; color = 0;
}
Point(int x, int y, int color) {
this(x,y); this.color = color;
}
}
PPS 1.4-10
Das Schlüsselwort this
this ist einVerweis auf das aktuelle Objekt
Verwendung:
Aufruf einer Methode mit dem aktuellen Objekt alsParameter, z.B.
anderesObjekt.dessenMethode(this)
Zugriff auf überdeckte Variablen, z.B.
void moveTo(int x, int y) { this.x = x; this.y = y; }
Zugriff auf andere Konstruktoren einer Klasse
this(x,y)PPS 1.4-9
Beispiel: Klassenvariablen
public Kunde {
static private int anzKunden = 0;
String name;
Kunde(String name) {
this.name = name;
anzKunden++;
}
static int gibAnzKunden() {
return anzKunden;
}
}
PPS 1.4-12
Klassenvariablen und -methoden
werden durch das Schlüsselwort static gekennzeichnet
Zugriff durch Klasse.variable bzw. Klasse.methode(..)
Gültigkeitsbereich Klassenvariablen = gesamtes Programm
Klassenvariablen werden nur einmal für die Klasse, nichtfür jedes einzelne Objekt angelegt
Anwendung Klassenvariablen: Definition von Konstanten
static final double PI = 3.14;
Klassenmethoden können nicht auf Instanzvariablen und-methoden ihrer Klasse zugreifen
Anwendung Klassenmethoden: Berechnungmathematischer Funktionen
PPS 1.4-11
Vererbung
nur Einfachvererbung möglich
Kennzeichnung durch Schlüsselwort extends
alle Klassen sind Nachfahren der Klasse java.lang.Object
Zugriff auf Oberklasse durch Schlüsselwort super
(Zugriff auf Konstruktoren und überschriebene Methoden)
PPS 1.4-14
public class BlinkingPoint extends Point {boolean blinkt;public void blinkenAus() {blinkt = false;}public BlinkingPoint(int x, int y) {
super(x,y);this.blinkt = false;
}}
Initialisierung von Klassenvariablen
Klassenvariablen werden bei der Deklaration oder durchstatische Konstruktoren initialisiert
In beiden Fällen erfolgt die Wertzuweisung beim Ladender Klasse
Initialisierungen werden in textueller Reihenfolgeausgeführt
PPS 1.4-13
class Beispiel {
static int i=3;
static int j;
static {
j=3*i;
}
Vererbung und ÜberladenÜberladene Methoden müssen sich in den Parametern(nicht nur im Ergebnistyp) voneinander unterscheiden
Die Auswahl der Methode erfolgt zur Übersetzungszeit
Falls eindeutig bestimmt, wird die Methode mit denpassenden Parametern (Anzahl, Typ) ausgewählt
Falls die Parameter verschiedener Methoden inVererbungsbeziehung zueinander stehen oderanderweitig eine Typkonvertierung möglich ist, wird dieMethode mit den speziellsten Parametern ausgewählt
PPS 1.4-16
// Son sei Unterklasse von FatherSon son = new Son();public void test (Father father) {...};public void test (Son son) {...};test(son); // bewirkt Aufruf der Son-Variante
Vererbung und Konstruktoren
1) Anlegen des Speicherbereiches, Initialisieren mit 02) Aufruf des passenden Konstruktors, dabei rekursiveAnwendung der folgenden Regeln:
a) Falls der Konstruktor mit einem Aufruf von super (oder this)beginnt, zunächst Aufruf des entsprechenden Konstruktorsb) Falls a) nicht zutrifft und die Oberklasse keinen explizitenKonstruktor enthält, Aufruf des Default-Konstruktors derOberklassec) Falls a), b) nicht zutrifft und die Oberklasse einenparameterlosen Konstruktor enthält, Aufruf diesesKonstruktorsd) Falls a), b), c) nicht zutrifft -> Fehlermeldung
3) Initialisierung der Attribute und lokalen Variablen desKonstruktors, falls Deklaration mit Zuweisung verbunden4) Ausführung der Anweisungen des Konstruktors
PPS 1.4-15
Beispiel 2 zum Überladen
public class Bsp {public static void main(String args[]) {
Son son = new Son();Aufrufer aufrufer = new Aufrufer();aufrufer.test(son);
}}
PPS 1.4-18
public class Aufrufer {public void test(Father father) {...}
// Bei nachträglichem Hinzufügen ohne Neuübersetzung von// Bsp.java nicht berücksichtigt:public void test(Son son) {...}
}
Beispiel 1 zum Überladen
public class Bsp {public static void main(String args[]) {
Son son = new Son(); // Son sei Unterklasse von FatherFather father = son;Aufrufer aufrufer = new Aufrufer();aufrufer.test(father);
}}
PPS 1.4-17
public class Aufrufer {public void test(Son son) {...} // Son-Variantepublic void test(Father father) {...} // Father-Variante
}
Auswahl der Methode zur Übersetzungszeit-> Auswahl nach statischem Typ-> Es wird die Father-Variante von test aufgerufen
Beispiele zum Überdecken
PPS 1.4-20
class Point {int x, y, color;...
}class RealPoint extends Point {
float x, y, color;int i = super.x;...
}
RealPoint rp = new RealPoint();Point p = rp;float f = rp.x;int i = p.x; // Auswahl laut statischem Typ
Bsp.1
Bsp.2
Überdecken von Variablen
Vererbung kann zum Überdecken von Instanzvariablenführen
PPS 1.4-19
class Point {int x, y, color;...
}class RealPoint extends Point {
float x, y, color;...
}
Überdeckte Variablen sind lebendig, aber nicht sichtbar
Zugriff durch super möglich
Auswahl erfolgt zur Übersetzungszeit (laut statischem Typ)
Überdecken von Variablen sollte vermieden werden
Beispiel 1 zur Typkonvertierung
Zugriff auf Methoden und Attribute, die nur in derUnterklasse definiert sind
PPS 1.4-22
class BlinkingPoint extends Point {boolean blinkt;public void blinkenAus() {...}
}...BlinkingPoint bp = new BlinkingPoint();Point p = bp;if (((BlinkingPoint) p).blinkt)
((BlinkingPoint) p).blinkenAus();
Typkonvertierung für Objekte
Änderung des für den Compiler relevanten Typs
PPS 1.4-21
RealPoint rp = new RealPoint();Point p = rp;RealPoint rp2 = p; // Fehlermeldung des CompilersRealPoint rp2 = (RealPoint) p;
Voraussetzung: neuer Typ = dynamischer Typ oderneuer Typ = Oberklasse des dynamischen Typs
Andernfalls wird zur Laufzeit eine Ausnahme ausgelöst
Dieser Fall sollte durch Verwendung von instanceofvermieden werden
if (p instanceof RealPoint)RealPoint rp2 = (RealPoint) p;
Überschreiben, Überladen und Überdecken
Überschreiben und Überladen beziehen sich auf Methoden;Überdecken bezieht sich auf Attribute
beim Überschreiben haben alle Parameter den gleichen Typ,beim Überladen gibt es Unterschiede
gleiche Parametertypen, aber unterschiedlicher Ergebnistyp-> Fehlermeldung durch Compiler
überschriebene Methoden werden dynamisch gebunden,überdeckte Attribute werden statisch gebunden
Konsequenz: bei Methoden ist kein Typcast nötig, falls neuerTyp = dynamischer Typ
Klassenmethoden werden nicht überschrieben, sondern neudefiniert
Klassen- und Instanzmethoden mit gleicher Signatur sindnicht zulässig
PPS 1.4-24
Beispiel 2 zur Typkonvertierung
Zugriff auf überdeckte Variablen
PPS 1.4-23
class Point {int x, y, color;...
}class RealPoint extends Point {
float x, y, color;...
}...RealPoint rp = new RealPoint();Point p = rp;int i = ((Point) rp).x;float f = ((RealPoint) p).x;
Wrapper-Klassen
Jedem primitiven Typ ist eine Wrapper-Klassezugeordnet: int - Integer, float - Float etc.
Nutzen:
Die Wrapperklassen sind Unterklassen von Object undstellen zusätzliche Methoden zur Verfügung
Viele Methoden (z.B. der Klasse Vector) verlangen alsParameter Objekte
Keine automatische Konvertierung
PPS 1.4-26
myVector.addElement(new Integer(7));
float f = 1.23f;String s = Float.toString(f)
Beispiel zum Überschreiben, -laden, -decken
class Point {
int x = 0, y = 0;
void move(int dx, int dy) { x += dx; y += dy; }
int color;
}
class RealPoint extends Point {
float x = 0.0f, y = 0.0f;
void move(int dx, int dy) { move((float) dx, (float) dy); }
void move(float dx, float dy) { x += dx; y += dy; }
}
PPS 1.4-25
Pakete
Kennzeichnung durch package paketname; als ersteAnweisung in allen Klassen des Pakets
Nutzen: Strukturierung des Programms:
Gruppieren von Quellfiles
getrennte Namensräume
Pakete können Klassen und/oder Unterpakete enthalten
Paketstruktur entspricht Verzeichnisstruktur
Paketname = Verzeichnisname
Bezeichnung für Unterpakete: grossesPaket.unterpaket
Klassen ohne package-Anweisung gehören alle zurgleichen (namenlosen) Klasse
Pakete können archiviert werden (jar)PPS 1.4-28
Das Schlüsselwort final
bei Instanzvariablen, Klassenvariablen, lokalen Variablen:
Definition von Konstanten
Sicherstellen einer nur einmaligen Wertzuweisung
bei Parametern: Verbot lokaler Zuweisungen
bei Klassen: Verbot der Bildung von Unterklassen
bei Methoden: Verbot des Überschreibens
Nutzen (bei Klassen und Methoden):
Vermeiden von Fehlern (versehentliches Überschreiben)
Effizientere Implementierung (da statische Bindungmöglich)
PPS 1.4-27
Datenkapselung
für Methoden und Attribute:
private, public, protected, default
PPS 1.4-30
für Klassen: public, defaultdefault - nur innerhalb des Pakets sichtbarpublic - überall sichtbarKlasse nicht sichtbar -> Attribute/Methoden nichtsichtbar (unabhängig von deren Modifikator)
default
private
protected
public
Klasse
X
X
X
X
Unterklasse
(gl. Paket)
X
X
Paket
X
X
X
Welt
X
Import-Anweisung
Import aller Klassen eines Paketes durchimport paketname.*
(als erste Anweisung hinter package, sofern vorhanden)Import einer bestimmten Klasse durch
import paketname.KlassennameImport eines Paketes impliziert nicht den Import derUnterpaketeauch ohne Import-Anweisung kann über
paketname.Klassenname.methode()auf fremde Klassen zugegriffen werdenImport kann Datenkapselung nicht aufhebenjava.lang.* wird automatisch importiert
PPS 1.4-29
Datenkapselung - public
package paketA;
public class One {
public int a;
}
public class Two extends One {
...
}
public class Three {
...
}PPS 1.4-32
package paketB;
import paketA.One;
public class Four extends One {
... = a ...
}
public class Five {
... = one.a ...
}
Datenkapselung - private
Als private gekennzeichnete Attribute / Methodensind für Objekte anderer Klassen nicht sichtbar
Trotzdem können die verschiedenen Objekte dergleichen Klasse gegenseitig auf ihre privatenAttribute/ Methoden zugreifen
Als private gekennzeichnete Attribute / Methodenwerden nicht vererbt
Falls in der Unterklasse Attribute/Methoden mitgleichem Namen definiert werden, so handelt essich um eine Neudefinition (kein Überschreiben,Überladen, Überdecken)
PPS 1.4-31
Datenkapselung - default
PPS 1.4-34
package paketA;
public class One {
public int a;
}
public class Two extends One {
...
}
public class Three {
...
}
package paketB;
import paketA.One;
public class Four extends One {
... = a ...
}
public class Five {
... = one.a ...
}
Datenkapselung - protected
PPS 1.4-33
package paketA;
public class One {
public int a;
}
public class Two extends One {
...
}
public class Three {
...
}
package paketB;
import paketA.One;
public class Four extends One {
... = a ...
}
public class Five {
... = one.a ...
}
Abstrakte KlassenKlassen müssen als abstract gekennzeichnet werden,wenn sie mindestens eine abstrakte Methode definierenoder erben
Abstrakte Methoden beschreiben Schnittstellen (Signatur)
Abstrakte Methoden müssen in Unterklassenüberschrieben (implementiert) werden, erst dann istInstanzierung möglich
Konsequenz: abstract kann nicht mit final, static, privatekombiniert werden
PPS 1.4-36
abstract class Fahrzeug() {
...
abstract void starte();
}
class Fahrrad extends Fahrzeug {void starte() {
steigeAuf();}
}
Datenkapselung und Vererbung
Beim Überschreiben ist es meist sinnvoll, dieZugriffsklasse beizubehalten.
Falls doch Änderung, darf die Unterklasse dieSichtbarkeit erweitern, aber nicht einschränken, d.h.
Oberklasse public -> Unterklasse public
Oberklasse protected -> Unterklasse protected oder public
Oberklasse default -> Unterklasse default, public oder protected
Bei Überladen, Überdecken und Neudefinition gibt eskeine solchen Einschränkungen
PPS 1.4-35
Implementierung von Interfaces
Eine Klasse kann ein oder mehrere Interfacesimplementieren
Dazu muß sie
die Interfaces unter implements aufführen und
alle Methoden der Interfaces überschreiben (falls nureinige überschrieben werden, bleibt die Klasse abstrakt)
Interfaces ermöglichen also Mehrfachvererbung für denwichtigen Spezialfall abstrakter Methoden
Bei Namenskonflikten erhalten beide abstraktenMethoden die gleiche Implementierung - für sinnvolleVerwendung ist der Programmierer verantwortlich
PPS 1.4-38
Interfacesauch: Schnittstelle, Schnittstellenklasse
Interfaces sind spezielle Klassen, die nur abstrakteMethoden und Konstanten enthalten
explizite Kennzeichnung als public abstractbeziehungsweise public final static kann entfallen
möglich: public, default
falls public: Filename = Name des Interfaces .java
PPS 1.4-37
public interface KannBlinken {void blinkenEin();void blinkenAus();
}public interface KannVerschieben {
int GRENZE = 100;boolean move(int dx, int dy);
}
Verwendung von Interfaces und abstrakten Klassen
Möglich: Deklaration von Variablen mit dem Typ einesInterfaces/einer abstrakten Klasse
Diesen Variablen können Objekte aller Klassenzugewiesen werden, die das Interface implementieren
Der Compiler akzeptiert dann den Aufruf der Methodendes Interfaces
Analog: Interfaces/abstrakte Klassen als Elementtyp vonFeldern bzw. Typ formaler Parameter
Typcast, instanceof sind anwendbar
PPS 1.4-40
KannBlinken leuchtObjekt;if (...) leuchtObjekt = new BlinkingPoint();else leuchtObjekt = new BlinkingArrow();leuchtObjekt.blinkenEin();// Nicht zulässig ist leuchtObjekt.move(3,4);
Beispiel: Interfaces
public class BlinkingPoint extends GeomFigur implementsKannBlinken, KannVerschieben {
boolean blinkt;int x, y;public void blinkenEin() { blinkt = true; }public void blinkenAus() { blinkt = false; }public boolean move(int dx, int dy) {
x+=dx; y+=dy;if (x > GRENZE || y > GRENZE )
return false;else return true;
}
PPS 1.4-39
Generisches ProgrammierenProgrammieren auf hohem Abstraktionsniveau
Programmiertechnik, die in Java mit bereits bekanntenMitteln (Interfaces, Überschreiben) realisiert wird
Nutzen: Wiederverwendung von Programmcode
Generische Datentypen (z.B. Liste, Stack) verwenden alsElementtyp Object (oder anderen abstrakten Typ)
Einfügen etc. kann unabhängig vom konkreten Elementtyp("generisch") programmiert werden
Generische Methoden verwenden als ParametertypObject (oder anderen abstrakten Typ) und sind damit aufObjekte beliebiger Klassen anwendbar
intern häufig Aufruf abstrakter Methoden, die in denUnterklassen überschrieben sind
Verwendung spezieller Methoden erfordert TypcastPPS 1.4-42
Interfaces und Vererbung
Bei implementierenden Klassen:
Die Eigenschaft, ein Interface zu implementieren, wirdvererbt, muß also in Unterklassen nicht erneut deklariertwerden
Zwischen Interfaces:
Interfaces können Unterklasse von ein oder mehrerenanderen Interfaces sein (hierarchisch)
Für diese Form der Vererbung wird das Schlüsselwortextends verwendet
PPS 1.4-41
Garbage Collector
niedrigpriorisierter Hintergrundprozeß zurautomatischen Freigabe unerreichbarer Objekte
Objekt ist unerreichbar, wenn es keine Verweiskette vomStack auf das Objekt mehr gibt
Objekt kann unerreichbar werden durchVerlassen eines Blocks -> Entfernen Variablen vom Stack
Zuweisungen: p = null oder p = p2
Unerreichbarkeit eines Vorgängerobjekts (z.B. Liste)
GC ruft vor Freigabe die Methode
protected void finalize()
auf, falls vorhanden (Destruktor)
expliziter Aufruf des Garbage Collectors durch System.gc()
PPS 1.4-44
Speicherfreigabe
Der vom Programm benutzte Speicher gliedert sich in
Stack: Lokale Variablen und Parameter der inAusführung befindlichen Methoden
Halde (Heap): Objekte
Speicher auf dem Stack wird nach Verlassen der Methodefreigegeben (C und Java)
In C wird Haldenspeicher mit malloc angefordert undmit free freigegeben -> fehleranfällig
In Java wird Haldenspeicher mit new angefordert undautomatisch freigegeben -> vereinfachtProgrammierung
PPS 1.4-43
Ausnahmen und FehlerAusnahmen (Exceptions) sind "leichte" Fehler, nachdenen eine Programmfortsetzung sinnvoll ist oder seinkann
Fehler (Errors) führen zu Programmabbruch
PPS 1.5-2
Throwable
RuntimeException
ErrorException
IOException
NullPointerException FileNotFoundException
OutOfMemoryError
PPS 1.5-1
1.5. Ausnahmebehandlung
Weiterleiten von Ausnahmen
1. Fall: IOException (und eigene Ausnahmen)
in Methode nicht behandelte Ausnahmen müssen unterthrows deklariert werden, sonst Fehlermeldung durchCompiler
void myMethod() throws ArrayOutOfBoundsException,MeineException {...}
2. Fall: RuntimeException
können abgefangen werden, müssen aber nicht
Auflistung unter throws kann entfallen
Generell
Ausnahmen wandern die Aufrufhierarchie hinauf bis sieabgefangen werden
außen angekommen -> Java-Interpreter stopptPPS 1.5-4
Konzept der Ausnahmebehandlung
Ausnahmen werden häufig von vordefiniertenJava-Methoden ausgelöst und müssen vom Programmiererbehandelt (abgefangen) werden
weiterhin kann der Nutzer eigene Ausnahmen definieren
Abfangen von Ausnahmen durch try-catch
möglich: mehrere catch-Blöcke, finally
PPS 1.5-3
try {// Anweisungsblock, der eine Ausnahme auslösen kann
}catch (Exception e) {
// Anweisungen zur Behandlung der Ausnahme}
Ausnahmen als ObjekteAusnahmen sind Objekte (enthalten Attribute, Methoden)
alle Ausnahmeklassen sind von Throwable abgeleitet
Klassen charakterisieren die Art der Ausnahme, Objektedie konkret im Programm aufgetretene Fehlersituation
catch (BspAusnahme e) fängt alle Ausnahmen der KlasseBspAusnahme und ihrer Unterklassen ab
für alle Ausnahmeklassen definiert:
Konstruktor mit Übergabe einer Fehlermeldung
Konstruktor ohne Übergabe einer Fehlermeldung
Methode getMessage
Definition eigener Ausnahmeklassen durch Bilden einerUnterklasse von Exception
PPS 1.5-6
Beispiel: Abfangen von Ausnahmen
int a, b, c;
// Einlesen von b und c
try {
a = b / c;
}
catch (ArithmeticException e) {
System.out.println("Bitte neuen Divisor eingeben: ");
// erneutes Einlesen von c
}
PPS 1.5-5
2. Parallele, verteilte und
nebenläufige Programmierung
PPS 2.1-1
Auslösen von Ausnahmen
erfolgt durch throws-Anweisung
PPS 1.5-7
Integer value;
public void setValue(Integer value) {
if (value==null)
throw new IllegalArgumentException("null übergeben");
this.value = value;
}
throws wird häufig in catch verwendet, um verschiedeneAusnahmesituationen zusammenzufassen
beim Überschreiben von Methoden dürfen derthrows-Klausel keine neuen Ausnahmen hinzugefügtwerden; Weglassen von Ausnahmen ist zulässig
2.1. Überblick
Nebenläufige Programmierung
Kennzeichen: mehrere Programmfäden befinden sichgleichzeitig in Abarbeitung
Konsequenz: es existieren mehrere Programmzähler
Ausführungsreihenfolge von Operationen ausverschiedenen Programmfäden ist dem Programmierernicht bekannt
kennt nur partielle Ordnung innerhalb eines Programmfadens
Ausführung auf einem Prozessor (Pseudoparallelität) odermehreren Prozessoren (Parallelität) möglich
Motivation: Beschreiben probleminhärenter Parallelität(z.B. Simulationsaufgaben)
PPS 2.1-3
Gliederung
2.1. Überblick
Begriffe, Architekturen, Programmiermodelle
2.2. Threadprogrammierung in Java
2.3. Applets
2.4. Remote Method Invocation
PPS 2.1-2
Literatur zu 2.1.:C. Leopold: Parallel and Distributed Computing: A Survey ofModels, Paradigms, and Approaches, Wiley, 2000
Literatur zu 2.2-2.4:Java-Lehrbücher
Paralleles Rechnen
Kennzeichen: gleichzeitige Ausführung vonBerechnungen mit Ziel Geschwindigkeitsgewinn
Einsatz mehrerer Prozessoren, die durch Netzwerkverbunden sind und zur Lösung der Aufgabe kooperieren
parallele Architekturen sind meist homogen, haben oftgemeinsamen Speicher
Konzentration auf eine Anwendung, d.h., paralleleOperationen sind Teil des gleichen Programms
Kommunikationsstruktur kann häufig statisch geplantoder zumindest abgeschätzt werden
parallele Programme sind meist nebenläufig
Typisches Anwendungsgebiet: wissenschaftlichesRechnen PPS 2.1-5
Nebenläufigkeit - Probleme
Programm muß für jede Ausführungsreihenfolge korrektarbeiten
Zeitkritischer Ablauf (engl.: race condition): GleichesProgramm kann auf gleicher Eingabe verschiedeneAusgaben erzeugen -> vermeiden
Programmfäden nutzen gemeinsame Ressourcen (z.B.gemeinsame Variablen)
Verklemmung(engl.: deadlock): gegenseitiges Wartenauf Ressourcenfreigabe verhindert Weiterarbeit desProgramms -> vermeiden
PPS 2.1-4
Architektur 1: Feldrechner
PPS 2.1-7
Steuerrechner
Verteiltes Rechnen
Kennzeichen: räumliche Verteilung von Berechnungenauf verschiedene Rechner eines Netzwerkes, zwecksNutzung entfernter Ressourcen
Hard- und Softwareressourcen, z.B. Parallelrechner,Drucker, Datenbanken
Architekturen sind meist heterogen und dynamisch, habenkeinen gemeinsamen Speicher
betrachtet System aus mehreren, getrennt entwickelten,Anwendungen, die gemeinsame Ressourcen nutzen undeventuell kooperieren
=> Paralleles, verteiltes und nebenläufiges Rechnen sindverwandte Gebiete mit vielen Überschneidungen undGemeinsamkeiten
PPS 2.1-6
Architektur 3: Parallelrechner mitverteiltem Speicher
PPS 2.1-9
P
M
P
M
P
M
P
M
P
M
P
M
P
M
P
M
P
M
Architektur 2: Parallelrechner mitgemeinsamem Speicher
PPS 2.1-8
Gemeinsamer Speicher
P
M
P
M
P
M
P
M
P
M
P
M
Datenparallelität
paralleles Programmiermodell
Grundidee: parallele Anwendung der gleichen Operationauf verschiedene Daten
Daten werden auf Prozessoren (Speicher) verteilt
Einfache Variante (Feldrechner): Operationen sindelementar -> nur ein Programmzähler
Erweiterte Variante (Parallelrechner): Operationen sindkomplex, aber unabhängig voneinander
keine Kommunikation während der Ausführung einer Operation
nach Operationsausführung Synchronisation
Sprachen: High Performance Fortran, HPF-2, C*, HPJavaPPS 2.1-11
Architektur 4: Verteiltes System
PPS 2.1-10
Gemeinsamer Speicher (Programmiermodell)
PPS 2.1-13
Programmfäden (Threads) kommunizieren indirektdurch Lesen/Schreiben gemeinsamer Variablen
Zeitkritische Abläufe und Deadlocks müssen durchSynchronisation vermieden werden
Gemeinsamer Speicher kann physisch existieren oderdurch Software nachgebildet werden
für nebenläufige und parallele Programmierung
GemeinsamerSpeicher
Thread
Thread
Thread
Thread
Thread
Thread
Datenparallelität - Beispiel
!HPF$ INDEPENDENT
FORALL (I=1:3)
a(I) = b(I)
c(I) = d(I)
END FORALL
PPS 2.1-12
b(1)
a(1)
d(1)
c(1)
b(3)
a(3)
d(3)
c(3)
b(2)
a(2)
d(2)
c(2)
Begin
End
Nachrichtenaustausch
engl.: message passing
Begriff hat andere Bedeutung als im OO-Programmieren!
Prozesse kommunizieren durch Senden und Empfangenvon Nachrichten, es existiert kein gemeinsamer Speicher
Kommunikation kommt nur zustande, wenn passendeSende- und Empfangsoperationen ausgelöst wurden
Kommunikation erfolgt zwischen 2 Prozessen, mußstatisch geplant werden und impliziert Synchronisation
wichtigstes Modell der parallelen Programmierung
Bibliotheken: Message Passing Interface, MPI-2, PVM
PPS 2.1-15
Gemeinsamer Speicher - Formen
Thread-Programmierung (z.B. Pthreads, Java Threads):explizite Erzeugung der Threads und Zuweisung vonAufgaben durch den ProgrammiererSprachkonstrukte zur Synchronisation undBeeinflussung des Scheduling
Scheduling = räumliche und zeitliche Zuordnung der Threads zuProzessoren
Direktivenbasierte Programmierung (z.B. OpenMP):Compiler übernimmt Threaderzeugung undAufgabenverteilungProgrammierer beschreibt Parallelitätspotential undnotwendige Synchronisationen problemnah (z.B. durchparallele Schleifen)
PPS 2.1-14
Client/Server
wichtigstes Paradigma des verteilten Rechnens
beschreibt asymmetrische Beziehung zwischen Prozessen
PPS 2.1-17
Klienten können auf Ressource nur über die vom Serverangebotenen Dienste zugreifen
Server ist passiver Dienstanbieter
Client ist aktive Seite, löst Interaktion aus
während Ausführung des Dienstes wartet Client
Client Server RessourceNetzwerk
Nachrichtenaustausch - Beispiel
char msg[20];
int me, total, tag;
MPI_Status status;
...
MPI_Comm_rank(MPI_COMM_WORLD, &me);
MPI_Comm_size(MPI_COMM_WORLD, &total);
if (me==0) {
strcpy(msg, "Gruesse von Prozess 0");
MPI_Send(msg, strlen(msg)+1, MPI_CHAR, 1, tag, MPI_COMM_WORLD);
}
else if (me==1) {
MPI_Recv(msg, 20, MPI_CHAR, 0, tag, MPI_COMM_WORLD, &status);
...
}
PPS 2.1-16
Mobiler Code
Gegenstück zum Datenaustausch zwischen Prozessen
Analogie: Versenden von Briefen vs. Reisen
Hauptproblem: Sicherheit
Varianten:
Austausch von Programmtexten
Migration in Abarbeitung befindlicher Prozesse
Einsatzgebiete:
Erweiterungen des Client/Server-Modells
Mobile Agenten
Parallele Mobile Agenten
Automatische MigrationPPS 2.1-19
Client/Server 2
Client und Server können getrennt entwickelt werden
meist existieren mehrere Klienten pro Server
-> Diese können unter Verwendung von Threadsgleichzeitig bedient werden!
möglich:
hierarchische Anordnung: Server nutzt während derDienstausführung Dienste eines anderen Servers
gleicher Rechner übernimmt (je nach Kontext) Rolledes Clients oder Servers ->Peer-to-Peer
Programmierung mittels Sockets, Remote ProcedureCall, Remote Method Invocation
PPS 2.1-18
Messagingauch: Message-Oriented Middleware (MOM), z.B. Java MessageService API
Verteilte Prozesse kommunizieren über gemeinsamenSpeicher -> ermöglicht zeitliche Entkopplung vonSender und Empfänger
Varianten:
Message Queuing: Als gemeinsamer Speicher dienenSchlangen (Queues), in die Nachrichten eingefügt bzw.aus denen Nachrichten entnommen werden können
im System existieren meist mehrere Schlangen mitunterschiedlichen Zugriffsrechten
Publish-and-Subscribe: Produzenten stellen Klassenvon Informationen zur Verfügung, Konsumentenkönnen diese abonnieren (vergleichbar Mailinglisten)
PPS 2.1-21
Mobiler Code - Einsatzgebiete
Erweiterungen des Client/Server-Modells:
Remote Evaluation: Code wird zur Laufzeit vom Clientzum Server geschickt (z.B. Übermittlung einer Funktion zwecksBerechnung durch leistungsfähigen Server)
Code on Demand: Server verwaltet Datenbank mitProgrammtexten und versendet sie bei Bedarf an dieKlienten (Beispiel: Applets in Webseite)
Mobile Agenten: Programm wandert während seinerAusführung durch Netzwerk zwecks Nutzung entfernterRessourcen; Programm entscheidet selbst, wann undwohin es migriert
Agenten können kooperierenPPS 2.1-20
2.2. Java Threads
Besonderheit Java: Threadprogrammierung ist in dieSprache integriert
Motivation: Unterstützung nebenläufiger (nur sekundärparalleler) Programmierung
Ein Programm (d.h., ein Prozeß des Betriebssystems)kann mehrere Threads umfassen
Die Threads eines Programmes verfügen übergemeinsamen Speicher
daneben existieren lokale Variablen der Threads
Alle Threads arbeiten mit dem gleichen Programmtext,aber unterschiedlichen Programmzählern
- > typisch: Verschiedene Threads bearbeiten verschiedene MethodenPPS 2.1-23
Verteilte Objekte
Verteiltes Programmiermodell - betrachten Objekte, diesich auf verschiedenen Rechnern befinden (-> getrennteAdreßräume)
Konzept: verbinden mit jedem Objekt einen eigenenProzeß (Unterschied zu sequentiellem Java und Threads!)
Prozeß verwaltet das Objekt im Sinne eines Servers
andere Prozesse können den Programmcode nichtselbst ausführen, sondern müssen dazu die Dienste desServers in Anspruch nehmen -> RMI = Remote MethodInvocation = entfernter Methodenaufruf
Systeme: CORBA, Java RMI, DCOMPPS 2.1-22
Beispiel 1 zur Threaderzeugung
public class BspThread extends Thread {...public void run() {
System.out.println("Gruesse vom erzeugten Thread");}
}
public class Bsp {public static void main(String[] args) {
BspThread t = new BspThread();t.start();System.out.println("Gruesse vom Hauptprogramm");
}}
PPS 2.1-25
Threaderzeugung mittels Thread
Die Klasse Thread des Pakets java.lang definiertMethoden zur Arbeit mit Threads: run, start, etc.
Threaderzeugung mittels Thread:
Bilden einer Unterklasse von Thread
Überschreiben der vordefinierten Methode runmit der gewünschten Funktionalität des Threads
Aufruf der von Thread geerbten Methode start
-> bewirkt Start des Threads und impliziten Aufruf von run
PPS 2.1-24
Beispiel 2 zur Threaderzeugung
public class NutzerThread extends ... implements Runnable {public void run() {
System.out.println("Gruesse vom erzeugten Thread");}
}
public class Bsp {public static void main(String[] args) {
NutzerThread nutzerThread = new NutzerThread();Thread hilfsThread = new Thread(nutzerThread);hilfsThread.start();System.out.println("Gruesse vom Hauptprogramm");
}}
PPS 2.1-27
Threaderzeugung mittels RunnableDa Java nur Einfachvererbung erlaubt, schließt die vorigeMethode Vererbung nach inhaltlichen Aspekten aus
Threaderzeugung mittels Runnable ist flexibler (aber etwas
komplizierter):
Runnable ist vordefiniertes Interface, enthält nur eineMethode: void run()
Aufrufende Klasse erzeugt zwei Objekte: Nutzer-Threadeiner eigenen Klasse und Hilfs-Thread der Klasse Thread
Klasse des Nutzer-Threads implementiert Runnable
Bei Erzeugung des Hilfs-Threads Übergabe desNutzerobjekts als Argument des Konstruktors
Aufruf der Methode start des Thread-ObjektsPPS 2.1-26
Beenden von Threads 2
PPS 2.1-29
Mit join() kann ein Thread auf die Beendigung einesanderen Threads warten:
public final void join() throws InterruptedException
Threadprogramme sind unstrukturiert: jeder Threaddarf jeden zum Abbruch auffordern
Threads leben eventuell länger als dasHauptprogramm
Abbruch aller Threads durch System.exit(0)
statt 0 Angabe eines Fehlercodes möglich
System.exit(0) kann in Hauptprogramm oder erzeugtemThread aufgerufen werden
Beenden von Threads 1
automatisch am Ende der run-Methode
Direkter Abbruch (stop) durch andere Threads soll inJDK 1.3 nicht mehr verwendet werden (Problem:Ressourcenfreigabe)
Andere Threads können durch Aufruf der Methode
public void interrupt()
zum Abbruch auffordern
Thread kann durch
public boolean isInterrupted()
feststellen, ob er zum Abbruch aufgefordert wurde undgegebenenfalls die run-Methode beenden
PPS 2.1-28
Beispiel zum Unterbrechen
public class BspThread extends Thread {public void run() {
while (true) {if (isInterrupted()) break;System.out.println("Hallo");try { Thread.sleep(100); }catch (InterruptedException e) { interrupt(); }
}}
}
public class Bsp {...BspThread t = new BspThread();t.interrupt();
} PPS 2.1-31
Unterbrechen von Threads
erfolgt mittels der Methode
public static void sleep(long milllis)
Bei Eingang einer Abbruchanforderung während desSchlafes wird eine Ausnahme ausgelöst und der Threadsofort geweckt -> Ausnahme abfangen
Aufruf : Thread.sleep(100) - bezieht sich auf den aktuellenThread, kann auch das Hauptprogramm sein
Mit
public final boolean isAlive()
kann abgefragt werden, ob ein Thread noch läuft, z.B.
if (t.isAlive()) t.interrupt();PPS 2.1-30
Locks und Objekte
in Java besteht eine 1:1-Beziehung zwischen Lock undObjekt
Sinn: gemeinsame Ressourcen sind in Java-ProgrammenAttribute und damit einem Objekt zugeordnet
Alle Ressourcen des Objekts werden durch den gleichenLock geschützt
PPS 2.1-33
Markierung mit synchronized ist möglich für
Methode- es wird der Lock des aktuellen Objektsangefordert
Anweisungsblock - Programmierer legt explizit fest,von welchem Objekt der Lock angefordert wird
Synchronisation
Kritischer Bereich:
Abschnitt des Programms, in dem Zugriff aufgemeinsame Ressourcen erfolgt
darf nicht durch andere Prozesse, die die gleicheRessource nutzen, unterbrochen werden
PPS 2.1-32
Java-Threads basieren auf dem Monitor-Konzept:
jedem Objekt ist ein Schlüssel (Lock) zugeordnet
Programmierer markiert kritische Bereiche mit demSchlüsselwort synchronized
Java-System stellt sicher, daß sich zu einem Zeitpunktnur ein Thread in einem kritischen Bereich des gleichenObjektes befindet
Beispiel: Monitor
public class Konto {int kontostand = 0;synchronized void einzahlen(int betrag) {kontostand+=betrag; }synchronized void abheben(int betrag) {kontostand-=betrag; }
}public class Kontoinhaber extends Thread {
public void run() { einzahlen(200); abheben(50); }}public class Bsp {
Konto unserKonto = new Konto();Kontoinhaber susi = new Kontoinhaber(unserKonto);Kontoinhaber fritz = new Kontoinhaber(unserKonto);susi.start(); fritz.start();
}PPS 2.1-35
PPS 2.1-34
Ausschließlicher Zugriff
wird durch das Monitor-Konzept realisiert
Nach Erzeugen eines Objekts ist dessen Lock verfügbar.
Sobald ein Thread einen kritischen Bereich erreicht, wirdautomatisch der dazugehörige Lock angefordert.
Falls verfügbar, wird der Lock dem aufrufenden Threadzugeordnet und ist dann für andere Threads nicht mehrverfügbar.
Andernfalls wird der Thread in die Warteliste desangeforderten Locks eingetragen.
Bei Verlassen des kritischen Bereichs wird der Lockautomatisch freigegeben. Falls Threads warten, erhälteiner von ihnen den Lock (welcher ist nicht festgelegt).
wait und notify
Weiterer Synchronisationsmechanismus - eignet sich fürSynchronisation zwischen Produzenten undKonsumenten (Anwendung Monitor: ausschließlicher Zugriff)
Durch Aufruf wait() gibt der Besitzer des Locks diesenfreiwillig ab und begibt sich in einen zweiten Warteraum("Schlafsaal") zum Objekt
wait() kann nur in kritischem Bereich aufgerufen werden
Durch Aufruf von notify() wird ein (willkürlichausgewählter) Thread des Schlafsaals in den Warteraumdes Locks geschickt
Nutzen wait/notify: Vermeidung aktiven WartensPPS 2.1-37
Parallelität und Serialisierung
Java Threads werden gegenwärtig meist pseudoparallelausgeführt ("green threads")
Parallelausführung ist möglich falls
der Rechner mehrere Prozessoren enthält und
die Java-Implementierung die Parallelausführungunterstützt ("native threads")
PPS 2.1-36
Serialisierung = durch Warten auf Lock bedingtesequentielle Ausführung der Threads
Unnötige Serialisierung vermeiden (auch bei pseudo-
paralleler Ausführung)-> kritische Abschnitte kurz halten
Thread Scheduling
Threads können sich in 4 Zuständen befinden
aktiv - in Ausführung, d.h. läuft auf Prozessor
rechenbereit - wartet auf Zuweisung eines Prozessors
wartend - wartet auf Lock oder notify()
beendet
Algorithmus zur Prozessorzuordnung (Scheduling) istimplementierungsabhängig -> Programme sollten injedem Fall korrekt laufen
meist: Zeitscheiben, Prioritäten
Programmierer kann Scheduling beeinflussen, z.B. durchSetzen von Prioritäten
PPS 2.1-39
Anwendung von wait /notify
PPS 2.1-38
Produzent Konsument
Konsument
Konsument
nach Produktioneiner Einheit:
notify();
Lager
Alle Zugriffe geschütztdurch synchronized
if (Lager leer)wait();
Beispiel: Applets
import java.applet.*;import java.awt.*;public class Bsp extends Applet {
public void paint(Graphics g) {g.drawString("Hello World",10, 20);g.drawLine(10,22,80,22);
}}<html><body>
<applet code="Bsp.class" width=300 height=200></applet>
</body></html>
PPS 2.1-41
2.3. Applets
Java-Programme, deren Ausführung typischerweise voneinem Web-Browser gesteuert wird
Statt main() ruft der Browser situationsabhängig (eventuellüberschriebene) Methoden der Klasse Applet auf: init(),start(), stop() und andere
Als mobiler Code unterliegen Applets sicherheitsbedingtenEinschränkungen, z.B. Verbot des Zugriffs auf Files
Ausnahme: signierte Applets
Bytecode-Verifizierer überprüft nach dem Ladensicherheitsrelevante Eigenschaften des Codes
zum Applet gehörige Klassen werden nach Bedarf geladen
Alternative: jar-Archiv
Applet-Programmierung ist grafik- und ereignisorientiertPPS 2.1-40
Funktionsweise RMI
PPS 2.1-43
Netzwerkverbindung
Client
Client = Prozeß, der aufrufendes Objekt ausführtServer = Prozeß, der dienstanbietendes Objekt ausführt
Stub Skeleton
Server
2.4. Remote Method Invocation
auch: entfernter Methodenaufruf, RMI
objektorientiertes Konzept zur Realisierung desClient/Server-Paradigmas
Kennzeichen:
Nachrichtenaustausch über Rechnergrenzenhinweg
Objekte verbleiben auf ihrem Rechner
RMI kann durch Code-Mobilität ergänzt werden;diese ist jedoch nicht Bestandteil des Konzepts
PPS 2.1-42
Datenübertragung
Zulässige Parameter:
(1) Werte primitiver Typen
(2) serialisierbare Objekte
(3) Verweise auf RMI-Objekte
Stub/Skeleton packen/entpacken Parameter undErgebnis
erfolgt bei (2) mittels SerialisierungPPS 2.1-45
Stub und Skeleton
Stub: lokale Methode auf Client-Seite, wird vomClient stellvertretend für die entfernte Methodeaufgerufen
Skeleton analog, aber auf Server-Seite
Stub und Skeleton werden mit Hilfe einesWerkzeugs erzeugt
Stub und Skeleton enthalten Programmcode zurRealisierung der Kommunikation -> ist transparentfür das Anwendungsprogramm
PPS 2.1-44
Praktische Umsetzung mit Java RMI
1) Definition eines Remote Interface für die Serverklasse
Unterklasse von java.rmi.Remote
jede Methode muß throws RemoteException deklarieren
2) Erstellen einer Klasse A, die das Interface implementiert
3) Erzeugen von Stub und Skeleton mit Hilfe des Werkzeugsrmic
4) Starten der RMI-Registry als Hintergrundprozeß aufdem Server-Rechner
5) Starten des Serverprozesses - darin Erzeugen einesObjekts der Klasse A und Anmelden dieses Objekts untereinem Namen xyz bei der RMI-Registry (mittels Naming.bind)
Serverprozeß läuft auch nach Beendigung von main() weiterPPS 2.1-47
Serialisierung
Abspeichern des Objektzustandes in einem zurDatenübertragung geeigneten Format (Folge von Bits)
Abgespeichert werden
die Werte aller eigenen und geerbten Attribute, außerstatic, transient
für Attribute, die Objekte sind, rekursiv auch derenAttribute (bei zyklischen Verweisen nur einmal)
Verweis auf zugehörige Klasse (Programmtext, Version)
Objekte können nur serialisiert werden, wenn sie das(leere) Interface Serializable implementieren
Weitere Anwendung: Sichern in Files (Persistenz)PPS 2.1-46
3. Skriptsprachen
PPS 3-1
Literatur für dieses Kapitel:D. Barron: The World of Scripting Languages, Wiley, 2000.
Praktische Umsetzung 2
6) Kopieren des Stub auf den Client-Rechner (insArbeitsverzeichnis)
7) Client-Programm muß kennen:
Name des Zielrechners (z.B. paral.informatik.uni-leipzig.de)
frei gewählten Namen des Servers (d.h.: xyz)
Erhält dann durch Aufruf von Naming.lookup(daten)vom RMI Registry des Server-Rechners einen VerweisfernesObjekt auf das Server-Objekt
8) Dieser Verweis ermöglicht Aufruf von Server-Methodenmit der üblichen Syntax, z.B. fernesObjekt.m()
PPS 2.1-48
Anwendungsgebiete und Sprachen
Systemadministration , Steuerung von Anwendungen
Betriebssysteme, Netzwerke, Datenbanken
Unix Shells, Perl, Tcl
Zusammensetzen von Komponenten
Tk, Visual Basic
Anwendungen, bei denen schnelle Programmentwicklungwichtiger ist als schnelle Programmausführung (Prototyp)
Visual Basic
Web-Programmierung auf Client- und Serverseite
JavaScript, VBScript, Perl
=>Skriptsprachen sind auf ein (eventuell breites)Anwendungsgebiet spezialisiert
PPS 3-3
Merkmale
werden häufig nicht zu den Programmiersprachen gezählt
einfache Sprachen
leicht zu erlernen (zumindest Sprachkonzept)
schnelle Entwicklung von Programmen
pragmatisch
einfaches Typsystem, dynamische Typisierung
werden interpretiert oder implizit kompiliert
-> direkter Aufruf des Programms ohne vorherigeÜbersetzung
große praktische Bedeutung
PPS 3-2
Beispiele: Perl
PPS 3-5
Schreiben in File Bsp.pl:#!/usr/bin/perlprint "Hello World\n"
Ausführung in Unixdurch:
>BspAusführung in Windowsdurch:
> perl Bsp
#!/usr/bin/perl$word = shift;while (<>) {print if /$word/};Aufruf durch:
Bsp xyz File1 File2
#!/usr/bin/perlwhile (<STDIN>) {
print if /wichtig/};
Perl - Einführung
Perl = Practical Extraction and Report Language
Ende 80-er Jahre eingeführt, danach weiterentwickelt
zunächst Unix, jetzt alle wichtigen Betriebssysteme
Spezialisierung: Textverarbeitung, Extraktion vonInformationen aus Files
Befehle des Betriebssystems (auch zur Netzwerk-programmierung) sind in Perl-Skripts direkt verfügbar
Syntax erlaubt Varianten des gleichen Befehls - Prinzip:fehlende Informationen werden sinnvoll ergänzt
Beispiel: Variablen können, müssen aber nicht deklariert werden
günstig für ungeübten ProgrammiererPPS 3-4
Zusammengesetzte Datentypen
Liste
z.B. ("rot", "blau", "gruen"), qw(rot blau gruen), (1..8)
Vertauschen von Daten: ($a, $b) = ($b, $a);
Array
z.B. @bsp = (0, "nichts", 0.0); -> $bsp[0] enthält 0 etc.
Zuweisung der Feldlänge: $laenge = @bsp;
Hash = inhaltsadressiertes Feld, assoziatives Feld
z.B. $myHash{baum} = "tree"; ...
%myHash = (baum => "tree", apfel => apple, ...);
Liste der Schlüssel/Werte: keys %myHash; values %myHash;PPS 3-7
Datentypen in Perl
Typ von Variablen wird im Bezeichner kodiert:
Skalare Daten: $name
Arrays: @name
Hashes: %name
Funktionen: &name
Skalare Datentypen: String, Zahl
Dynamisch-typisierte Sprache: System kennt denaktuellen Typ der Variablen und konvertiert wo nötig
Operatoren: arithmetisch, logisch, bitweise, Vergleich,bedingter Ausdruck, Zeichenreihen
z.B. $a = "Hallo" x 3; $b = "Ein $a"; $b .= $a; ++$a;PPS 3-6
Reguläre Ausdrücke
Beschreiben Muster in Zeichenreihen unter Verwendungvon Symbolen:
^ - Zeilenanfang, $ - Zeilenende
. - beliebiges Zeichen
[] - Zeichen aus Liste, z.B. /[aeiou]/
- - abgekürzte Aufzählung, z.B. /[0..9]/
[^]- Zeichen außer angegebenen, z.B. /^[ou]/
*, +, ?- Wiederholung (* für >=0, + für >=1, ? für 0,1)
| - Alternative, z.B. /From: | To:/
()- Gruppenbildung
{n,m}- gezählte Wiederholung, z.B. /([0..9]{1,3}\.){3}/
und andere PPS 3-9
Steuerstruktur
Blöcke
bedingte Anweisungen
PPS 3-8
if ($n>20) {print "gross"
} else {print "klein"
}
print "gross" if (n>20);print "klein" unless (n>20);
Schleifenz.B. $a += 2 while $a < $b;
$a += 2 until $a > $b;foreach $i reverse (1..10) { print $i };for ($i=1; $i<10; $i++) { print $i };
auch: Objekte, Pakete etc.
Was ist AssemblerAbstraktionsebene oberhalb von Maschinenbefehlen
Beispiel: MOV DX, 0 vs. 101110100000000000000000
Maschinenbefehle sind eventuell durch Folge vonMikrobefehlen realisiert
Zwei Bedeutungen des Begriffs:
Sprache, die Maschinenbefehle verständlich kodiert undeinfache Möglichkeiten zur Programmstrukturierungbereitstellt
Programm, das Assemblerprogramme inMaschinenprogramme umwandelt
Informationen zu konkreten Assemblersprachen findetman z.B. in der Dokumentation des jeweiligen Prozessors
PPS 4-2
4. MaschinennaheProgrammierung
PPS 4-1
Literatur für dieses Kapitel:H.-P. Gumm, M. Sommer: Einführung in die Informatik,Oldenbourg-Verlag, 2000, Abschnitte 5.4-5.6
Eigenschaften von Assembler
Maschinenabhängig -> Assemblerprogramme sind nichtportabel
evtl. Abwärtskompatibilität innerhalb einer Prozessorfamilie
betrachten hier typische und grundlegende Befehlsklassen
Assemblersprachen sind minimalistisch
enthalten (fast) nur die vom Prozessor unterstützten Grundbefehle
Komplexere Operationen müssen im Programm aus Grundbefehlenzusammengesetzt werden
Verwendung Assembler:
Assembler als Teil des Compilers, z.B. gcc -S myprog.c, gcc myprog.s
Assembler als eigenständiges Programm
Einfügen von Assemblercode in HochsprachprogrammePPS 4-4
Bedeutung Assembler
Wozu beschäftigen wir uns mit Assembler?
Zielsprache im Compilerbau
Verständnis für Performance von Programmen
Zusammenspiel Programmierer - Compiler
in sehr seltenen Ausnahmefällen Performance-kritischeProgrammabschnitte in Assembler schreiben
Programmierung von Basisfunktionen desBetriebssystems (Zugriff auf periphere Geräte)
Geschichte von Programmiersprachen
Wozu nicht?
Programmierung von AnwendungsprogrammenPPS 4-3
Speicherzugriff und Adressierung
bei RISC-Architekturen können nur explizite Lese- undSchreibbefehle auf den Speicher zugreifen
arithmetische Operationen erwarten die Operanden inRegistern
Adressierungsarten:
Direktoperand, z.B. MOV R1,14
Registerzugriff, z.B. MOV R1, R2
direkte Adressierung, z.B. MOV R1, [12]
indizierte Addressierung, z.B. MOV R1, R2[R3]
indirekte Adressierung, z.B. MOV R1, (R2)PPS 4-6
Rechnermodellbetrachten von-Neumann Rechner
Speicher unterteilt in Register und (Haupt-)speicher
unterscheiden
Mehrzweckregister R1, R2,...
Spezialregister, z.B. Programmzähler PC, Stackzeiger SP
Statusregister (FLAGS)
Registerbreite architekturabhängig, z.B. 4 Byte
Operationen verlangen evtl. bestimmtes Register
fassen Speicher als Array der Länge MAX_ADDRESS auf,mit Indizes = Adressen
Speicher enthält (in verschiedenen Segmenten)Programmtext und Daten des Programms
PPS 4-5
PPS 4-8
Adreßformen
unterscheiden
Einadreßform: op Quelle
Zweiadreßform: Ziel = Ziel op Quelle,
Dreiadreßform: Ziel = Quelle1 op Quelle2
Beispiel zur Zweiadreßform: Berechnung von a=(a+b)-(7-c)MOV R1, aMOV R2, bADD R1, R2MOV R3, 7MOV R4, cSUB R3, R4SUB R1, R3MOV a, R1
Datentypenunterscheiden
Byte = 8 Bit, Wort = 16 Bit, Doppelwort = 32 Bit u.a.
Bitfolgen werden von verschiedenen Operationen als intmit/ohne Vorzeichen, float etc. interpretiert
betrachten byteadressierten Speicher (z.B. Intel Pentium):
PPS 4-7
3AH
BCH
12H
E2H
01H 0H
1H
2H
3H
4H Wort auf 1H enthält 12E2H
Doppelwort auf 0H enthältBC12E201H
Byte auf 4H enthält 3AH
für effizienten Zugriff müssen Daten korrekt ausgerichtetsein, z.B. Doppelwort an durch 4 teilbarer Byteadresse
Beispiel: Flags
(im Intel Pentium sind AL , BL Register der Breite 1 Byte)
PPS 4-10
MOV AL, -3MOV BL, -1ADD AL, BL
MOV AL, 253MOV BL, 255ADD AL, BL
AL BL
AL FLAGSC O
1 0
FDH FFH
FCH
Ergebnis = -4Gültig, da O=0
Ergebnis = 252Ungültig, da C=1
Flags
Flag = einzelnes Bit des Registers FLAGS
unterscheiden Status-, Steuer- und Systemflags
Statusflags werden automatisch durch die ALU gesetztund enthalten Informationen zur letzten Operation
welche Flags aktualisiert werden, hängt von der konkretenOperation ab
Beispiele:
Z (Zero) - Ergebnis der letzten Operation war 0
C (Carry) - Überlauf bei vorzeichenlosen ganzen Zahlen
O (Overflow) - Überlauf bei ganzen Zahlen mit Vorzeichen
S (Sign) - Ergebnis war negativ PPS 4-9
Sprungbefehle
bewirken Laden des Programmzählers mit neuem Wert
unterscheiden unbedingte und bedingte Sprünge
Beispiel: Berechnung von AX = 1+2+ ... +CX
PPS 4-12
bedingte Sprünge beziehen sich auf Flags der vorigenOperation; existiert Vielzahl bedingter Sprungbefehle
MOV AX, 0CMP CX, 0JZ ende ; bedingter Sprung (Jump on Zero)ADD AX, CXDEC CXJMP nochmal ; unbedingter Sprung...
nochmal:
ende:
Arithmetische Operationen: ADD, SUB, MUL, DIV
Register für Produkt bzw. Dividend müssen doppelte Breite haben
Beispiel Intel Pentium:
Vergleiche: CMP
Logische Operationen: AND, OR, XOR, NOT
können für Bitoperationen verwendet werden, z.B. OR AL, 0100 0010B
Schiebebefehle, z.B. SHR AL, 1
Anwendung: Multiplikation, Division mit Zweierpotenzen
Bit- und Byteoperationen, u.a.
Operationen
PPS 4-11
MOV AL, 17MOV DL, 30MUL DL ; AX := AL * DL
Symbolische Adressen
(im Codesegment: Sprungmarken)
im Datensegment: symbolische Datenadressen
werden am Anfang des Assemblerprogramms deklariertund eventuell initialisiert
können später statt expliziter Adressen verwendetwerden
DB = Define Byte, DW = Define Word
Beispiel:
PPS 4-14
Alter DB 0Name DB 15 DUP(0)Groesse DW ?
Effekt: Es wird Speicherplatz reserviert, z.B.Alter: DS:04, Name: DS:05 ... DS:0E, Groesse: DS:0F und DS:10
Speichersegmente
Speicher ist unterteilt in Daten-, Code- undStacksegment
Segmente sind verschiebbar, aktuelle Startadressen derSegmente stehen in Spezialregistern DS, CS, SS
bei Datenzugriffen gilt:
physische Adresse = 16 * DS + angegebene Adresse
beim Laden von Befehlen gilt:
Adresse nächster Befehl = 16 * CS + PC
Segmente können sich überlappen
Größe/Überlappung der Segmente kann im Programmfestgelegt werden, z.B. . stack 100H
PPS 4-13
Verwendung des Stack
PPS 4-16
Stack = durch SS adressiertes Segment des Speichers
Zugriff erfolgt mittels PUSH, POP
wird für Implementierung von Unterprogrammaufrufenverwendet, insbesondere Parameterübergabe
RET bewirkt
POP PC ; wieder alten Programmzähler laden
CALL meineFunktion bewirkt
PUSH PC ; alten Programmzähler sichernJMP meineFunktion ; unbedingter Sprung
innerhalb des Unterprogramms benötigte Register sollten zuBeginn gerettet und am Ende wiederhergestellt werden
Unterprogramme
PPS 4-15
Prozeduraufruf
ProzedurdeklarationmeineFunktion: Befehl 1...Befehl nRET
...CALL meineFunktion...END main
main:
Es dürfen beliebig viele Unterprogramme deklariertwerdenRekursive Aufrufe sind zulässigHauptprogramm ist durch ´END´ gekennzeichnet
Parameterübergabe auf Stack
PPS 4-18
SS
PC BP
SP
LokaleVariablen des
Aufrufers
ÜbergebeneParameter
Datenrahmen desUnterprogramms(Frame)
Stack wächst hier nach unten: PUSH POP
Lokale Variable
Parameterübergabe
Übergabe in Registern
welche Register, ist Konvention zwischen Aufrufer undaufgerufenem Unterprogramm
geeignet für wenige / kurze Parameter
Übergabe auf Stack
Übergabe mittels PUSH
Entfernen mittels RET k (k Byte entfernen, RET)
Zugriff über Spezialregister SP (Stack Pointer) und BP(Base Pointer)
z.B. MOV BP, SP
MOV AX, [BP+4] PPS 4-17
5. Zusammenfassender Überblick
Unterscheiden vier grundlegende Paradigmen:
Imperative Programmierung
Objektorientierte Programmierung
Funktionale Programmierung
Logikprogrammierung
Weitere Sprachklassen:
Parallele, verteilte, nebenläufige Programmierung
Skriptsprachen
Maschinennahe Programmierung PPS 5-1