Download - Prof. Dr. Max Mühlhäuser Dr. Guido Rößling
Telecooperation/RBG
Technische Universität Darmstadt
Copyrighted material; for TUD student use only
Grundlagen der Informatik IThema 12: Einführung in die objektorientierte
Programmierung mit JavaProf. Dr. Max MühlhäuserDr. Guido Rößling
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Inhaltsverzeichnis
• Objektorientierter Entwurf in aller Kürze; Klassen und Objekte in Java
• Interpreter, Compiler, virtuelle Maschinen; Java- Übersetzungs- und -Laufzeitumgebung
• Sichtbarkeit von Variablen in Java
• Packages
• Einführung in das Testen mit JUnit und Eclipse
2
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Objektorientierte Programmierung
• Eines der existierenden Programmierparadigmen – Organisiert die zu modellierende Welt als eine Menge
kooperierender Objekte (OO-Systeme)
• Dabei gilt: – Ein Objekt ist zuständig für einen spezifischen
wohldefinierten Teil der Berechnung • Kapselt die Definition der dafür benötigten Daten und
Operationen, welche diese Daten verarbeiten• Nimmt Dienste anderer ihm bekannter Objekte in
Anspruch
– Jedes Objekt ist eine Instanz (Exemplar) einer Klasse– Klassen sind in einer Vererbungshierarchie organisiert
• Bilden Begriffshierarchien der zu modellierenden Welt nach
3
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Objektorientierte Programmierung• Beispiel: Modellierung der Immobilienfirma
Nobel&Teuer
• Objekte repräsentieren Häuser, Mitarbeiter und Kunden– Für jedes Haus sollen Informationen über den
betreuenden Mitarbeiter, den Besitzer… verwaltet werden– Für jeden Kunden sind die zu verwaltenden Häuser, Name
und Telefonnummer… zu verwalten– Mitarbeiter haben Namen, Telefonnummer, verwaltete
Häuser– …
• Verschiedene Typen von Häusern– Ein- und Mehrfamilienhäuser– Verschiedene Typen von Haus-Objekten werden in Erben
der Klasse Haus spezifiziert 4
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Objektorientierte Programmierung
5
Besitzer
Reich
Bes
itze
r
verwaltet
verw
alte
tSchmidt
Müller
Mitarbeite
rManager
WichtigDie Welt von Nobel&Teuer
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Objektorientierte Programmierung
6
Objekt
Person Haus
Mitarbeiter Kunde Einfamilien-haus
Mehrfamilien-haus
Manager Verwalterverwaltet
0..2
besitzt *
zuständig für2..10
Begriffe & Kategorisierung
Ur-Objekt-Typ
Die Welt der Immobilienfirmen
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Objektorientierte Programmierung
7
Objekt
Person Haus
Mitarbeiter Kunde Einfamilien-haus
Mehrfamilien-haus
Manager Verwalter
besitzt *
zuständig für2..10
Die Welt der Immobilienfirmen
Instanziierung
0..2
verwaltet
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Klassen
• Allgemein: Eine Klasse fasst Gemeinsamkeiten einer Gruppe von Objekten (Instanzen) zusammen– mit denselben Eigenschaften (Attributen)– mit demselben Verhalten (Operationen)
8
Daten(Variablen)
Konstruktionsvorschrift (Schablone) für Objekte; beschreibt deren Struktur und Dienste (Schnittstelle).
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Klassen in Java
• Der Definitionsblock einer Klasse besteht aus – einer Menge von
Variablendeklarationen • Attribute, Instanzvariablen, Felder
– einer Menge von Operationsdefinitionen
– Konstruktordefinitionen 9
<KlassenDefinition> = class Klassen-Name [extends SuperKlassenName] <KlassenDefinitionBlock>
<KlassenDefinitionsBlock> = { <MitgliedDefinition> ... <MitgliedDefinition> }<MietgliedDefinition> = <InstanzvariablenDeklaration>
| <OperationsDefiniton>| <KonstruktorDefinition>
class Counter { ...
}
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Instanzvariablen (Felder)• Instanzvariablen modellieren Eigenschaften von Objekten
z.B. aktueller Wert eines Zählers, aktueller Stand eines Kontos, …– Haben einen Namen, einen Typ und einen Wert
• Der Name wird meistens klein geschrieben • Der Wert ändert sich während der Ausführung
10
class Counter { int currentVal; ...}
Typ
Name
class Counter { int currentVal = 10; ...} Wert
Zur Erinnerung: int ist ein so genannter primitiver Typ in Java.
Stellt die Klasse der natürlichen Zahlen zwischen -2.147.483.648 und 2.147.483.647 dar
(define (make-counter) (local ( (define currentVal 10) ...)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Konstruktor-Operationen
• Ein Konstruktor definiert mit Hilfe der Parameter eine generische Initialisierungsvorschrift
• In Java sind Konstruktoren spezielle Operationen:– haben den gleichen Namen wie die Klasse selbst– haben keinen Rückgabewert
11
class Counter { int currentVal; ... Counter(int initVal) { currentVal = initVal; } ...}
(define (make-counter initVal) (local ( (define currentVal initVal) ...)
Formaler Parameter des Konstruktors
Initialisierung der Felder mit den aktuellen Parametern eines Konstruktor-Aufrufs
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Die Konstruktor-Operationen
• Eine Initialisierungsvorschrift wird einmal in einer Klasse definiert und mehrfach benutzt– Erzeugung mehrerer Zählerexemplare des
gleichen Typs mit unterschiedlich initialisierten Instanzvariablen
12
... (define c1 (make-counter 3)) (define c2 (make-counter 6)) ...
... Counter c1 = new Counter(3); Counter c2 = new Counter(6); ...
Schlüsselwort für die Erzeugung von
Objektinstanzen
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Sichtbar außerhalb der Definition von
Counter
JavaDoc Kommentar.
Hier aus Platzmangel
verkürzt.
Die Java-Klasse Counter
13
class Counter { int currentVal;
public Counter(int initVal) { currentVal = initVal; }
/** * Effect: Increases the current value of counter by 1 */ public int inc() { currentVal = currentVal + 1; return currentVal; } /** * Effect: Decreases the current value of counter by 1 */ public int dec() { currentVal = currentVal - 1; return currentVal; } /** * @return the current value of the counter */ public int getCurrentVal() { return currentVal; }}
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Klassen in Scheme und Java
• Klassen werden in Scheme durch Konstruktor-Funktionen (make-XXX) modelliert– Spielen die Rolle der Java-Klassen und -Konstruktoren – Geben Dispatcher-Funktionen zurück
• Der Dispatcher kombiniert und versteckt alle Dienstfunktionen
• In Java gibt es ein spezielles Konstrukt für Klassen– Klassen sind nicht wirklich erstklassige Werte – Klassen können mehrere Konstruktoren haben– Dispatch-Mechanismus implizit in der Sprache
• Der Dispatcher ist Teil der Sprachsemantik und muss nicht programmiert werden (später mehr)
14
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Klassenschnittstellen in Java
• Service Managers (dispatchers) in Scheme sind Schnittstellenfunktionen, die Symbole auf Funktionen verschiedener Typen abbilden
• Die Schnittstelle einer Java-Klasse ergibt sich aus der Menge der Operationen, die als public deklariert sind– Nicht-öffentliche Operationen sind von außen
unsichtbar• Wir gehen fürs erste davon aus, dass sie nur von
Methoden der gleichen Klasse aufgerufen werden können• Das stimmt nicht ganz; wir betrachten es später genauer
• Der Begriff einer Klassenschnittstelle als eine Funktion, die Symbole auf Operationen mit einem bestimmten Vertrag abbildet, bleibt jedoch gültig
15
An address-book is an interface:'add :: symbol number -> void 'search :: symbol -> number
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
public static void main(String[] args) { Counter c1 = new Counter(2); int current = c1.currentVal; current = c1.getCurrentVal(); // OK}
Einkapselung (Information Hiding)
16
Felder und Operationen eines Objekts können versteckt werden. Auf sie kann nur innerhalb der Implementierung der (öffentlichen) Operationen der Klasse zugegriffen werden.
class Counter { int currentVal; ...}
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
• Generelle Design-Idee: Details eines Programm-Moduls verstecken (z.B. Klasse oder Funktion)
• Mächtige Idee: reduziert die Komplexität von Anwendungen – Keine Notwendigkeit, die versteckten Details des
Moduls zu verstehen, um es zu verwenden.– Reduziert die Kopplung zwischen Modulen – Man kann die versteckte Implementierung ändern, ohne
die Klienten unwirksam zu machen.– Modul-Schnittstelle als Vertrag.
• Wir kennen diese Design-Idee schon– Datenabstraktion: Repräsentation des
Datentyps verstecken– Make-Funktionen verstecken lokale Objektdefinitionen
Geheimnisprinzip (Information Hiding)
17
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Kapselung
• Idee: Kombination von Elementen, um größere Einheiten zu erzeugen und dabei die Details der Komposition zu verstecken.
• Kapselung ist ein Mechanismus, um Informationen zu verstecken.
• Der Begriff wird manchmal in einem gröberen Sinn verwendet.– Als Synonym für information hiding
• Der Begriff wird manchmal in einem spezifischeren Sinn verwendet– “Daten und Operationen zusammen”
18
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Klassen als zweifache Abstraktion…
19
In der Definition einer Klasse werden unwichtige Unterschiede zwischen allen möglichen Elementen (Objekten) einer Klasse außer Acht gelassen
Beispiel: Unterschiede in den aktuellen Werten der Zähler
…beschreiben nur solche Felder und Dienste von realen Objekten, die relevant für die zu entwickelnde Software sind.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Klassen und Objekte• Klassen in Java sind statische Beschreibungen
("auf Papier" bzw. "in der Datei") Pläne (engl. blueprints)
• Objekte sind Laufzeitelemente eines Programms Werte– dynamisch (sind zur Programmausführungszeit im
Hauptspeicher des Rechners)– Es kann mehrere Objekte einer Klasse geben, jedes mit
eigener Identität und eigenem Zustand– Objekte sind über einen Namen ansprechbar
• Jedes Objekt gehört einer Klasse an und kennt seine Klasse– Die Klasse kennt ihre Objekte in der Regel nicht
20
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Charakteristika eines Objekts
21
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Berechnungen durchführen• Jede Berechnung in einem OO-Programm geschieht als
Folge des Aufrufs einer Operation auf einem vorher erzeugten Objekt
• Beachten Sie die „Punkt-Notation“ für den Aufruf von Methoden
22
public class CounterConsumer {Counter c1 = new Counter(3);Counter c2 = new Counter(6);
public void doSomethingWithCounters() {c1.inc();c1.inc();c1.dec();System.out.println(c1.getCurrentVal());
c2.inc();c2.dec();System.out.println(c2.getCurrentVal());
}}
(begin (inc c1) (inc c1) (dec c1))
(begin (inc c2) (dec c2))
(getCurrentVal c2)
(getCurrentVal c1)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Berechnungen durchführen• Die Aufgabe wird in Dienstanweisungen zerlegt
– Formuliert als Nachrichten (Operationsaufruf) an Objekte
• Jede Nachricht enthält: – Name des Empfängerobjektes: c1 im Beispiel– Namen des Dienstes (der Operation), der (die) vom
Empfänger ausgeführt werden soll• inc(), dec(), ...• Die Operation muss in der Schnittstelle des Empfängers
enthalten sein• Es wird nur eine Nachricht mit einer
Dienstanweisung auf einmal geschickt• Wenn mehrere Objekte vorhanden sind, können
sie Botschaften aneinander senden– Teilaufgaben an bekannte Objekte delegieren
23
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Zur Erinnerung: Wie alles anfängt…• Die „ausgezeichnete“ Methode namens main wird
aufgerufen, wenn ein Java-Programm ausgeführt wird…
24
public class CounterTest { // ... public static void main(String[] args) { CounterConsumer cc = new CounterConsumer(); cc.doSomethingWithCounters(); } // ...} CounterTest.java
Java- Compiler
Java- Bytecode-Interpreter
javac CounterTest.java
java CounterTest
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Inhaltsverzeichnis
• Objektorientierter Entwurf in aller Kürze; Klassen und Objekte in Java
• Interpreter, Compiler, virtuelle Maschinen; Java- Übersetzungs- und -Laufzeitumgebung
• Sichtbarkeit von Variablen in Java
• Packages
• Einführung in das Testen mit JUnit und Eclipse
25
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Interpreter
26
• Ein Interpreter ist ein Programm, das ein Programm einer bestimmten Programmiersprache direkt ausführt.
• Arbeitsweise eines Interpreters (inpExpr ist der aktueller Ausdruck des auszuführenden Programms) 1. Syntaktische Analyse von inpExpr2. Überführung von inpExpr in eine Befehlsfolge der
Maschinensprache, oder der Sprache, in der das Interpreterprogramm selbst geschrieben ist (outExpr)
3. Ausführung von outExpr4. Wiederholung der Schritte (1) bis (3) für die
nächste Anweisung.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Definition eines Übersetzers
27
• Ein Übersetzer (Compiler) ist ein Programm, das Programme aus einer Programmiersprache A in eine Programmiersprache B übersetzt
Übersetzer
Zielprogramm P2A Quellsprache B Zielsprache
Au
sfü
hru
ng
Quellprogramm P1
Programm in der Sprache A
Programm in der Sprache B
• Semantische Korrektheit– Jedem Quellprogramm P1 in A wird genau ein
Zielprogramm P2 in B zugeordnet. – Das dem Quellprogramm P1 zugeordnete Zielprogramm
P2 muss die gleiche Bedeutung (Semantik) wie P1 besitzen.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Übersetzer (Compiler)
28
Nach eigener Aussage hat sie den Compiler aus Faulheit erfunden, und weil sie hoffte, dass "Programmierer wieder Mathematiker werden" könnten.
Konteradmiral Grace Murray Hopper (1906–1992)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Übersetzungsphasen
Quellprogramm wird in eine Folge von Worten zerlegt
29
Lexikalische Analyse
Syntaktische Analyse
Semantische Analyse
Code-Generierung
Testet, ob das Quellprogramm denSyntaxregeln der Quellsprache entspricht. Strukturiert Worte in gültige Sätze.
Testet, ob alle im Quellprogramm benutzten Namen deklariert wurden und ihrem Typ entsprechend verwendet werden, usw.
Zielprogramm wird erzeugt
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Traditionelle Übersetzung
30
Quelltext in Sprache A
Compiler für Sprache A und Prozessor X
Ausführbares Programm (Binärcode) für Prozessor X
Compiler fürSprache A undProzessor Y
Compiler für Sprache A undProzessor Z
Sun
PC
Apple
PascalPascal
SmalltalkSmalltalk
JavaJava
PrologProlog
C++C++
N Sprachen M PlattformenN*M Compiler
Ausführbares Programm (Binärcode) für Prozessor Y
Ausführbares Programm (Binärcode) für Prozessor Z
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Vor- und Nachteile traditioneller Übersetzung
• Vorteil: Optimale Ausnutzung der jeweiligen Prozessor-Eigenschaften– Hohe Abarbeitungsgeschwindigkeit der übersetzten
Programme
• Nachteil: Plattformabhängigkeit– Ein Programm, das in einer höheren
Programmiersprache geschrieben ist, kann theoretisch nach der Anwendung der entsprechenden Übersetzer auf jeder Maschine laufen...
31
„The difference between theory and practice is that in theory, there is no difference between theory and practice, but in practice there is.“
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Vor- und Nachteile traditioneller Übersetzung
32
• Das übersetzte Programm läuft nur auf dem jeweiligen Prozessortyp– Für jeden Prozessortyp und jedes Betriebssystem
muss das Programm mit einem anderen Compiler neu übersetzt werden.• Windows auf PC != Linux auf PC
• Plattformabhängigkeit: es gibt unterschiedliche Dialekte einer Sprache – Bestimmte Eigenschaften der Maschine
beeinträchtigen den Compiler-Entwurf • Z.B. Größe der Register oder Speicherzellen beeinträchtigt die
maximale Länge der Zahlen, die manipuliert werden können.– Daher gibt es oft verschiedene Dialekte einer
Programmiersprache
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Virtuelle Maschinen (VM)• Eine virtuelle Maschine ist ein Programm, das die
Arbeit eines Prozessors in Software simuliert
• Programme einer höheren Sprache werden in eine Assembler-ähnliche Zwischensprache übersetzt– Der simulierte Hardware-Prozessor nutzt diese
Zwischensprache und besitzt einige Software-Register
– Die Anweisungen der Zwischensprache nennt man auch Byte-Code
• Die Zwischensprache wird von der Virtuellen Maschine interpretiert
• Eine virtuelle Maschine versteckt die spezifischen Eigenschaften eines konkreten Prozessors eine neue Abstraktionsschicht auf der Hardware-Ebene!
33
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Vor- und Nachteile von Interpretern
• Vorteil: es lassen sich relativ schnell lauffähige Programmversionen erstellen Prototyping– Schnelle Änderbarkeit: geänderte Anweisungen /
Deklarationen des Quellprogramms sind sofort ausführbar
• Neuübersetzung nicht notwendig
• Nachteil: Längere Ausführungszeit– Werden Anweisungen des Quellprogramms k-mal
verwendet (z.B. bei Schleifen), werden sie k-mal analysiert und überführt
– Bei Zugriffen auf Variablen müssen die zugeordneten Adressen immer wieder bestimmt werden.
34
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Virtuelle Maschinen (VM)
35
Sun
PC
Apple
PascalPascal
SmalltalkSmalltalk
JavaJava
PrologProlog
C++C++
N SprachenM PlattformenN + M Compiler
VirtuelleMaschineVirtuelleMaschine
Eine VM verdeckt die speziellen Eigenschaften des jeweiligen Prozessortyps Abstraktionsschicht!
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Vor- und Nachteile der VM-Technologie
• Vorteile: Übersetzte Programme einer Sprache laufen auf allen Prozessortypen, für die es einen Byte-Code Interpreter gibt– Es wird nur ein Compiler benötigt
Die Sprache wird plattformunabhängig– Natürlich braucht man eine VM pro Prozessortyp!
• Nachteil: Byte-Code Programme sind langsamer als Maschinenprogramme– just-in-time-compiler (JIT): Übersetzen den Byte-
Code in ein Objekt-Programm für einen speziellen Prozessortyp
• sobald es geladen wird, oder nach der ersten Ausführung
36
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Java-Übersetzungs- und -Laufzeitumgebung
37
Java Source (.java)
Java Compiler(javac)
Java Bytecode (.class)
Java Bytecode
aus Dateisyste
m oder Netz
Übersetzungsumgebung
Class Loader
BytecodeVerifier
Java Klassen-
bibliothek
Java Interpreter
Just-in-time Compiler
Java Laufzeitumgebung
Betriebssystem
Hardware
Laufzeitumgebung
Java VM
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Struktur eines Java-Programms• Ein Java-Programm kann aus beliebig vielen
Klassen bestehen, von denen mindestens eine die main-Operation besitzen muss (Hauptprogrammklasse).
• Aufgaben von main:– Objekterzeugung der Aufbau einer anfangs minimalen
Welt– Aufruf der ersten Operation– Sollte in der Regel keinen weitergehenden Kontrollfluss
des Java-Programms enthalten• Der Kontrollfluss wird innerhalb der Objektoperationen
realisiert – Nicht vergessen! Berechnung als Kooperation von vielen
Objekten, wobei jedes Objekt nur eine kleine Teilaufgabe erledigt!
• main wird mit Hilfe des Java-Interpreters gestartet und ausgeführt
38
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Java-Laufzeitumgebung• Java Interpreter: Programm zur Ausführung des Java-
Bytecodes auf dem konkreten Rechner
• Just-In-Time-Compiler (JIT-Compiler) – Eine Klasse kann (optimal) nach dem Laden direkt in
Maschinen-Code der jeweiligen Maschine übersetzt werden– Falls die vorliegende Java-Installation keinen JIT-Compiler
besitzt, wird der Bytecode vom Java-Interpreter direkt ausgeführt
• Runtime-System: Stellt einem Java-Programm wichtige Ressourcen zur Verfügung
• Bytecode Verifier: überprüft, ob die geladenen Bytecodes der JVM-Spezifikation entsprechen– Klassen können über das Netz oder aus dem lokalen
Dateisystem zur Laufzeit einer Java-Anwendung in das Laufzeitsystem nachgeladen werden
– Ein Teil der Sicherheitsmaßnahmen wird durch den Bytecode Verifier realisiert
39
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Java-Übersetzung (Wiederholung)
• Java-Compiler– Eingabe: Java-Quelltextdatei, Datei.java, die eine
oder mehrere Klassendefinitionen enthält• Eine derartige Datei nennt man eine Übersetzungseinheit
– Ausgabe: pro Klasse Bsp wird genau eine Datei Bsp.class erzeugt, die das Bytecode-Format der Klasse enthält
40
Java C
om
pile
rBsp1.class
Bsp2.class
Datei.class
class Bsp1 {...}class Bsp2 {...}class Datei {...}
Datei.java
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Inhaltsverzeichnis
• Objektorientierter Entwurf in aller Kürze; Klassen und Objekte in Java
• Interpreter, Compiler, virtuelle Maschinen; Java- Übersetzungs- und –Laufzeitumgebung
• Sichtbarkeit von Variablen in Java
• Packages
• Einführung in das Testen mit JUnit und Eclipse
41
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Sichtbarkeit von Variablen in Java
• Der gleiche Variablenname kann mehrfach verwendet werden, z.B. Instanzvariable, Parameter, lokale Variable einer Methode oder eines Blocks.
• Wie in Scheme, lexical scoping: innere Deklarationen haben immer Vorrang vor äußeren Deklarationen.– Auf äußere Deklarationen kann man nicht mehr direkt
zugreifen– Mit this.<attribute-name> kann man auf
Instanzvariablen zugreifen– Lokale Variablen und Parameter können nicht re-
deklariert werden
• Redeklaration beeinflusst die Existenz der äußeren Variablen nicht– Fehlende Sichtbarkeit bedeutet kein fehlendes
Vorhandensein!– Außerhalb des Deklarationsblocks ist die äußere
Variable wieder sichtbar42
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Sichtbarkeit von Variablen in Java Klassen
43
Lexical scoping a la JavaKlassen-Scope
Scope von Methode g
Scope der for-Schleife
class Example {int i;char c;void g(int n) {
int i, j;for (char c... ) {
int k;… i … k … c … n … this.i …
} … c …
} }
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Inhaltsverzeichnis
• Objektorientierter Entwurf in aller Kürze; Klassen und Objekte in Java
• Interpreter, Compiler, virtuelle Maschinen; Java- Übersetzungs- und –Laufzeitumgebung
• Sichtbarkeit von Variablen in Java
• Packages
• Einführung in das Testen mit JUnit und Eclipse
44
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Packages
• Packages bündeln Klassen, die im Hinblick auf Zuständigkeit zusammen gehören.
• Hilft Namenskonflikte zu vermeiden.– Klassennamen müssen eindeutig sein (aber nur in
einem Package) Mehrere Klassen können den gleichen (nicht public)
Namen haben, z.B. List
• Versteckt Klassen, die nur interne Zwecke haben und die nach außen nicht sichtbar sein sollen.
45
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Package Hierarchien
• Packages sind hierarchisch organisiert Ein Package kann andere Packages enthalten, die wieder mehr Packages enthalten, usw.
• Punkt-Notation für Package Namen
46
package.subpackage.subsubpackage.Class
• Der Kopf einer Java Datei gibt an, mit welchem Package die folgenden Klassen verbunden sind.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Namenskonventionen für Packages
• Der Package Name spiegelt den Internet Domain Namen des Herstellers in umgekehrter Reihenfolge• Schräg- und Bindestriche sind nicht erlaubt:
– SUN URL: sun.com SUN class: com.sun.p1.p2.Class– TUD URL: informatik.tu-darmstadt.de TUD class:
de.tu_darmstadt.informatik.p1.Class
Die Konvention erlaubt die Definition weltweit eindeutiger Klassennamen. 47
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Deklaration von Packages
• Der gleiche Package Name kann in mehreren Dateien verwendet werden– Ein Package kann über mehrere Dateien
verteilt sein schnellere (Re-)Compilierung Unterstützt die Arbeitsteilung in größeren
Projekten
• Der volle Name einer Klasse enthält immer den Package Namen (packagename.ClassName)
• Shortcut Notation mit nur dem Klassennamen ist nur innerhalb des selben Packages möglich oder wenn das Package bzw. die Klasse importiert wurde.
48
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Struktur einer Java Datei
<Source-File> ::= <Package-Declaration> <Import-Declarations><Type-Definitions>
<Package-Declaration> ::= package <Package-name> ; | ε
<Package-Name> ::= <Identifier> {. <Package-Name>}
• Nur Kommentare oder leere Zeilen dürfen vor der Package Deklaration stehen.
• Nur ein Package Name pro Datei• Ohne eine Package-Deklaration werden die
enthaltenen Klassen einem anonymen Standard Package hinzugefügt.
49
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Package Import
<Import-Declaration> ::= import <Package-Name> . (<Class-Name> | *) ;
• Eine Klassendefinition nach einer import-Anweisung kann auf die importierte Klasse zugreifen, ohne den vollständigen Namen zu nennen.
• Wenn "*" (wild card) benutzt wird, kann man auf alle Klassen des Packages zugreifen.
• Falls nur Klassenmethoden (static) importiert werden sollen, langt auch folgende Notation:
import static <Package-Name>.<Class-Name>.<Methode>;
50
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Verwendung von Packages
• Verwendung der vollständigen Kennzeichnung (full qualification)java.util.Random numberGenerator
= new java.util.Random();
• Verwendung von importimport java.util.Random;
...
Random numberGenerator = new Random();
51
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Package Import
• Das Importieren von Klassen mit dem selben Namen erzeugt einen Namenskonflikt
import java.awt.*; // hat Klasse Listimport java.util.*; // hat Klasse List...java.util.List list; // verwende den
// Package-Namen, um // eine auszuwaehlen
• Zwei Packages werden automatisch importiert– Das aktuelle Package– Das vordefinierte Package java.lang, das
grundlegende Klassen wie Object, String, usw. enthält.
52
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Package Import
Die Java API enthält eine große Zahl vordefinierter Packages (alle Teil vom JDK), unter anderem
– java.applet Applet-Unterstützung– java.io Input/Output, Dateien– java.net Netzwerk-Unterstützung– java.util Utility Typen, z.B.
Containertypen– java.util.zip Unterstützung für .zip
Archive– …
53
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Namensgebung für Packages
Package-Namen und VerzeichnisstrukturenDie Stellen der Dateien, die ein Package
definieren, spiegelt die hierarchische Struktur des Packages wieder.
• Punkte müssen ersetzt werden durch:– UNIX Slash " / "– Windows Backslash " \ "
Beispiel:– Name des Packages: kilian.hobby.raytracer
– zugehörige UNIX Verzeichnis-Struktur:kilian/hobby/raytracer
54
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Packages einbinden
• Ein Package Name wird als relativer Pfad verstanden
• Die Umgebungsvariable CLASSPATH enthält alle Verzeichnisse, die nach Klassen und Packages durchsucht werden.
• Darüber hinaus kann ein CLASSPATH auch auf ZIP und JAR-Archive verweisen, die Klassen enthalten
• UNIX BeispielCLASSPATH=.:/home/joe/classes:/usr/classes.zip
55
Weitere Verzeichnisse
Packages und "CLASSPATH"
Aktuelles Verzeichnis
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Packages einbinden
• Die Verzeichnisse aus CLASSPATH sind die Startpunkte für die relativen Pfade zu den Packages
• Die Suchreihenfolge ist von links nach rechts• Es ist möglich, dass ein Package Name
mehrere Verzeichnisse bezeichnet. Keine gute Idee, da die Auswahl der Packages
dann von der Reihenfolge des Auftretens dieser Verzeichnisse im CLASSPATH abhängt.
56
Packages und "CLASSPATH"
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Inhaltsverzeichnis
• Objektorientierter Entwurf in aller Kürze; Klassen und Objekte in Java
• Interpreter, Compiler, virtuelle Maschinen; Java- Übersetzungs- und –Laufzeitumgebung
• Sichtbarkeit von Variablen in Java
• Packages
• Einführung in das Testen mit JUnit und Eclipse
57
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Testen mit JUnit und Eclipse
58
Der Ärmste... wir hätten ihm bei der Einstellung sagen sollen, dass er zuerst testen und dann programmieren soll.
Test-first programming Unsere Entwurfsrezepte verlangen, dass wir Tests schreiben, bevor wir mit dem Programmieren anfangen
JUnit ist ein Programm (framework), das das Schreiben und Ausführen von Tests teilweise automatisiert• JUnit ist bereits in Eclipse integriert
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Motivation für JUnit• Analog zu unseren Testfällen in Scheme wollen wir auch in
Java unsere Programme testen können• Wir schreiben dazu ein Testprogramm, welches die
Operationen mit Beispiel-Daten benutzt und die Ergebnisse auswertet– Testprogramm wird zur Entwicklungszeit zum eigentlichen
Programm parallel weiterentwickelt und ausgeführt– Immer dann, wenn wir wissen möchten, ob gewisse Testfälle
noch laufen
59
Wir verwenden ein Framework, hier JUnit- für automatisierte Unit-Tests
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Annotationen• Bevor wir uns JUnit widmen, möchten wir einen
Blick auf Annotationen werfen– Die neueste Fassung von JUnit nutzt Annotationen
• Annotationen liefern Metadaten über den Programmcode
• Java 1.5+ definiert 7 Annotationen – Möglichkeit zur Ergänzung durch nutzerdefinierte
Annotationen – 3 „echte“ Annotationen – 4 Meta-Annotationen
• Annotationen werden mit einem @-Symbol im Programm-Code markiert– Zum Beispiel: @SuppressWarnings
• Annotationen verweisen auf eines der folgenden Elemente– Element = Code-Zeile, Methode, …
60
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Echte Annotationen
• @Override– Zeigt an, wenn eine Methode aus der Basisklasse durch
eine andere Methode überschrieben wird. – Kann verwendet werden, um auf Tipfehler und Fehler in
den Signaturen von Methoden zu testen.
• @Deprecated– Verursacht eine Compiler-Warnung, wenn das folgende
Element verwendet wird
• @SuppressWarnings– Unterdrückt Compiler-Warnungen für das folgende
Element
61
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Meta-Annotationen
• @Target(args)– Wo können Annotationen verwendet werden?– Zusätzliche Argumente: CONSTRUCTOR, FIELD,
LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE• @Retention(args)
– Wie lange sollen Annotationen behalten werden? • SOURCE = Vom Compiler verworfen• CLASS = Verfügbar in Klassen-Datei, zur Laufzeit verworfen• RUNTIME = Von Virtual Machine für die Laufzeit-Nutzung
beibehalten
• @Documented – Schließt Annotation in JavaDoc ein
• @Inherited – Erlaubt es Unterklassen, Annotation zu erben
62
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Annotationen: Beispiel
• Die Annotationen @Target und @Retention können genutzt werden, um neue Annotationen zu definieren
• Neue Annotationen werden wie Interfaces definiert mit dem Schlüsselwort @interface (mit @-Präfix)
• Beispiel:
63
@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface UseCase { public int id(); public String description() default "no description";}
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Annotationen: Beispiel
• Wie können vorausgegangene Annotationen genutzt werden, um “Use Cases” zu generieren?
64
public class PasswordUtils { @UseCase(id = 47, description = "Password must have one number") public boolean validatePassword() { // ... } @UseCase(id = 48) public String encryptPassword() { // ... }}
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Annotationen und JUnit• Die aktuelle Version von JUnit basiert auf
Annotationen• Testfälle werden mit der Annotation @Test
markiert• Frühere Versionen brauchten spezielle
Konventionen bei den Namen der Test-Klassen– In JUnit 4 ist das nicht mehr notwendig
• JUnit-Demo, aber im Vorfeld noch ein paar Worte zum Testen
65
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Teststadien
66
Kunden-wünsche
Entwurf
Code
Abnahmetest
Systemtest
Integrationstest
Unittests
X Y A wird vor B ausgeführtA B X findet Fehler in Y
Anforderungen
Entwicklungsphasen mit zugehörigen Tests
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Teststadien
Sich anbietende Teststrategien• Unit Test: Test von Codekomponenten, z.B. Code einer
Methode, einer Klasse strukturelles Testen
• Integrationstest: Test des Zusammenwirkens mehrerer Codekomponenten strukturelles Testen
• Systemtest: Test des gesamten Systems gegen die Anforderungen funktionales Testen
• Abnahmetest: Test des gesamten Systems mit echten Daten des Kunden
67
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Entwicklungsprozess & Testen
68
Zeitdruck
Weniger Tests
Mehr Fehler
Mehr Zeitdruc
k
Ein ungewollter Teufelskreis …
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Entwicklungsprozess & Testen:„Agile“ Prozessmethoden
• Entwicklung und Testen als verschränkter Prozess• Testentwicklung vor Produktentwicklung!• Werkzeugunterstützung benötigt...
69
Ein wenig testen
Ein wenig programmier
en
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Motivation Testen: Zusammenfassung• In der Praxis unverzichtbar
– Je früher Fehler gefunden werden, desto besser (kostengünstiger)
– Entwicklung ist deshalb typischerweise ein iterativer, rückgekoppelter Prozess
• Qualität nicht nur überprüfen, sondern, wenn möglich, „hineinkonstruieren“– Systematische Verfahren Software Engineering
70
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Testen mit JUnit 4.4
• Auf den nächsten Folien testen wir einen Taschenrechner
• Die Implementierung ist relativ einfach• Der Taschenrechner arbeitet nur auf int-Werten• Er ist sehr einfach und ineffizient• Außerdem hat er ein paar Bugs• Wir werden sehen, ob JUnit uns bei den Bugs helfen
kann!
71
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Die Calculator Klasse (Teil I)package calc;
public class Calculator { private static int result; // Statische Variable fuer Speicherung des Ergebnisses
public void add(int n) { result = result + n; } public void substract(int n) { result = result - 1; // Bug: sollte lauten result = result - n } public void multiply(int n) { // noch nicht implementiert... } public void divide(int n) { result = result / n; } public void square(int n) { result = n * n; }
72
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Die Calculator Klasse (Teil II) public void squareRoot(int n) { // implementieren wir spaeter… for (; ;) ; // Bug: unendliche Schleife } public void clear() { // Ergebnis loeschen auf 0 result = 0; } public void switchOn() { // Display anschalten, “Hallo” anzeigen, piepen... // Was so Geraete heute eben alles tun koennen! result = 0; } public void switchOff() { // Anzeigen “Tschuess", piepen, Display ausschalten } public int getResult() { return result; }}
73
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Wie testen wir den Calculator?
• Wir wollen jede Operation separat testen– Add– Substract– Divide– Multiply– Square Root – erst einmal aufgeschoben (Endlosschleife!)
• Wir schreiben eine Testmethode pro Test• Die Methoden kommen in eine Klasse
CalculatorTest• Tests werden annotiert mit @Test vor dem
„public”• Wir müssen den Rechner vor jedem Test
initialisieren– Müssen “clear()” aufrufen, damit der Wert 0 ist– Sonst kriegen wir ggf. Folgefehler!
74
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Die CalculatorTest Klasse (Teil I)package junit4demo;
import calc.Calculator;import junit.framework.JUnit4TestAdapter;import static org.junit.Assert.assertEquals;import org.junit.Before;import org.junit.Ignore;import org.junit.Test;
/** * Basic test class using @Test, @Before and @Ignore annotation * as well as assert keyword and assertEqual methods */public class CalculatorTest { private static Calculator calculator = new Calculator(); // this is our calculator! // Used for backward compatibility (IDEs, Ant and JUnit 3 text runner) public static junit.framework.Test suite() { return new JUnit4TestAdapter(CalculatorTest.class); }
75
Packagename ist hier beliebig
Das ist unser Taschenrechner Einige Importe für
JUnit
Wir nutzen nur die statische Methode „assertEquals“
Nötig für ältere Umgebungen
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Die CalculatorTest Klasse (Teil II) @Before // must be public not protected like the setup public void clearCalculator() { calculator.clear(); // reset value to 0 }
//================================== // Test cases //================================== @Test public void add() { calculator.add(1); calculator.add(1); assertEquals(calculator.getResult(), 2); }
76
@Before: vor jedem Test ausgeführt; Calculator ist damit 0 vor jedem Test
@Test: Annotation für eine auszuführende Testmethode. Hier wird überprüft, ob 1+1 = 2 gilt.
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Die CalculatorTest Klasse (Teil III) @Test public void subtract() { calculator.add(10); calculator.substract(2); assertEquals(calculator.getResult(), 8); }
@Test public void divide() { calculator.add(8); calculator.divide(2); assertEquals(calculator.getResult(), 5); }
// @Test – deactivated, as it will cause an error (division by 0); more in T16 public void divideByZero() { calculator.divide(0); }
77
Hier wird getestet auf 10-2 = 8 (Fehlschlag durch Bug)
Soll testen auf 8/2=5 (Fehlschlag, da inkorrekt!)
Division durch 0 muss einen Fehler liefern, sonst schlägt der Test fehl
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Die CalculatorTest Klasse (Teil IV) // @Ignore hat einen String-Parameter, der eine Nachricht anzeigt @Test @Ignore("noch nicht testbereit") public void multiply() { calculator.add(10); calculator.multiply(10); assertEquals(calculator.getResult(), 100); }}
78
Ignoriere den Test von multiply, da der Code noch nicht fertig ist.
• Kopieren Sie die Klassen von der Homepage• Stellen Sie sicher, dass JUnit 4.4 installiert ist und als
“External JAR” zum Projekt zugefügt wurde• Selektieren Sie die Klasse CalculatorTest und wählen Sie
Run As JUnit Test• Die Ausgabe sehen Sie auf den nächsten Folien
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
JUnit in Eclipse: Assert-Methoden etc.
79
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
JUnit in Eclipse: Als Testfall starten
80
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Fehlerausgabe von JUnit
81
Logbuch der Tests
Kurzfassung der Ergebnisse
10-2=8 schlug fehl
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Fortgeschrittene Tests
• Wir haben den „divideByZero“-Test nicht genutzt– Wenn wir dies tun, kommt eine (erwartete)
Fehlermeldung!– Wie man auf das Vorhandensein erwarteter Fehler testet,
folgt zusammen mit der Fehlerbehandlung in T16.• Wir haben die squareRoot Methode nicht getestet
– Wäre auch keine gute Idee durch die Endlosschleife…• Wir brauchen eine einmalige allgemeine
Initialisierung– Lege Instanz des Calculator an und schalte ihn an vor den
Tests– Ausschalten, wenn alle Tests fertig sind und freigeben
(=null)• Der nachfolgende Code illustriert das Vorgehen
– Gegenüber der Webseite leicht vereinfacht 82
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Fortgeschrittene Tests: Set-Uppackage junit4demo;
import calc.Calculator;import junit.framework.JUnit4TestAdapter;import org.junit.AfterClass;import static org.junit.Assert.assertEquals;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Test;
/** * This test uses advanced fixture and timeout */public class AdvancedTest { private static Calculator calculator; // Used for backward compatibility (IDEs, Ant and JUnit 3 text runner) public static junit.framework.Test suite() { return new JUnit4TestAdapter(AdvancedTest.class); }
83
Einmal ausführen, wenn alle Tests fertig
Ausführen vor jedem Test
Einmal ausführen vor dem ersten Test
Externe Klasse sichtbar machen (-> T15)
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Test-Initialisierung und Beendigung @BeforeClass // must be public and static public static void switchOnCalculator() { System.out.println("\tSwitch on calculator"); calculator = new Calculator(); calculator.switchOn(); }
@AfterClass // must be public and static public static void switchOffCalculator() { System.out.println("\tSwitch off calculator"); calculator.switchOff(); calculator = null; }
84
Einmal ausführen bevor Testen beginnt: Rechner anlegen und anschalten
Einmal ausführen, wenn alle Tests fertig sind: ausschalten und Rechner freigeben
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Testen mit Timeout //================================== //= Test cases //================================== @Test(timeout = 1000) public void squareRoot() { calculator.squareRoot(2); }
@Test public void square2() { calculator.square(2); assertEquals(4, calculator.getResult()); } // two more tests skipped}
85
Test wird fehlschlagen, wenn nicht in 1000ms fertig (Endlosschleifen!)
Testen auf die Quadrate von 4 & 5
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Testausgabe mit Timeout
86
Testen von squareRoot schlug fehl wegen Timeout
Dr. G. RößlingProf. Dr. M. Mühlhäuser
RBG / Telekooperation©
Grundlagen der Informatik I: T12
Mehr zu JUnit...
• JUnit kann (viel) mehr als hier gezeigt• Das ist aber jenseits des Stoffs der Vorlesung!• Ein Blick in die Doku lohnt sich
– Mitgeliefertes JavaDoc für JUnit– Gute Referenz (und Basis dieser Folien):
Antonio Goncalves, Get Acquainted with the New Advanced Features of JUnit 4
http://www.devx.com/Java/Article/31983/0/page/1
87