Einfuhrung¨ in JAVA - ra.cs.uni- · PDF fileInhalte der Vorlesung Einleitung 1...

Einfuhrung in JAVA

– DR. PETER MERZ –

Wilhelm-Schickard-Institut fur InformatikAbteilung Rechnerarchitektur

Eberhard-Karls-Universitat Tubingen

Inhalte der Vorlesung

Einleitung 1

Programmiersprachen und Compiler 4

Imperative Programmierung mit Java 19

Objektorientierte Programmierung mit Java 63

Zusammenfassung der Java-Sprachkonzepte 133

Peter Merz Einfuhrung in JAVA 2

WWW-Adressen

① Die aktuellen Folien /das Skript sind unterhttp://www-ra.informatik.uni-tuebingen.de/lehre/ws02/java einf.html

verfugbar.

② JAVA-Entwicklungsumgebungen/DK finden Sie unterhttp://java.sun.com/downloads/ (Sun JDK’s)http://www.borland.com/jbuilder/ (Borland JBuilder)

③ JAVA-API-Dokumentation finden Sie unterhttp://www-ra.informatik.uni-tuebingen.de/local/doc/java/1.4.1/docs (Lokal)http://java.sun.com/j2se/1.4.1/docs/api/ (Sun)

④ Das JAVA-Tutorial finden Sie unterhttp://www-ra.informatik.uni-tuebingen.de/local/doc/java/tutorial/ (Lokal)http://java.sun.com/docs/books/tutorial/ (Sun)


Programmiersprachen

Allgemeine Definition einer Programmiersprache:

Sprache zur Formulierung von Rechenvorschriften, die direkt oder indirektvon einem Rechner ausgefuhrt werden konnen

indirekt: Umsetzung der Rechenvorschriften in ein fur den Rechner verstandlichesFormat

Wichtige Eigenschaften einer Programmiersprache (PS):

✓ eindeutige Syntax –Festlegung, welche Zeichenfolgen als Programme zugelassen sind

✓ eindeutige Semantik –Festlegung, welche Auswirkung die Ausfuhrung des Programms auf einemRechner hat


Programmiersprachen

Klassifikation von Programmiersprachen:

• Maschinensprache

– Maschinenprogramm = Folge von elementaren, im Binarcode dargestelltenBefehlen, d.h. im Befehlssatz eines Mikroprozessors

– Maschinenprogramme sind direkt auf der Hardware ausfuhrbar– Maschinenprogramme sind nur sehr schwer verstandlich

• niedere, maschinenorientierte Programmiersprachen Assembler-Sprachen

Programmierung der Hardware unter Verwendung symbolischer Namen

• hohere, problemorientierte Sprachen

– Hardware-Unabhangigkeit– Orientierung an den zu bearbeitenden Problemfeldern– Abbildung in eine Maschinensprache durch Verwendung eines Ubersetzers

(Compiler) oder direkte Ausfuhrung unter Anwendung eines Interpreters


Programmiersprachen

Der Paradigmabegriff:

• Synonyme Begriffe:

Denkmuster, Musterbeispiel

• Musterbeispiel

ein Beispiel, das typisch fur eine Klasse von Beispielen ist, und somit auchals Bezeichnung fur das diesen Beispielen Gemeinsame verwendet wird

• Verwendung des Paradigma-Begriffes in der Informatik

– ein Paradigma bezeichnet ein ubergeordnetes Prinzip– dieses Prinzip ist fur eine ganze Teildisziplin typisch– es ist jedoch nicht klar ausformulierbar, sondern manifestiert sich in

Beispielen


Programmiersprachen

Klassifikation von nach Programmierparadigmen:

➠ imperative Programmiersprachen

➠ funktionale Programmiersprachen

➠ pradikative Programmiersprachen

➠ deskriptive Programmiersprachen

➠ objektorientierte Programmiersprachen

✗ Beachte:

Programmiersprachen konnen Konzepte mehrerer Programmierparadigmenenthalten!Z.B. enthalten einige Objektorientierte Sprachen auch imperative Sprachkonzepte.


Programmiersprachen

Imperative Sprachen:

• imperare (lat.): befehlen

• ein Programm besteht aus einer Folge von Befehlen an den Rechner, z.B.

– schreibe in die Variable a den Wert 3– springe an die Stelle x im Programm

• wichtige Eigenschaften imperativer Programmiersprachen

– wesentlich ist die Verwendung des Variablenkonzepts:Eingabewerte werden in Variablen (Speicherzellen) gespeichert undweiterverarbeitet

– es spiegelt sich deutlich die Architektur des Von Neumann Rechners wider

• Beispielsprachen:

– FORTRAN, C, PASCAL, MODULA


Programmiersprachen

Funktionale Sprachen:

• Programm = Menge von Ausdrucken, die Funktionen definieren

– eine Berechnung ist die Anwendung der Funktion auf eine Liste von Werten– eine solche Anwendung nennt man auch Applikation ➠ Programmaufruf

• Eigenschaften:

– das wichtigste Konstruktionsprinzip ist die Rekursion– Variablen sind keine Behalter, denen Werte zugewiesen werden– Variablen sind Platzhalter fur Werte und Funktionen, mit denen im

mathematischen Sinne symbolisch gerechnet wird– Funktionen konnen als Parameter und als Ergebnisse von Funktionen

auftreten

• Anwendungsgebiete: Kunstliche Intelligenz, Rapid Prototyping

• Beispiele: LISP, SCHEME (LISP-Dialekt fur Ausbildungszwecke), . . .


Programmiersprachen

Pradikative Sprachen:

• bei diesen Sprachen wird die Programmierung als Beweisen in einem Systemvon Tatsachen und Schlußfolgerungen aufgefaßt

• prinzipielle Vorgehensweise:

– Vorgaben durch den Anwender:Fakten ➠ gultige PradikateRegeln ➠ wie gewinnt man aus Fakten neue Fakten

– Aufgabe des Rechners:Beantwortung einer vom Anwender gestellten Frage als richtig, falsch oderdurch Angabe der Variablenwerte, fur die die Aussage erfullt ist

➭ der Anwender muß sein Problem exakt spezifizieren, die Vorgabe einesAlgorithmus zur Problemlosung ist nicht notwendig (und auch nicht moglich)

• Beispiele: PROLOG, OPS5


Programmiersprachen

Deskriptive Sprachen:

• eine deskriptive Programmiersprache dient zur Beschreibung derEigenschaften gesuchter Informationen (ublicherweise Daten aus einerDatenbank)

• Anwendung:Formulierung von Anfragen, Eingaben, Anderungs- und Loschoperationenin (relationalen) Datenbanken

• SQL (Structured Query Language) ist der wichtigste Vertreter deskriptiverProgrammiersprachen

➭ werden in Vorlesung “Informationssyteme” ausfuhrlich behandelt


Programmiersprachen

Objektorientierte Sprachen:

• objektorientierte Programmiersprachen basieren auf einemProgrammiermodell, das von einer (Mini-) Welt ausgeht, welche ausgleichberechtigten und einheitlich erscheinenden Objekten besteht

• Daten und Anweisungen werden als Objekte aufgefaßt

• prinzipielle Struktur eines (rein) objektorientierten Programms:

– es gibt nur Objekte, die sich nach außen einheitlich verhalten und allegleichberechtigt sind

– Objekte besitzen Zustande, fuhren Operationen aus und konnenNachrichten empfangen und verschicken

– Programme enstehen durch Interaktion von Objekten

• Anwendungsgebiete: wiederverwendbare Software, große Softwareprojekte

• Beispiele: SMALLTALK, C++, EIFFEL, JAVA


Interpretation und Ubersetzung von Programmen

Interpreter:

Ein Interpreter ist ein Programm, das Programme einerProgrammiersprache A direkt ausfuhrt.

• Arbeitsweise:

– Schrittweise syntaktische Analyse der Anweisungen des Quellprogramms– Ermittlung der Parameter und Aufruf einer internen Funktion zur Ausfuhrung

einer Anweisung

• Interpretierte Sprachen:APL, BASIC, LISP, PROLOG, POSTSCRIPT



Compiler:

Ein Ubersetzer (Compiler) ist ein Programm, das Programme aus einerProgrammiersprache A in eine Programmiersprache B ubersetzt.

Eine Ubersetzung ist somit die folgende Abbildung:

Quellsprache A⇒ Zielsprache B

Somit wird jedem Quellprogramm genau ein Zielprogramm zugeordnet.

Wichtig:Quell- und Zielprogramm mussen gleiche Bedeutung haben - semantischeKorrektheit!

Ziel:Zielprogramm soll moglichst schnell ausfuhrbar sein bei geringemSpeicherplatzbedarf ➭ Effizienz!



Ubersetzungsphasen:

Quellprogramm

Folge von Token

Ableitungsbaum

Zielprogramm

(effizienteres)Zielprogramm

Lexikalische Analyse

Syntaktische Analyse

Semantische Analyseund Codegenerierung

CodeOptimierung

Lexikalische Analyse:Zerlegung in Token (Scanner)

Syntaktische Analyse:Erzeugung eines Ableitungsbaums (Parser)

Semantische Analyse:Analyse des Ableitungsbaums

Codegenerierung:Erzeugung des Zielprogramms aus demAbleitungsbaum incl. Codeoptimierung

➭ Vorlesung Compilerbau!



Compilerarten:

• Compiler erzeugen i.d.R. Maschinencode fur den Zielrechner➠ sehr schnelle hoch optimierte Programme, die vom Prozessor direktausgefuhrtwerden konnen (Interpretation durch Hardware)

• Crosscompiler ermoglichen Ubersetzung fur andere Rechnerarchitekturen

• Konzept der virtuellen Maschine:

– Generierung plattformunabhangigen Programmcodes– Virtueller Maschinencode muß interpretiert werden– Just-In-Time Compiler konnen die Ausfuhrungsgeschwindigkeit deutlich

erhohen



Plattform(un)abh angige Ubersetzungsvorg ange:

Quellcode Compiler RuntimeSystem

VirtuellerMachinencode

NativeMaschinencode

Hardware

Quellcode Compiler LinkerObjectcode Executable -Maschinencode

Hardware

Just-In-TimeCompiler

Platformunabhängige Sprachen:

Platformabhängige Sprachen:

✓ Anmerkung:

Beide Ansatze haben ihre Vorteile – Portabilitat vs. Performanz!


Programmbibliotheken

API (Application Programming Interface ):

➠ Schnittstelle zu Programmbibliothek(en)

• API sind programmiersprachenabhangig

• Heutige Anwendungsprogrammierung ist undenkbar ohne API

• Beispiele fur API:

– Benutzungsschnittstellen-API (GUI)– Datenbank-API– API fur Internetfunktionen– API fur Betriebssystemfunktionen– API fur mathematische Berechnungen– API fur multimediale Prasentationen, . . .


Die Programmiersprache JAVA

JAVA ist eine von der Firma Sun Microsystems entwickelte objektorientierteProgrammiersprache

JAVA ist . . .

. . . a simple, object-oriented, distributed, interpreted, robust, secure,architectural neutral, portable, high-performance, multithreaded, anddynamic language. (Sun)

Historie von JAVA:

• Mai 1995: Vorstellung von JAVA auf der SUNWORLD’95

• Anfang 1997: Freigabe der Version JAVA 1.1

• Ende 1998: Freigabe der Version JAVA 1.2 (JAVA 2)

• Ende 1999: Freigabe von Version 1.3

• Mai 2001: Freigabe von Version 1.4



Eigenschaften von JAVA:

➠ Plattformunabhangigkeit - Write Once, Run Anywhere

➠ Leichte Entwicklung von Netzwerkanwendungen – insbesondere Internet

➠ Objektorientierung als Basiskonzept

➠ Besondere Unterstutzung verteilter und paralleler Anwendungen

➠ Robuste und sichere Sprache

➠ Lauffahigkeit von JAVA-Programmen im WWW-Browser (Applets)

➠ JAVA ist frei verfugbar (JDK: Java Development Kit))



Sprachkonzepte von JAVA:

• angelehnt an C/C++, aber stark vereinfacht

– Kein Praprozessor– keine Operatoren, Mehrfacherbung, Templates, . . .

• Bewahrte Konzepte anderer Sprachen wurden integriert, z.B.

– Exceptions : Fehlerbehandlung– Garbage Collection : Automatische Speicherfreigabe– Package-Konzept : Zusammenfassung von Klassen– Concurrency : Nebenlaufigkeit durch Threads

• JAVA kommt mit sehr umfangreichen API

– GUI-API: Swing, AWT, Datenbank-Schnittstelle (JDBC)– Network/Internet API inkl. Remote Method Invocation (RMI)– JAVA BEANS: Komponenten-Modell


JAVA Programme

① JAVA-Applikationen (Anwendung, engl. Application)

• Eine JAVA-Applikation ist ein JAVA-Programm, das direkt auf derBetriebssystemebene gestartet werden kann• die Applikation besteht aus einer oder mehreren Klassen• (mindestens) eine Klasse muß eine main-Methode enthalten• eine Applikation wird mit Hilfe des JAVA-Interpreters gestartet und

ausgefuhrt

② JAVA-Applets• Applets sind JAVA-Programme, die in HTML-Seiten eingebunden werden

konnen (HTML: HyperText Markup Language)• Applets konnen durch das Programm appletviewer (Teil des JDK) oder einen

WWW-Browser mit JAVA-Unterstutzung, wie Netscape Communicator oderMicrosoft Internet Explorer ausgefuhrt werden

JAVA-Applikationen werden meistens einfach als JAVA-Programme bezeichnet!


JAVA Programme

Ein einfaches JAVA Programm:

Der Quellcode eines einfachen JAVA-Programms (Dateiname: Hello.java):

// Hello.java// A simple programm displaying ”Hello World”

class Hello {

public static void main( String [] args ) {// System.out.println () : Ausgabefunktion aus der Syatem APISystem.out.println ( ”Hello World!” );}}

Ubersetzen und zu starten mit dem JDK:

– javac Hello.java (Erzeugt die Datei Hello.class)– java Hello (startet das Programm)


JAVA Programme

Notige Schritte zu einem JAVA-Programm:

① Erstellen eines Quellprogrammes mit Hilfe eines Texteditors, z.B. Notepad(Windows) oder kwrite (Unix/KDE)

② Ubersetzen aller Quelldateien/Klassen, z.B. mit javac in derEingabeaufforderungErgebnis: Eine Sammlung von JAVA-Klassen im Bytecode (Dateiendung:.class)

③ Start des Programmes durch Aufruf einer Klasse mit einer statischenmain-Methode mit dem JAVA-Interpreter javaAnmerkung: Die Endung .class muß weggelassen werden!

➭ JAVA-Programm = Sammlung von JAVA-Klassen im Bytecode


Programmierparadigmen in JAVA

Unterscheidung zwischen Programmierung im Großen

Die Konzentration auf das Zusammenwirken von Teilen nennt manProgrammierung im Großen, weil hier von der Gestalt der Teile abstrahiertwird und nur das Außenverhalten betrachtet wird.

und Programmierung im Kleinen

Die Ausformulierung von Teilen nennt man Programmierung im Kleinen, weilauf die Einzelheiten eines Teils bzw. die interne Realisierung geachtet wird.

Programmierung im Großen ➠ Objektorientierte ProgrammierungProgrammierung im Kleinen ➠ Imperative Programmierung


JAVA Syntax

Aufbau eines JAVA-Programms:

• Alle Zeichen zwischen ”/*” und ”*/” oder ”//” und dem Zeilenende werden alsKommentar aufgefaßt

• Ein Programm ist eine Folge von Token , die durch Whitespaces (Leerzeichen,Tabulatoren, Zeilenumbruche) getrennt werden

• Ein oder mehrere Token ergeben eine Anweisung

➠ Ein JAVA-Programm besteht aus einer Folge von Anweisungen !

• Anweisungen sind:

– Deklarationen von Variablen– (Mathematische) (Wert-)Zuweisungen– Methoden-/Funktionsaufrufe– Klassendefinitionen, Methodendefinitionen


JAVA Syntax - Anweisungen und Ausdrucke

Anweisungen und Ausdrucke:

Vorlaufige Definition einer Anweisung :

<Anweisung> ::= <Variablen-Deklaration> | <Wertzuweisung> |<Deklaration und Wertzuweisung> | <Prozeduraufruf>

<Variablen-Deklaration> ::= <Typ> <Bezeichner>;

<Wertzuweisung> ::= <Bezeichner> = <Ausdruck>;

<Deklaration und Wertzuweisung> ::= <Typ> <Bezeichner> = <Ausdruck>;

Ein Ausdruck ist in JAVA ein Bool’scher oder arithmetischer Ausdruck (vorlaufigeDef.):

<Ausdruck> ::= <Konstante> | <Variable> | (<Ausdruck>) |<Unarer Operator> <Ausdruck> |<Ausdruck> <Binarer Operator> <Ausdruck> |<Wertzuweisung> | <Funktionsaufruf>


JAVA Syntax - Gultige Bezeichner

Gultige Bezeichner in JAVA fur Variablen:

• Gultige Bezeichner beginnen mit einem Buchstaben

• Gultige Bezeichner bestehen aus Buchstaben und Zahlen

• Die folgenden reservierten Worter sind nicht als Bezeichner zugelassen:

abstract default if private throw boolean do implementsprotected throws break double import public transient byteelse instanceof return try case extends int short voidcatch final interface static volatile char finally long superwhile class float native switch const for new synchronizedcontinue goto package thissowie true false null !


JAVA Syntax - Primitive Datentypen

Primitive Datentypen in JAVA:

Datentyp Inhalt Bits KEMinimalwert

Maximalwertboolean true oder false 1

char UNICODE-Zeichen 16 c\u0000

\uFFFF

byte vorzeichenbehaftete Integer-Zahl 8 b-128

127

short vorzeichenbehaftete Integer-Zahl 16-32768

32767

int vorzeichenbehaftete Integer-Zahl 32-2147483648

2147483647

long vorzeichenbehaftete Integer-Zahl 64 l-9223372036854775808

9223372036854775807

float IEEE 754-1985 Floating-Point-Zahl 32 f±1.40239846 E -45

±3.40282347 E 38

double IEEE 754-1985 Floating-Point-Zahl 64 d±4.94065645841246544 E- 324

±1.79769313486231570 E 308

KE: Konstantenendung


JAVA Syntax - Primitive Datentypen

Beispiele fur Variablendeklarationen:

int i , j ; // Deklaration von Integervariable i und jfloat x ; double y; // Deklaration von zwei Fliesskommazahlen

i = 10; // Eine ganze Zahl mit dem Wert 10j = i ; // Die Variable j erhaelt den Wert von ix = 5f ; // Das f gibt eine float−Konstante any = −1.2e3; // Eine Zahl mit Exponent −1.2 ∗ 10 hoch 3

int n = 20; // Die Kombination von Deklaration und Wertzuweisungi = j = 42; // Dies ist auch moeglich

✗ Beachte:

Der Ruckgabewert einer Zuweisung ist der zugewiesene Wert!


JAVA Syntax - Operatoren

Unare Operatoren:

Operator Operandentyp Ergebnistyp Beschreibung

− numerisch numerisch Vorzeichenanderung

! boolean boolean Negierung

∼ integral integral bitweises Komplement

(type) numerisch numerisch Typumwandlung (cast)

Bin are Operatoren:

Operator Operandentyp Ergebnistyp Beschreibung

−,+ numerisch numerisch Addition und Subtraktion

∗,/,% numerisch numerisch Multiplikation, Division, Rest

<<,>>,>>> integral integral Bitweise Links-/Rechts-Verschiebung

>,<,==, ! =, <=,>=

numerisch boolean Vergleichsoperatoren

&&,|| boolean boolean Logische UND-/ODER-Verknupfung

&, |, ˆ integral integral Bitweises AND, OR, XOR



Sonderformen:

• Dekrement/Inkrementoperatoren: --, ++

– x--, --x dekrementiert eine numerische Variable (x) um 1– x++, ++x inkrementiert eine numerische Variable (x) um 1– ist der Operator vorangestellt (nachgestellt), ist der Ruckgabewert des

Ausdruckes der neue (alte) Wert der Variable

• Kombinierte Zuweisung und Arithmetik:Operatoren: +=, -=, *=, /=, %=, &=, |=, ˆ=, <<=, >>=, >>>=.

– Die Anweisung x ⊗= y; ist eine Kurzschreibweise fur x = x ⊗ y;



Beispiele zur Verwendung von Operatoren:

int i , j ; // Zwei Integer−Variablenfloat x ; // Flieskommazahl einfacher Genauigkeitdouble y; // Flieskommazahl doppelter Genauigkeitboolean b; // Eine Boolsche Variable

i = 42; // i bekoomt einen sinnvollen Wertj = i >> 1; // j bekommt den Wert 21 == 42 / 2i = j−−; // i bekommt den Wert 21 und j den Wert 20b = (0 <= i && i <= 50); // i liegt zwischen 0 und 50, also b = trueb = !b ; // b = falsex = 5; // x bekommt den Wert 5x /= 10; // x = 5 / 10 = 0.5y = x + 4; // y = 0.5 + 4 = 4.5j = ( int )y ; // j = 4i ++; // So wird der Inkrement−Operator verwendet!



Operator-Priorit aten:

Operator PrioritatZuweisung, Zuweisung mit arithm. Operation 1Logisches ODER, UND 2, 3Bitweises OR, XOR, AND 4, 5, 6Vergleich == und != 7Vergleich <, >, >=, <= 8Verschiebungsoperatoren 9Addition und Subtraktion 10Multiplikation, Division und Rest 11Typumwandlung und restl. unare Operatoren 12

✓ Anmerkung:Die Klammerung eines Teilausdrucks andert die Reihenfolge der Auswertung!



Implizite Typumwandlung:

Wenn die Operanden eines binaren numerischen Operators verschiedene Typenhaben,erfolgt eine implizite Typumwandlung (Numeric Promotion):

• Wenn einer der Operanden von Typ double ist, wird der andere nach doublekonvertiert.

• Andernfalls, wenn einer der Operanden von Typ float ist, wird der andere nachfloat konvertiert.

• Andernfalls, wenn einer der Operanden von Typ long ist, wird der andere nachlong konvertiert.

• Andernfalls werden beide nach int konvertiert.



Beispiel fur Typumwandlung und geschachtelte Ausdrucke:

int i = 4, j = 1;float x = 5, y;double u = 5, v;

y = x + 10 / x ; // y = 5 + 2 = 7 Punkt vor Strich−Rechnung!y = ( x + 10) / x ; // Erst die Addition : y = 15 / 5 = 3

float z = i ∗ x ; // i wird implizit nach float gewandeltint k = ( int )( i ∗ y ); // Das Ergebnis von i ∗ y ist ein float !x = ( float )u ; // Von double nach float casten!v = x ; // Von float nach double nicht noetig

y = x + 1 / i ; // y = 5 + 0 = 5 !!y = x + 1.0 f / i ; // y = 5 + 0.25 = 5.25 !!y = x + ( float ) j / i ; // y = 5 + 0.25 = 5.25 !!


Zeichenketten in JAVA

Zeichenketten - Strings:

Zeichenketten sind in JAVA vom Typ String , und werden mit Hilfe von (doppelten)Anfuhrungsstrichen definiert:

¨Dies ist eine Zeichenkette, also ein String!¨ .

Der + -Operator – auf Strings angewandt – bewirkt eine Konkatenation dieserStrings:

¨Hello ¨ + ¨World¨ ist aquivalent zu ¨Hello World¨

Wenn einer der Datentypen kein String ist, wird er in einen String gewandelt!

String text = ¨Einundzwanzig: ¨ + (17+4);


JAVA Programmbeispiel zu Operatoren

Beispiel Satz des Pythagoras:

// Programm zur Berechnung des Flaecheninhalts sowie der Hypotenuse// eines Dreieckesclass Pythagoras {

public static void main(String [] args) {double a = 3.5, b = 5.5;double flaeche, hypotenuse;

flaeche = a ∗ b / 2;// Math.sqrt(x) berechnet die Quadratwurzel von x: (aus Math API)hypotenuse = Math.sqrt(a∗a + b∗b);

System.out.println( ”Katheten: ” + a + ” cm und ”+ b + ” cm”);System.out.println( ”Flaecheninhalt: ” + flaeche + ” qcm”);System.out.println( ”Hypothenusenlaenge: ” + hypotenuse + ” cm”);

}}


JAVA Programmierregeln

Regeln furs strukturierte Programmieren:

✓ Deklarationen und Zuweisungen trennen

✓ Mehrfachzuweisungen vermeiden

✓ Dekrement-/Inkrementoperatoren sowie Zuweisungen nur in separatenAnweisungen verwenden

✓ Jeden neuen Anweisungsblock einrucken

✓ Kommentare!

✓ Komplexe Ausdrucke klammern, um Lesbarkeit zu erhohen

✓ Eine Anweisung pro Zeile!

✓ Aussagekraftige Variablennamen verwenden!


Verzweigungen in JAVA

Verzweigungen im Programmfluß

(auch Sprunge genannt) lassen sich ebenfalls in JAVA realisieren.

Zunachst lassen sich Anweisungen zu einem (Anweisungs-)Blockzusammenfassen, der selbst eine Anweisung darstellt:

<Anweisungsfolge> ::= <Anweisung> |<Anweisungsfolge> <Anweisungsfolge>

<Anweisungsblock> ::= { <Anweisungsfolge> }

Die zuvor gegebene Definition einer Anweisung wird nun erweitert:

<Anweisung> ::= . . . | <Anweisungsblock> | <Bedingte Anweisung> | <Schleife>


JAVA Syntax - Bedingte Anweisungen

Die If-Anweisung:

Will man eine Anweisung nur unter einer Bedingung ausfuhren lassen, soverwendet man eine if-Anweisung:

<If-Anweisung> ::= if ( <Bedingung> ) <Anweisung> |if ( <Bedingung> ) <Anweisung>else <Anweisung>

Somit besteht die If-Anweisung aus einer Bedingung, die durch einen (bool’schen)Ausdruck gegeben ist, und einer Anweisung, die ausgefuhrt wird, wenn dieAuswertung des Ausdruckes true ergibt.

Optional kann ein else -Zweig angegeben werden, der ausgefuhrt wird, wenn dieBedingung nicht erfullt ist.



Beispiele fur if-Anweisungen:

/∗ Eine ganz einfache If−Anweisung ∗/if ( x < 0) x = −x; // somit ist x immer positiv (Betragfunktion)

/∗ Eine If−Anweisung mit else−Zweig ∗/if ( x != 0) y = y / x;else y = 0;

/∗ Eine If−Anweisung mit else−Zweig und Anweisungsablock ∗/if ( x < 0) {

System.out.println( ”x war negativ”);x = −x;

} else {System.out.println( ”x war positiv” );

}



Die Switch-Anweisung:

Fur aufwendige Fallunterscheidungen eignet sich die switch-Anweisung:

<Switch-Anw.> ::= switch ( <Ausdruck> ) {case <Konstante-1>: <Anweisungsfolge>case <Konstante-2>: <Anweisungsfolge>.. .default: <Anweisungsfolge>

}

Ergibt der Ausdruck den Wert von Konstante-i, so werden alle Anweisungen nachderentsprechenden case <Konstante-i >: -Anweisung ausgefuhrt bis zum Ende derSwitch-Anweisung oder bis zum ersten Auftreten der Anweisung break !



Beispiele fur Switch-Anweisungen:

int zahl;zahl = 42; // Setze zahl auf irgendeinen Wert, z.B. 42

/∗ Zwei Switch Anweisungen ∗/switch (zahl) {

case 0: System.out.println( ”Null ” ); break ;case 1: System.out.println( ”Eins” ); break ;case 2: System.out.println( ”Zwei” ); break ;case 3: System.out.println( ”Drei” ); break ;default : System.out.println( ”So hoch kann ich nicht zaehlen!”);}

switch (zahl) {case 0: System.out.println( ”Null ” ); break ;case 1:case 2: System.out.println( ”Kleiner als Drei” ); break ;case 3: System.out.println( ”Drei” ); break ;default : System.out.println( ”So hoch kann ich nicht zaehlen!”);}


JAVA Syntax - Schleifen

Die While-Schleife:

Die While-Schleife ermoglicht die wiederholte Ausfuhrung einer Anweisung (odereines Anweisungsblockes) solange eine Bedingung (bool’scher Ausdruck) erfulltist.

<While-Schleife> ::= while ( <Bedingung> ) <Anweisung> |do <Anweisung> while ( <Ausdruck> );

Es gibt zwei Varianten der While-Schleife:

Bei der ersten (zweiten) Variante wird die Bedingung vor (nach) Betreten derSchleife gepruft.



Beispiele fur While-Schleifen:int i , n;i = 1; n = 42; // i und n werden initialisiert

/∗ Zaehle von 1 bis 42 ∗/while ( i <= n ) {

System.out.println( i );i = i + 1; // Kurzschreibweise: i++;

}

/∗ i ist jetzt n + 1, Schleife wird nicht durchlaufen ∗/while ( i <= n ) i++;

System.out.println( i ); // Ausgabe: 43

/∗ i wird um eins erhoeht ∗/do i++; while ( i <= n );

System.out.println( i ); // Ausgabe: 44



Die For-Schleife:

Eine Alternative zur While-Schleife ist die For-Schleife:

<For-Schleife> ::= for (<Zuweisung> <Bedingung>; <Ausdruck>)<Anweisung>

Vor Beginn der Schleife wird die Zuweisung ausgefuhrt, dann wird eine Bedingunguberpruft, und solange diese erfullt ist, die Anweisung(oder ein Anweisungsblock) ausgefuhrt und <Ausdruck> ausgewertet.

Sie wird haufig wie folgt verwendet:

<For-Schleife> ::= for ( <Variable> = <Konstante>;<Variable> <Vergleichsoperator> <Ausdruck>;<Inkrement/Dekrement-Operator>) <Anweisung>



Beispiele fur For-Schleifen:

int i ;int n;

n = 10;

/∗ Ausgabe der Zahlen von 0 bis n − 1 = 9 ∗/for ( i = 0; i < n; i++) {

System.out.println( i );}

/∗ Ausgabe der Zahlen von 10 bis 1 in absteigender Reihenfolge ∗/for ( i = 10; i > 0; i−−) {

System.out.println( i );}



Anmerkungen zu Schleifen:

• Schleifen konnen beliebig geschachtelt werden!

• Vorsicht vor Endlosschleifen!

• Mit break kann das sofortige Verlassen einer Schleife erzwungen werden

• Mit continue kann sofort an den Anfang der Schleife gesprungen werden

– Die restlichen Anweisungen im Anweisungsblock werden ubersprungen– Bei For -Schleifen wird <Ausdruck> ausgefuhrt

• break und continue sollten moglichst nicht verwendet werden



Aquivalente Ausdrucke:

/∗ A: ∗/while ( true ) {

// ... Anweisungen ...if ( bedingung ) break ;// ... Anweisungen ...

}

/∗ B: ∗/while ( bedingung ) {

// ... Anweisungen ...if (! bedingung ) {// ... Anweisungen ...}

}

/∗ A: ∗/for ( i = 0; i < n; i ++ ) {

// ... Anweisungen ...if ( bedingung ) continue ;// ... Anweisungen ...

}

/∗ B: ∗/for ( i = 0; i < n; i ++ ) {

// ... Anweisungen ...if (! bedingung ) {// ... Anweisungen ...}

}

➠ break und continue nicht erforderlich!


Schleifen in JAVA - Programmbeispiele

Beispielprogramm 1:

Ausgabe des ASCII-Zeichensatzes

// Programm zur Darstellung des ASCII−Zeichensatzesclass ZeichenSatz {

public static void main(String [] args) {int i , j ;

System.out.println( ”Der ASCII−Zeichensatz:”);for ( i = 2; i < 16; i++) {

for ( j = 0; j < 16; j++) {char zeichen = (char )(16 ∗ i + j );System.out.print(zeichen);

}

System.out.println ();}

}}



Beispielprogramm 2:

Berechnung der Quadratwurzel:

Gesucht ist ein JAVA-Programm zur Berechnung der Quadratwurzel nach derNewtonschen Methode.

(Iterationsverfahren, das ausgehend von einem willkurlich vorgegebenen Startwerteine Folge besser werdender Approximationen von

√x liefert.)

Bei gegebenem Startwert s0 ergeben sich die Folgewerte nach der Vorschrift:

si+1 =xsi

+si

2

Z.B. Iterationen Fur die Quadratwurzel von 2:

s0 = 1 ⇒ s1 = 1.5, s2 = 1.41666, s3 = 1.41421. . .



// Programm zur Berechnung der Quadratwurzelclass QuadratWurzel {

public static void main(String [] args) {double x, s, genauigkeit;int i ;

s = 1; // Startwert s0x = 17; // Die Wurzel von x=17 soll berechnet werdengenauigkeit = 1e−8; // Die Genauigkeit der Annaeherungi = 0;while ( Math.abs(s∗s − x) > genauigkeit) { // Math.abs(): Math API

System.out.println( i + ”. Naeherung: ”+ s);s = ( x / s + s ) / 2;i++;

}System.out.println( ”Quadratwurzel von ” + x + ”: ” + s);

}}


Arrays in JAVA

Eindimensionale Arrays:

Arrays (dt.: Felder) bieten die Moglichkeit, eine beliebige Anzahl von Variablengleichen Typs simultan zu erzeugen.

Zunachst muß eine Referenz-Variable deklariert werden:

<Array-Referenz-Deklaration> ::= <Typ> [] <Bezeichner>;

Die Erzeugung eines Feldes mit vorgegebener Große (<Ausdruck>) erfolgtanschließend:

<Array-Definition> ::= <Bezeichner> = new <Typ>[<Ausdruck>];

<Ausdruck> muß einen ganzzahligen Wert (int ) großer 0 ergeben.


Arrays in JAVA

Eindimensionale Arrays (con’t):

Der Zugriff auf diese Variablen erfolgt durch Indizierung (<Ausdruck>):

<Array-Variable> ::= <Bezeichner>[<Ausdruck>]

<Ausdruck> muß einen ganzzahligen Wert (vom Typ int ) großer gleich 0 ergeben.

Die Lange/Große eines Arrays ergibt folgender Ausdruck:

<Array-Große> ::= <Bezeichner>.length

Achtung:✓ Ein Array beginnt bei Index 0 und endet bei seiner Große - 1!


Arrays in JAVA

Beispiele fur eindimensionale Arrays:

double [] a ; // Array−Referenz bereitstellenint i , n;int ersterWert, letzterWert ;

n = 42;a = new double [n]; // Erzeugen des Feldes

// a.length == n!for ( i = 0; i < a.length ; i++) {

a[ i ] = 42 − i ; // Wertzuweisung}

ersterWert = a [0]; // Ermittlung des Array−Wertes fuer Index 0letzterWert = a[n − 1]; // Ermittlung des Array−Wertes fuer letzten Index

System.out.println( ”Laenge: ” + a.length + ” == ” + n);System.out.println( ”Wert von a[0]: ” + ersterWert);


Arrays in JAVA

Programmbeispiel zu Arrays:

Berechnung von Minimum, Maximum, Mittelwert und Standardabweichung einerZufallszahlenfolge x = {x1, . . . ,xn}:

Mittelwert berechnet sich uber die Formel:

x =1n

n

∑i=1

xi

Die Standardabweichung ist definiert als:

σ(x) =

√1

n−1

n

∑i=1

(xi− x)2


Arrays in JAVA

// Programm zur Berechnung von Minimum, Maximum, Mittelwert und// Standardabweichung einer Zufallsfolgeclass Statistik {

public static void main(String [] args) {int n = 10000; // Anzahl der Zufallszahlendouble [] zufall ; // Die Referenz des Zufallszahlenvektorsdouble standardabw;double mittelwert;double min, max; // Die zu berechnenden Wertedouble sum; // Eine Hilfvariable fuer die Summenbildungint i ; // Ein Schleifenzaehler

/∗ Erzeuge n Zufallszahlen: ∗/zufall = new double [n]; // erzeugt Platz fuer n Zahlenfor ( i = 0; i < n; i++) zufall [ i ] = Math.random(); // <− Math API

/∗ Berechnung des Mittelwertes, Min und Max: ∗/sum = 0; min = 1; max = 0;


Arrays in JAVA

for ( i = 0; i < n; i++) {sum += zufall[ i ]; // berechne Summeif ( min > zufall [ i ]) min = zufall [ i ];if ( max < zufall[ i ]) max = zufall [ i ];

}mittelwert = sum / n;

/∗ Berechnung der Standardabweichung: ∗/sum = 0;for ( i = 0; i < n; i++) {

sum += (mittelwert − zufall [ i ]) ∗ ( mittelwert − zufall [ i ]);}standardabw = Math.sqrt(sum / (n − 1.0));

/∗ Bildschirmausgabe: ∗/System.out.println( ”Minimum : ” + min);System.out.println( ”Maximum : ” + max);System.out.println( ” Mittelwert : ” + mittelwert );System.out.println( ”Standardabweichung : ” + standardabw);

}}


Arrays in JAVA

Mehrdimensionale Arrays:

Analog zu eindimensionalen Arrays konnen mehrdimensionale Arrays definiertwerden:

• Statt einem eckigen Klammerpaar werden jetzt mehrere Klammernpaare(in Abhangigkeit der Dimensionszahl) benotigt

• Ein mehrdimensionales Array kann als Array von Arrays angesehen werden

• Die Anzahl der Elemente der einzelnen Arrays kann unterschiedlich sein


Arrays in JAVA

Beispiele fur mehrdimensionale Arrays:

double [][] a ; // Array−Referenz bereitstellenint [][] b;

// ... Werte fuer n und m festlegen ...

a = new double [n][m]; // Erzeugen des Feldesfor ( i = 0; i < n; i++)

for ( j = 0; j < m; j++) {a[ i ][ j ] = (42 − i ) ∗ j ; // Wertzuweisung

}

b = new int [n ][];for ( i = 0; i < b.length ; i++) {

b[ i ] = new int [i + 2]; // b[ i ]’ s sind unterschiedlich lang!}for ( i = 0; i < b.length ; i++)

for ( j = 0; j < b[ i ]. length ; j++) {b[ i ][ j ] = i ∗ j ; // Wertzuweisung

}


Parameter eines JAVA-Programms

Verarbeitung von Programmparametern:

Die Argumente (Parameter beim Programmaufruf) einer JAVA-Applikation werdender main() -Funktion in einem Array von Strings ubergeben.

Das folgende kleine Programm gibt diese Parameter als einen String aus:

// Ein Programm zur Ausgabe der Parameter einer// JAVA−Applikationclass Parameters {

public static void main( String [] args ) {String parameters = ””;

for ( int i = 0; i < args.length ; i++) parameters += args[i] + ” ” ;System.out.println(parameters);

}}


Einfuhrung in die Objektorientierung

Was ist eine Klasse ?

Eine Klasse beschreibt die Eigenschaften und das Verhalten einer Mengegleichartiger Objekte.

• Eine Klasse kapselt Daten und Operationen auf diesen Daten➠ Datenkapselung!

• Eigenschaften – Attribute – werden durch primitive Datentypen oder komplexeDatentypen = Klassen festgelegt

• Operationen sind Prozeduren/Funktionen, die die Daten lesen oder verandern,sie werden Methoden genannt

• i.d.R. legt eine Klasse keine Auspragung von Eigenschaften fest

• Die Schnittstelle legt von außen verwendbare Methoden/Attribute fest

• Interne Methoden/Attribute dienen zur Realisierung des Verhaltens und werdenvor dem Benutzer verborgen ➠ Geheimnisprinzip!



Was ist ein Objekt ?

Ein Objekt erhalt alle Eigenschaften seiner beschreibenden Klasse, d.h. eserhalt alle Attribute und Methoden dieser Klasse. Daruber hinaus erhalt esAuspragungen fur alle Eigenschaften, d.h. es besitzt einen Zustand, in demes sich von anderen Objekten derselben Klasse unterscheiden kann.

• Ein Objekt wird auch als Instanz einer Klasse bezeichnet

• In einem Objekt nehmen in der Klasse definierte Attribute konkrete Werte an

• Es konnen beliebig viele Objekte einer Klasse gleichzeitig existieren



Beispiele fur Klassen und Objekte aus der realen Welt:

Klasse Objekt AttributeAuto Mein Golf, Ernies Ente, Toms Trabbi Besitzer, Farbe, AlterKatze Moritz, Omas scharzer Kater Name, BesitzerSchauspieler Heinz Ruhmann, Sandra Bullock Alter, Geschlecht, Genre

Beispiele in der Informationsverarbeitung:

Klasse Objekt AttributeFenster Editorfenster Hintergrundfarbe, Titel, GroßeDrucker HP SW Laser, Canon Tintenstrahldr. Auflosung, BefehlssatzGrafikelement Linie, Kreis, Rechteck Koordinaten, Fullmuster



Schritte der objektorientierten Softwareerstellung:

① Problemanalyse (OOA)

② Designphase (OOD)

• Einteilung der Daten und Funktionalitat des Programmes in Klassen/Objekte– Bilden einer Klassenhierarchie: Generalisierung und Spezialisierung– Festlegen von Ist-Teil-von-Beziehungen, . . .

• Festlegung der Schnittstellen der Klassen• Definition der Interaktion zwischen Objekten verschiedener oder gleicher

Klassen

③ Implementation

• Implementierung der Schnittstellenfunktionen und internen Funktionen

✗ Anmerkung: Softwareentwicklung ist ein iterativer Prozeß!


Objektorientierte Programmierung in JAVA

Syntax einer Klassendefinition (vorlaufig):

<Klasse> ::= class <Klassen-Bezeichner> {<Attribute><Konstruktoren><Methoden>

}

Eine Klasse kann also aus einer Reihe von Attributen, Konstruktoren undMethoden bestehen.

Im folgenden werden der Reihe nach Attributdefinitionen sowie Konstruktor- undMethodendefinitionen besprochen.



Modifizierer:

Modifizierer bestimmen den Zugriff auf Methoden und Attribute:

<Modifizierer> ::= public | protected

• public : von anderen Objekten aus aufrufbar

• protected : nur innerhalb des Objektes benutzbar

✗ Anmerkung:Diese Definition ist vorlaufig. Weitere Modifizierer kommen spater hinzu.



Attribute sind i.d.R. Variablen von primitiven Datentypen, die Eigenschaften vonKlassen/Objekten beschreiben:

<Attribute> ::= ε | <Attribute> <Attribute> |<Modifizierer> <Typ> <Bezeichner>;

Beispiele:

public int size ; // Die Laenge einer Datenstrukturprotected double [] x; // Ein Array von Flieskommazahlenprotected String name; // Der Name eines Objektes als Zeichenketteprotected float prozentsatz; // Der Prozentsatz einer Statistischen Erhebung



Parameter-Definitionen kann man sich als eine Folge vonVariablen-Deklarationen vorstellen, die durch Kommata getrennt werden. DieDefinition von Parametern hat folgende Syntax:

<ParameterDef> ::= ε | <P-Liste>

<P-Liste> ::= <TYP> <Bezeichner> | <P-Liste>, <P-Liste>

Parameter werden durch eine Folge von Ausdrucken, die durch Kommagetrennt sind, beschrieben.

<Parameter> ::= ε | <Ausdr-Liste>

<Ausdr-Liste> ::= <Ausdruck> | <Ausdr-Liste>, <Ausdruck>



Konstruktoren:

Konstruktoren werden nur bei Instanziierung (Erzeugung) eines Objektes derKlasse aufgerufen. Sie tragen den Namen der Klasse:

<Konstruktoren> ::= ε | <Konstruktoren> <Konstruktoren> |<Modifizierer> <Klassen-Bezeichner>(<ParameterDef>)

<Anweisungsblock>

Beispiele:

public MeineKlasse() { // Ein Konstruktor ohne Parameter// ..

}

public MeineKlasse(String text) { // Ein Konstruktor mit einem Parameter//..

}



Methoden:

Methoden haben einen Ruckgabewert fur den der Typ angegeben werden muß,sowie eine Parameterliste, die leer sein kann:

<Methoden> ::= ε | <Methoden> <Methoden> |<Modifizierer> <Typ> <Bezeichner>(<ParameterDef>)

<Anweisungsblock>

Mit der Anweisung return <Ausdruck>; wird ein Ruckgabewert festgelegt,dessen Typ dem deklarierten Ruckgabe-Typ entsprechen muß.

Wird anstelle eines Ruckgabe-Typs das Schlusselwort void verwendet, hat dieMethode keinen Ruckgabewert.



Beispiele fur Methodendefinitionen:

// Eine Prozedur die nur Klassenintern verwendet werden kannprotected void init ( int n) {

// ...}

// Eine (Mathematische) Funktionpublic double sinus(double x) {

// ...}

// Eine methode mit Parametern unterschiedlicher Typen// ( MyClass ist eine selbstdefinierte Klasse)

public int doit ( int m, double x, float y , int [] a , String s , MyClass obj) {// ...

}



Beispiel fur eine Klassendefinition:

class BeispielKlasse {// Definition von Datenfeldernprotected int value;

// Definition von Konstruktorenpublic BeispielKlasse() {

value = 0;}

// Definition von Methodenpublic int getValue() {

return value;}

public void setValue(int v) {value = v;

}}


Objekte in JAVA

Erzeugung von Objekten:

Klassen werden wahrend des Programmierens festgelegt, Objekte hingegen zurLaufzeit erzeugt ➠ Mechanismus zur Instanziierung notwendig

In Java gibt es keine Objekt-Variablen. Es gibt nur Objektreferenzen, d.h. Verweiseauf Objekte!

Syntax zur Deklaration einer Objekt-Referenz:

<Objektreferenz-Deklaration> ::= <Klasse> <Bezeichner>;

Ist ein Bezeichner eine gultige Objektreferenz, so kann mit Hilfe von new ein neuesObjekt erzeugt und dieser Referenz zugewiesen werden:

<Instanziierung> ::= <Bezeichner> = new <Klasse>(<Parameter>);


Objekte in JAVA

Beispiel fur die Erzeugung von Objekten:

class MyClass {// ...

}

MyClass object1;

object1 = new MyClass();MyClass object2 = new MyClass();

object1 und object2 sind Instanzen der Klasse MyClass.

Die Objekte mussen nicht explizit nach ihrer Benutzung geloscht werden, diesubernimmt der Garbage Collector!

Klassen sind Typen ➠ sie werden ahnlich wie primitive Datentypenverwendet Ahnlichkeit zu Arrays!


Objekte in JAVA

Zugriff auf Methoden und Attribute:

Der Zugriff auf offentliche Attribute und Methoden erfolgt mit Hilfe desDereferenzierungsoperators “.” :

Syntax fur den Attributzugriff:

<Attribut-Zugriff> ::= <Objekt-Referenz>.<Attribut-Bezeichner>

Syntax fur den Methoden-Aufruf:

<Methoden-Aufruf> ::= <Objekt-Referenz>.<M-Bezeichner>(<Parameter>);

✗ Anmerkung:Innerhalb einer Klasse braucht keine Objektreferenz dem Methodennamen oderAttributnamen vorangestellt werden!


Objekte in JAVA

Beispiel fur Objektdereferenzierung:

// Beispielklasse fuer Dereferenzierungclass Beispiel {

// Attributpublic int value;

// Methodenpublic void calculate () {

// ...}

public double sinus(double x) {// ...

return y;}

}

double x, y;int n;Beispiel object ;

object = new Beispiel();

// Zugriff auf Attribut :

x = 3.0 ∗ object .value;

object .value = 12 ∗ n;

// Methoden−Aufruf

object . calculate ();

y = 1.0 / object .sinus(x );


Objekte in JAVA

Programmbeispiel Quadratwurzelberechnung:

// Programm zur Berechnung der Quadratwurzelclass Sqrt {

protected double genauigkeit; // Die Genauigkeit der Berechnung

// Der Konstruktorpublic Sqrt(double g) {

genauigkeit = g;}

// Die Berechnungsfunktionpublic double calculate(double x) {

double s;

// PI = 3.14156;s = 1; // Festlegung des Startwerteswhile ( Math.abs(s∗s − x) > genauigkeit) s = (x / s + s ) / 2;return s ; // Rueckgabewert ist die berechnete Wurzel

}


Objekte in JAVA

}

class QuadratWurzelOO {

public static void main(String [] args) {double x, y;Sqrt sqrt ;Sqrt sqrtGenau;

x = 9;sqrt = new Sqrt(1e−5);sqrtGenau = new Sqrt(1e−10);

y = sqrt . calculate(x );System.out.println( ”Quadratwurzel mit einfacher Genauigkeit: ” + y);

y = sqrtGenau.calculate(x);System.out.println( ”Quadratwurzel mit hoher Genauigkeit: ” + y);

}


Methoden in JAVA

Es gibt verschiedene Arten von Methoden:

• Methoden ohne Ruckgabewert ➠ Prozeduren (stellen Anweisungen dar)

• Methoden, die in Abhangigkeit eines oder mehrerer Parameter ein Ergebniszuruckliefern ➠ Funktionen (konnen in Ausdrucken verwendet werden)

Beispiel:

public void calculateY() {// set a value for x ...

if ( isValid (x ) ) y = 1.5 / ( abs(x) + z ) / PI;else reportError(x );

// ...}


Methoden in JAVA

Beispiel (con’t):

protected double abs(double x) {if ( x < 0) x = −x;return x;

}

protected boolean isValid(double x) {return (x != 0);

}

protected void reportError(double x) {System.out.println( ”The value of x was invalid: ” + x);// ...

exitProgramm(); // Sofortiges Beenden des Programmes}


Methoden in JAVA

Es wird zwischen internen Methoden und offentlichen Methoden unterschieden:

• Interne Methoden werden nur von Methoden des selben Objekts aufgerufen

• Offentliche Methoden konnen aus allen Objekten aufgerufen werden

➭ Modifizierer: public fur offentliche und protected fur interne Methoden

Weiterhin lassen sich Methoden danach unterscheiden, ob sie den Zustand einesObjektes andern ➠ Anderung eines oder mehrerer Attribute:

class Sqrt { // ... wird erweitert :// ...

public void setPrecision(double p) {genauigkeit = p;

}}


Methoden in JAVA

Methodenaufrufe:

Was passiert bei einem Methodenaufruf?

① Die Parameter-Ausdrucke werden den Variablen in der Parameterlistezugewiesen

② Die Anweisungen im Anweisungsblock werden der Reihe nach ausgefuhrt

③ Bei Methoden mit Ruckgabewert legt der durch die return -Anweisungangegebene Ausdruck den Wert des Methoden-Ausdrucks fest

Beispiel:public void sort( int n, int [] array , String text ) {

System.out.println( text );sortarray = array;quicksort (0, n);System.out.println( ”Quicksort has finished!” );

}


Methoden in JAVA

public void doSort1() { // Die erste Version des Sortierensint [] a;a = new int [42];sort (a.length / 2, a , ”Ein Array der Laenge 21”);

}

public void doSort2() { // Die zweite Version des Sortierensint [] a;a = new int [42];{ // Dieser Anweisungsblock ist aquivalent mit dem Aufruf von sort

int n = a.length / 2; // Den Parametern wird ein Wert zugewiesenint [] array = a;String text = ”Ein Array der Laenge 21”;

System.out.println( text ); // Der Anweisungsblock von sortsortarray = array;quicksort (0, n);System.out.println( ”Quicksort has finished!” );

}}


Methoden in JAVA

Methodenaufrufe (Funktionsaufrufe) in Ausdrucken:

Die Auswertung von Ausdrucken kann man sich als eine schrittweise Ersetzungvon Teilausdrucken vorstellen, bis der komplette Ausdruck ersetzt ist:

Sei x = 4 und y = 9:

2*x*x-(3+x)*(y-7) ➠ 8*x-7*2 ➠ 32-14 ➠ 18

Analog werden Methodenaufrufe in Ausdrucken durch ihren Ruckgabewert ersetzt.

Sei folgende Methode (Funktion) gegeben:

public double abs(double x) {if ( x < 0) x = −x;return x;}

Dann ergibt sich: 2*abs(1-x) ➠ 2*abs(-3) ➠ 2*3 ➠ 6


Methoden in JAVA

Seiteneffekte sollten vermieden werden:

Eine Methode, die als Funktion in zusammengesetzten Ausdrucken verwendetwird, sollte keine Attribute einer Klasse andern:

class Seiteneffekte { // So sollte man es nicht machen !!!!!!!!!!!!!protected int a; // Ein einfaches Attribut

public int abs(int x) {if ( x < 0) x = −x; // Der Absolutwert wird berechneta = −x; // Hier wird das Attribut veraendert!return x;

}

public void calculate( int x , int y) {int n;/∗ Das Ergebnis dieses Ausdrucks haengt von der Auswertungsreihenfolge

der Teilausdruecke ab: ∗/n = a∗abs(x)−(a−abs(y));

}}


Gultigkeitsbereiche in JAVA

Regeln fur Gultigkeitsbereiche von Variablen und Referenzen:

Fur als Parameter von Methoden/Konstruktoren deklarierte Variablenund Referenzen (Bezeichner) gilt:

✓ Sie sind nur in der Methode bzw. dem Konstruktor gultig!

✓ Sie uberdecken alle Attribute mit dem gleichen Bezeichner, die in der selbenKlasse definiert sind!

Fur in Anweisungsbl ocken deklarierte Variablen und Referenzen(Bezeichner) gilt:

✓ Sie sind nur in diesem Anweisungsblock gultig!

✓ Sie uberdecken alle Attribute mit dem gleichen Bezeichner, die in der selbenKlasse definiert sind!



Statische Bindung:

Die Regeln fur die Gultigkeitsbereiche habe eine wichtige Konsequenz:

In JAVA ist statische Bindung realisiert, d.h. bei der Definition einer Klassewerden die Gultigkeitsbereiche der Variablen festgelegt.

➠ Der Aufruf einer Methode hat, unabhangig von wo sie aufgerufen wird, immerdie gleiche Semantik (sofern die Parameter die selben sind)!

Es folgt ein Beispiel.



class Gueltig {public static void main(String [] args) {

Beispiel beispiel ;beispiel = new Beispiel (7.0); // Aufruf des Konstruktorsbeispiel . printx (); // Ausgabe des Attributsbeispiel .methode1(2.4);beispiel .methode2();

}}

class Beispiel {protected int x;

public Beispiel(double x) {this .x = 42; // this ist eine Refernz auf sich selbst !System.out.println(x ); // Ausgabe von x

}

public void printx () {System.out.println(x ); // Ausgabe des Attributes

}



public void methode1(double x) {System.out.println(x );printx ();

}

public void methode2() {{ // Hier beginnt ein neuer Anweisungsblock

double x;x = 3.45;System.out.println(x );

} // Hier endet der 1. AnweisungsblockSystem.out.println(x );{ // Hier beginnt ein 2.Anweisungsblock

int x;x = −1;System.out.println(x );

} // Hier endet der 2. AnweisungsblockSystem.out.println(x );

}

}


Referenzen in JAVA

Referenzen auf Objekte und Arrays:

Da auf Arrays und Objekte nur Referenzen verwaltet werden, bewirkt dieZuweisung nur ein Kopieren von Referenzen nicht aber den Inhalt der Arrays bzw.Objekte

Konsequenzen:

➠ Mehr als eine Referenz kann auf das selbe Objekt zeigen:Mogliche Seiteneffekte mussen beachtet werden!

➠ Das Kopieren von Objekten oder Arrays muß der Programmierer ubernehmen!

➠ Zwei Referenzen sind gleich, wenn sie auf das selbe Objekt zeigen

➠ Zwei unterschiedliche Referenzen konnen auf gleiche Objekte zeigen

Beispiel fur Referenzen und Objekte: Kinokarten und Sitzplatze


Referenzen in JAVA

Grafische Darstellung:

Objekt A

Referenz:simple1

Klasse Simple

Objekt B

Referenz:simple3

Referenz:simple2


Beispiel fur Referenzen in JAVA

// Eine einfache Klasse, die// einen Integer−Wert speichertclass Simple {

protected int value; // Der Wert

public Simple(int val ) { // Der Konstruktor zur Initialisierungvalue = val ;

}

public Simple(Simple orig) { // Ein Kopierkonstruktorvalue = orig .value; // der ein Objekt in ein neues kopiert

}

public void setValue(int val ) {value = val ; // Setzen des Wertes

}

public void print () {System.out.println(value ); // Ausgabe des Wertes

}}


Beispiel fur Referenzen in JAVA

class Referenzen {public static void main(String [] args) {

Simple simple1, simple2, simple3;

simple1 = new Simple(1); // Ein neues Objekt mit dem Wert 1simple2 = new Simple(2); // Ein neues Objekt mit dem Wert 2simple3 = simple1; // Eine 2. Referenz auf das erste Objekt

simple1.print (); simple2.print (); simple3.print (); // Ausgabe: 1 2 1

simple1.setValue(42); // Veraenderung des 1. Objekts

simple1.print (); simple2.print (); simple3.print (); // Ausgabe: 42 2 42

simple1.setValue(1); // Das 1. Objekt bekommt seinen alten Wertsimple3 = new Simple(simple1); // Ein drittes Objekt wird erzeugtsimple1.setValue(42); // Das 1. Objekt wird veraendert

simple1.print (); simple2.print (); simple3.print (); // Ausgabe: 42 2 1}

}


Beispiel fur Referenzubergabe in JAVA

class Integer { // Eine Klasse die eine Integer Variable enthaeltpublic int value;

}

class Increment {public int increment(int value) {

value++; // Eine Variable aus der Parameterliste wird inkrementiertreturn value;

}

public int increment(Integer integer ) {integer .value++; // Ein Attribut eines Objektes wird inkrementiertreturn integer .value;

}

public int increment(int [] values) {values[0]++; // Ein Element eines Arrays wird inkrementiertreturn values[0];

}}


Beispiel fur Referenzubergabe in JAVA

class ReferenzenUebergabe {public static void main(String [] args) {

int value, retvalue ;

Increment increment = new Increment(); // Ein neues Inkrement−ObjektInteger integer = new Integer(); // Ein neues Integer−Objektint [] values = new int [1]; // Ein neues int−Array

value = 41; values [0] = 41; integer .value = 41; // Initialisierung auf 41

retvalue = increment.increment(value);System.out.println(retvalue + ” ” + value ); // Ausgabe: 42 41

retvalue = increment.increment(integer);System.out.println(retvalue + ” ” + integer .value ); // Ausgabe: 42 42

retvalue = increment.increment(values);System.out.println(retvalue + ” ” + values [0]); // Ausgabe: 42 42

}}


Konstanten in JAVA

Unver anderliche Attribute:

Bisher haben wir nur Attribute definiert, die veranderlich sind.

Mit dem Modifizierer final konnen wir bei der Definition des Attributs angeben,daß es nicht verandert werden darf.

Somit konnen wir z.B. fur Konstanten Namen vergeben!

Beispiel:

class Konstanten {protected final int MAX LENGTH = 42; // Maximale Laenge z.B. fuer ein Arraypublic final double PI = 3.14159265; // Die mathematische Konstante Piprotected final int MIN VALUE; // Die Variable muss im Konstruktor initialisiert werden

public Konstanten() {MIN VALUE = 4000;

}}


Namenskonventionen in JAVA:

Namenskonventionen:

① Groß- und Kleinschreibung wird unterschieden! (JAVA ist case sensitive)

② Namen von Klassen beginnen mit Großbuchstaben (Bsp. Hello, HelloWorld )

③ Namen von Konstanten bestehen ausschließlich aus Großbuchstaben,Unterstrichen, und Ziffern (Bsp. MAX SPEED )

④ Namen von Objekten , Methoden , und Attributen beginnen mit einemKleinbuchstaben (Bsp. myClass = new MyClass(), value, getValue()

⑤ Bei zusammengesetzten Wortern werden neue Worter mit einemGroßbuchstaben begonnen (Bsp. getContentsOfStream() )


Klassenattribute und -Methoden in JAVA

Klassenattribute:

Bisher haben wir nur Attribute betrachtet, die einer Instanz (Objekt) zugeordnetsind und folglich in jeder Instanz unterschiedliche Werte (Auspragungen) habenkonnen.

Fur Klassenattribute hingegen gilt:

• Sie sind Klassen und nicht Objekten zugeordnet!

• Ein Klassenattribut existiert genau einmal!

• Man braucht zur Verwendung kein Objekt erzeugen!

• Man spricht auch von statischen Attributen (dyn. Speicherzuordnung)

Klassenmethoden:

Analog konnen Klassenmethoden ohne ein Objekt verwendet werden. Siekonnen aber nur auf Klassenattribute zugreifen!



Objekt- vs. Klassenattribute/Methoden:

Objekt A:

Klasse GrafikElementAttribute:Gefüllt = ja

Attribute:Form: KreisFarbe: Rot

Objekt B:Attribute:Form: RechteckFarbe: Blau



Syntax:

Der Modifizierer static macht ein Klassenattribut oder eine Klassenmethodekenntlich. Er wird an andere Modifizierer angehangt.

Zur Initialisierung kann ein Anweisungsblock definiert werden:

<Klassen-Initialisierer> ::= static <Anweisungsblock>

Verwendung eines Klassenattributes:

<Klassenattribut-Zugriff> ::= <Klassen-Bezeichner>.<Attribut-Bezeichner>

Verwendung einer Klassenmethode:

<Klassenmethoden-Aufruf> ::= <Klassen-Bezeichner>.<Methoden-Bezeichner>(<Parameter>);



Beispiele fur Klassenattribute und -Methoden:

class StatischeElementeKlasse {// Klassen−Attribute:public static final double E = 2.71828182845904523536;protected static int maxIndex;

// Initialisierer fuer Klassen−Attribute:static {

maxIndex = 12;}

// Klassenmethoden:public static void setMaxIndex(int val) {

maxIndex = val;}

public static int getMaxIndex() {return maxIndex;

}}



Jetzt konnen wir die bisher benutzten mathematischen Funktionen definieren:

class Math {public static final double PI = 3.14159265358979323846;

public static double sqrt(double x) {// Hier folgt die Implementierung ...

}

public static double abs(double x) {// Hier folgt die Implementierung ...

}

public static double sin(double x) {// Hier folgt die Implementierung ...

}

public static double exp(double x) {// Hier folgt die Implementierung ...

}}



Klassen mit gemischten Attributen:

class Mix {protected int a;protected static int b;

Mix(int wert) {a = wert ; // Das Instanzattribut bekommt einen Wertb = 17; // Das Klassenattribut bekommt den Wert 17

}

public void print () {System.out.println(a + ” ” + b ); // Ausgabe von a und b

}

public void setB(int wert) {b = wert ; // Setzen der statischen Variable

}



Klassen mit gemischten Attributen (con’t):

class Statisch {

public static void main(String [] args) {Mix mix1, mix2;mix1 = new Mix(1); // 1. Objektmix2 = new Mix(2); // 2. Objektmix1.print (); mix2.print (); // Ausgabe der Werte

mix2.setB(42); // Das Klassenattribut wird auf 42 gesetzt

mix1.print (); mix2.print (); // Ausgabe der Werte}

}

➠ Seiteneffekte beachten!


Strings in JAVA

Zeichenketten:

Der Typ String ist in JAVA kein primitiver Datentyp, sondern eine Klasse!

➠ eine Variable vom Typ String ist eine Referenz

Eine (unvollstandige) Definition der Klasse String :

class String {// Konstruktorenpublic String () { /∗ Implementation ... ∗/ }public String(char value []) { /∗ Implementation ... ∗/ }// Methodenpublic int length () { /∗ Laenge des Strings ∗/ }public char charAt(int index) { /∗ Zeichen an einer Position ∗/ }public int indexOf(int ch) { /∗ Position eines Zeichens ∗/ }public String substring( int beginIndex) { /∗ Teilstring ab einer Position ∗/ }public String concat(String str ) { /∗ Konkatenation ∗/ }public int compareTo(String anotherString) { /∗ Vergleich mit einem anderen String ∗/ }public static String valueOf(double d); { /∗ Konvertierung von double nach String ∗/ }

}


Strings in JAVA

Programmbeispiel zu Strings:

// Eine Programm zur Ermittlung von Nummern zu Buchstabenclass Alphabet {

protected static final String alphabet = ”ABCDEFGHIJKLMNOPQRSTUVWXYZ”;

/// Ermittle die Nummer im Alphabet zu einem Buchstabenprotected static int nummerInAlphabet(char c) {

return alphabet.indexOf(c) + 1;}

public static void main(String [] args) {int i ;for ( i = 0; i < args.length ; i++) {

char c;c = args[ i ]. charAt(0);System.out.println( ”Zeichen ” + c + ” ist Nummer ”+

nummerInAlphabet(c));}

}}


Strings in JAVA

Konvertierung von und nach Strings:

• Konvertierung nach Strings:Methoden der Klasse String der Form: public static String valueOf(<Typ> d);

• Konvertierung von Strings:Methoden der Klassen Integer,Double, Boolean, Float, Long, Character, Short

class Double {// ...

public static Double valueOf(String s) { /∗ Creates a Double object ∗/ }public double doubleValue() { /∗ returns the double ∗/ }

}

class Integer {// ...

public static Integer valueOf(String s ) { /∗ Creates a Integer object ∗/ }public int intValue () { /∗ returns the int ∗/ }

}


Strings in JAVA

// Beispiel fuer das Konvertieren von String nach intclass Convert {

public static void main(String [] args) {int [] a;int summe, i;

a = new int [args.length ];for ( i = 0; i < args.length ; i++) {

/∗ Variante 1: ∗/Integer integer ;integer = Integer.valueOf(args[i ]);a[ i ] = integer . intValue ();/∗ Variante 2 ( Kombination in einer Anweisung): ∗/a[ i ] = Integer.valueOf(args[i ]). intValue ();

}

summe = 0;for ( i = 0; i < a.length ; i++) summe += a[i];System.out.println( ”Summe: ” + summe);

}}


Strukturierung von Klassen in JAVA

Strukturierungsm oglichkeiten von Klassen:

• Definition von Interfaces : Festlegung gemeinsamer Schnittstellen

• Erzeugung von Klassenhierarchien mit Hilfe von Vererbung

• Zusammenfassung von funktional ahnlichen Klassen zu Paketen ➠ Packages

Mit diesen “Features” lassen sich Bibliotheken fur die Programmierung erstellen

➠ API (Application Programming Interfaces)


Strukturierung von Klassen in JAVA

Interfaces

Interfaces ermoglichen die Vereinheitlichung von Klassen mit ahnlicherFunktionalitat ➠ Interfaces definieren gemeinsame Schnittstellen verschiedenerKlassen

Interface-Definitionen ahneln Klassendefinitionen mit folgenden Unterschieden:

• Es durfen keine Konstruktoren, statische Klasseninitialisierer, Instanzattributeoder Klassen-Methoden definiert werden

• Es durfen nur unveranderbare Klassenattribute (Konstanten) mit unmittelbarerInitialisierung deklariert werden

• Es durfen nur Methoden mit dem Modifizierer public deklariert werden, aberohne Anweisungsblock (Rumpf)!

Eine Klasse kann beliebig viele Interfaces implementieren - Schlusselwortimplements


Beispiel fur Interfaces in JAVA

interface SortingAlgorithm { // Schnittstelle fuer Sortieralgorithmenpublic void sort(Sortable [] a);

}

interface Sortable { // Schnittstelle fuer Klassen die sortiert werden koennenpublic double sortKey();

}

class SortableInteger implements Sortable { // Eine Klasse die einen Integerprotected int value; // beinhaltet nach dem sortiert werden kann

public double sortKey() { return (double )value; } // Der Sortierschluessel}

class QuickSort implements SortingAlgorithm { // Das Sortierverfahren QuickSortpublic void sort(Sortable [] a ) { /∗ Hier kommt die Implementierung ∗/ }

}

class MergeSort implements SortingAlgorithm {// Das Sortierverfahren MergeSortpublic void sort(Sortable [] a ) { /∗ Hier kommt die Implementierung ∗/ }

}


Vererbung in JAVA

Klassenhierarchien durch Vererbung:

Vererbung bedeutet in der Objektorientierung:

• Die Nachkommen einer Elternklasse erben alle Eigenschaften dieser Klasse,d.h. alle Attribute und Methoden

• Die Nachkommen konnen Attribute und Methoden hinzufugen

• Die Nachkommen konnen Methoden uberladen, d.h. die Implementierung vonMethoden andern

Bei der Klassendefinition gibt das Schlusselwort extends dieVererbungsbeziehung an:

class A extends B { ... }


Vererbung in JAVA

Basisklassen:

• Klassen, die am Anfang einer Vererbungshierarchie stehen, werdenBasisklassen genannt

• Ubergeordnete Klassen werden Superklassen genannt

• Von ubergeordneten Klassen abgeleitete Klassen werden Subklassen genannt

• Die implizite Basisklasse aller anderen Klassen ist die Klasse Object


Vererbung in JAVA

Abstrakte Basisklassen:

• Basisklassen konnen auch undefinierte Methoden haben (Methoden ohneImplementierung) ➠ abstrakte Methoden

• Um abstrakte Methoden zu kennzeichnen, wird der Modifizierer abstractverwendet

• Eine Klasse, die eine abstrakte Methode enthalt muss als abstract definiertwerden: abstract class MyClass { ... }

• Von einer abstrakten Klasse konnen keine Objekte erzeugt werden!


JAVA Beispiel Vererbung

// Die Basisklasse Grafikelementabstract class GrafikElement {

protected double [] x;

abstract public void draw(); // Unimplementiert!}

// Ein einfacher Punkt − ein Vektor gibt die Koordinaten anclass Punkt extends GrafikElement {

public Punkt(double [] x) { /∗ ... ∗/ }public void draw() { /∗ Zeichne Punkt ∗/ }

}

// Linie − zwei Vektoren noetigclass Linie extends Punkt {

protected double [] y;

public Linie(double [] x , double [] y ) { /∗ ... ∗/ }public void draw() { /∗ Zeichne Linie ∗/ }

}



// Rechteck − Urpsrungsvektor und Vektor fuer die Ausdehnunmg noetigclass Rechteck extends Linie {

public Rechteck(double [] x, double [] d ) { /∗ ... ∗/ }public void draw() { /∗ Zeichne Rechteck ∗/ }

}

// Ein Kreis − hat einen Mittelpunkt und einen Radiusclass Kreis extends Punkt {

protected double radius;

public Kreis(double [] x , double radius) { /∗ ... ∗/ }public void draw() { /∗ Zeichne Kreis ∗/ }

}



Graphische Darstellung einer Klassenhierarchie:

GrafikElement

Punkt

Linie

Rechteck

Kreis


Vererbung und Polymorphismus

Polymorphismus:

Transparente Verwendung von Objekten einer Klassenhierarchie:

• Eine in der Basisklasse definierte Methode kann uber eine Objekt-Referenz derBasisklasse aufgerufen werden

• Ist in einer abgeleiteten Klasse die Methode uberschrieben, wird die neueImplementierung ausgefuhrt

• Es konnen zur Implementierung noch nicht bekannte abgeleitete Klassennachtraglich hinzugefugt werden

✓ Anmerkung: Das selbe gilt fur Methoden, die in Interfaces definiert wurden



Beispiel fur Polymorphismus:

Alle Grafikelemente konnen auf die selbe Weise verwendet werden:

GrafikElement element;

Punkt punkt = new Punkt(...);Linie linie = new Linie (...);Rechteck rechteck = new Rechteck(...);Kreis kreis = new Kreis (...);

element = punkt;element.draw(); /// Zeichnet einen Punkt (Punkt.draw())

element = linie ;element.draw(); /// Zeichnet eine Linie ( Linie .draw())

element = rechteck;element.draw(); /// Zeichnet ein Rechteck (Rechteck.draw())

element = kreis;element.draw(); /// Zeichnet einen Kreis (Kreis.draw())



Datenstrukturen / Container:

Polymorphismus erlaubt die Speicherung von unterschiedlichen Objekten in einemArray (oder anderen Datenstrukturen)

➠ Array ist vom Typ der gemeinsamen Basisklasse (oder des Interfaces)

Sehr wichtiges Konzept in der Objektorientierung!

Unterschied Interfaces und Vererbung:

• Jede Klasse kann nur eine Klasse, von der sie erbt, besitzen (Superklasse)

• Jede Klasse kann zusatzlich beliebig viele Interfaces implementieren



Modifizierer und Vererbung:

Fur Methoden und Attribute gilt:

• public : von anderen Objekten aus verwendbar

• protected : nur innerhalb der Klasse und allen Subklassen verwendbar

• private : nur verwendbar innerhalb der Klasse

Die obigen Modifizierer konnen mit abstract bzw. final kombiniert werden:

• abstract : Methode wird in Unterklassen definiert

• final : Methode kann nicht mehr in Unterklassen uberschrieben werden,Attribut ist nicht veranderbar!



Methoden der Superklasse:

Aufruf mit Schlusselwort super !

public Circle2 extends Circle {

protected boolean visible;

public Circle2(){

super (); /// Ruft Konstruktor von Circle aufvisible = false ;

}

protected void draw(){

super .draw(); /// Ruft Circle .draw() aufvisible = true ;

}}



Vererbung und Objektorientierung:

Vererbung ist eine der wichtigsten Eigenschaften derObjektorientierten Programmierung:

✓ Erlaubt die Definition von Klassenhierarchien

✓ Fordert die Wiederverwendung von Code!

✓ Programming the difference!

✓ Erlaubt Entwicklung universal verwendbarer Datenstrukturen

✓ Laßt sich nicht ohne Weiteres in imperativen/prozeduralenSprachen nachbilden


Exceptions

Fehlerbehandlung in Java:

• Bei Auftreten eines Fehlers konnen Exceptions ”geworfen” werden: throw

• Eine Exception bewirkt den Abbruch des Programmes

• Exceptions konnen ”gefangen” werden: catch

• Das Fangen erlaubt die geordnete Weiterfuhrung des Programmes

• Bei einigen Exceptions ist zwingend erforderlich, dass sie gefangen werdenSyntax:<try-catch-Anweisung> ::= try <Anweisung>

catch (<Exception>) <Anweisung> |try <Anweisung>catch (<Exception>) <Anweisung>finally <Anweisung>

Anmerkung: Haufig wird ein Anweisungsblock nach try und catch verwendet!


Exceptions

Ablauf:

• Zuerst wird try-Anweisung ausgefuhrt

• Die Catch-Anweisung wird ausgefuhrt, wenn eine Exception mit angegebenemTyp geworfen wurde.

• Die Anweisung nach finally wird immer durchlaufen!

Beispiele fur Exceptions:

ArithmeticException , ArrayIndexOutOfBoundsException , NullPointerException

Beispiele fur Exceptions, die gefangen werden mussen:

FileNotFoundException , IOException


Exceptions

Beispiel zum Fangen einer Exception:

class ExceptionsExample {

public double divide(double x){

double y = 0.0;

try {y = 42.0 / x;} catch (ArithmeticException e) {

System.err.println ( ”Division by Zero!” );y = 0.0;} finally {

y += 60.0;}return y;}

}


Exceptions

Werfen einer Exception:

Syntax:

<throw-Anweisung> ::= throw <Ausdruck>

Das Ergebnis des Ausdruckes ein Objekt vom Typ Exception sein!

Die Throw-Anweisung muss von einem try-Block umschlossen sein oder dieMethode muss die Behandlung der Exception weiterleiten ➠ throws -Anweisung

Syntax der throws-Anweisung:

<Methoden-Def> ::= <Modifizierer> <Typ> <Bezeichner>(<ParameterDef>) throws<Ausdruck-1>, <Ausdruck-2>, ...

Es folgtein Beispiel.


Exceptions

Beispiel fur das Werfen von Exceptions:

class ThrowsExample {

public double calculate(double x) throws ArithmeticException, MyException{

if ( x > 10000.0) throw new MyException(”x > 10000.0 not allowed”);if ( x < 0.0) throw new ArithmeticException(”sqrt of number < 0”);else return Math.sqrt(x ) / ( x + 1.0);}

}

Im obigen Beispiel ist MyException eine eigene Subklasse von Exception

Wichtig: Aufruf der Methode calculate nur in einem try -Block!


JAVA Packages

Packages:

JAVA-Packages sind Klassensammlungen, die mit dem JDK ausgeliefert werdenund somit auf allen Plattformen verfugbar sind.

Die Wichtigsten sind:

java.lang: Fundamentale Klassen der Programmiersprache JAVA

Beispiele: String, Integer, Object, System, Math.

java.io: Klassen fur die Ein- und Ausgabe uber Datenstrome wie z.B. Dateien

java.net: Klassen zur Erstellung von Netzwerkapplikationen

java.util: Klassen zur Verwaltung von Objekten (Collections) und andere hilfreicheDatenstrukturen

java.awt: Klassen zur Programmierung von graphischen Benutzungsschnittstellen(GUI)

javax.swing: Weitere Klassen zur GUI-Programmierung


JAVA Packages

Verwendung von Packages:

Die Klassen einer Package konnen importiert werden, d.h. sie gelten dann alsdefiniert und konnen somit in eigenen Klassen verwendet werden.

Importanweisungen stehen am Anfang des JAVA-Quelltextes und haben folgendeForm:

import java.lang.*;

import java.io.*;

import java.util.Random;

Eine eigene package wird definiert, wenn als erste Anweisung im JAVA-Quelltextdie package Anweisung steht. Alle Klassen im Quelltext sind dann derangegebenen package zugeordnet.

Syntax: package MeinePackage;


JAVA im Schnelldurchlauf

JAVA -Programme :

✓ Ein JAVA-Programm ist eine Folge von Anweisungen

✓ Ein JAVA-Programm besteht aus einer oder mehreren Klassendefinitionen

➠ Eine Klassendefinition ist ebenfalls eine Anweisung!

✓ Die Klassenmethode main der Klasse, die bei Aufruf des JAVA-Laufzeitsystems(java) angegeben wird, wird zum Programmstart ausgefuhrt

✓ Die Klassenmethode main hat folgende Form:

public static void main(String [] args) {/∗ Folge von Anweisungen, die zu Programmstart ausgefuehrt werden ∗/

}



Anweisungen in J AVA :

✓ Klassendefinitionen

✓ Variablendeklarationen von primitiven Datentypen und Referenzdeklarationenvon komplexen Datentypen

✓ Zuweisungen: Zuweisungen von Werten an Variablen, Bindung von Referenzenan Objekte und Arrays

✓ Bedingte Anweisungen (if und switch )

✓ Schleifen (while und for )

✓ Methodenaufrufe: Ausfuhrung der Anweisungen im Rumpf derMethodendefinition (Anweisungsblock)

Anweisungen konnen zu Anweisungsblocken zusammengefaßt werden!



Ausdrucke in J AVA :

✓ Konstanten sowie Variableninhalte von primitiven Datentypen

✓ Operatoren ermoglichen die Verknupfung eines oder zweier Ausdrucke zueinem neuen Ausdruck

✗ Unare Operatoren: -, !, . . .✗ Binare Operatoren: +, -, *, /, >, <, ==, && , ||, . . .

➠ Uber Operatoren konnen Teilausdrucke zu komplexen Ausdruckenzusammengesetzt werden

✓ Methodenaufrufe konnen in Ausdrucken verwendet werden sofern sie einenRuckgabewert besitzen



JAVA -Datentypen :

✓ Datentypen sind in JAVA entweder primitive Datentypen oder komplexe bzw.zusammengesetzte Datentypen

✓ Primitive Datentypen sind:

✗ boolean (Bool’scher Datentyp),✗ char (Datentyp fur UNICODE-Zeichen),✗ byte , short , int , long (Ganzzahlige, numerische Datentypen),✗ float , double (Numerische Datentypen mit Fließkommadarstellung)

✓ Komplexe Datentypen sind Arrays (Felder von Variablen eines Datentyps) odervordefinierte sowie selbstdefinierte Klassen



Klassen in J AVA :

✓ Klassendefinitionen beinhalten:

✗ Attribute: Variablen und Referenzen✗ Konstruktoren: Spezielle Methoden, die bei Instanziierung eines Objektes

aufgerufen werden✗ Methoden: Funktionen bzw. Prozeduren

✓ Modifizierer bestimmen den Zugriff auf Attribute und Methoden:

publicprotectedprivate

— abstractfinal

— static



Klassen in J AVA (con’t):

✓ Klassenelemente konnen Instanzbezogen oder klassenbezogen sein

➠ Instanzattribute: Fur jedes Objekt individuell (eigene Auspragung)➠ Klassenattribute: Existieren nur einmal - unabhangig von der Anzahl

instanziierter Objekte➠ Klassenmethoden konnen nur auf Klassenattribute zugreifen➠ Klassenelemente konnen ohne Instanziierung verwendet werden!



Objekte in J AVA :

✓ Klassen entstehen wahrend der Programmenwicklung – Objekte hingegen zurLaufzeit!

✓ In Objekten erhalten alle Attribute konkrete Auspragungen (Werte)

✓ Objekte mussen explizit erzeugt (instanziiert) werden

✓ In JAVA werden Objekte uber Referenzen verwendet

✓ Referenzen sind Verweise auf Objekte

➠ Gleiche Referenzen zeigen auf das selbe Objekt➠ Verschiedene Referenzen konnen auf gleiche Objekte zeigen➠ Die Zuweisung von Referenzen bewirkt kein Kopieren von Objekten!

✓ Objekte sind gleich, wenn sie von der selben Klasse sind und alle Attributegleiche Werte haben



Arrays in J AVA :

✓ Der Zugriff auf Arrays erfolgt ebenfalls uber Referenzen

✓ Es ergeben sich daher die gleichen Eigenschaften wie bei Objekten

✓ Somit mussen Seiteneffekte bei der Ubergabe an Methoden beachtet werden

✓ Weiterhin konnen Seiteneffekte bei der Verwaltung mehrerer Referenzen aufdas selbe Array (Objekt) auftreten

✓ Zwei Arrays sind gleich, wenn an allen Indizes gleiche Werte abgelegt sind



Vererbung:

✓ Wichtiges Merkmal der objektorientierten Programmierung!

✓ Erlaubt Erweiterung oder Veranderung bestehender Klassen

✓ Klassenhierarchien fassen Klassen mit ahnlichen Eigenschaften bzw. ahnlicherFunktionalitat zusammen

✓ Datenstrukturen bzw. Container fur Objekte lassen sich leicht realisieren

✓ Interfaces erlauben die Definition von einheitlichen Schnittstellen uberKlassenhierarchiegrenzen hinweg



Weitere wichtige Eigenschaften von J AVA :

✓ Implizite Typwandlung:

✗ In Ausdrucken mit binaren Operatoren und Operanden mit unterschiedlichenTypen wird in den Typ mit hoherer Wertigkeit gewandelt (z.B. float ➠ double )

✗ Bei der Zuweisung kann implizit in einen Typ mit hoherer Wertigkeitkonvertiert werden

✓ Gultigkeitsbereiche:

✗ Lokale Variablen oder Referenzen (In Anweisungsblocken/Methodenrumpfenoder Parameterdefinitionslisten deklarierte Variablen) konnen Attribute vonKlassen uberdecken

✗ Die Gultigkeit von lokalen Variablen ist auf ihren Deklarationsbereich(Anweisungsblock oder Methodenrumpf) beschrankt



Ausnahmebehandlung :

✓ Exceptions erlauben die Behandlung von Fehlern im Programm

✓ Bei Auftreten einer Exception wird das Programm an der entsprechenden Stelleunterbrochen

✓ Durch das Fangen von Exceptions kann auf Fehler geeignet reagiert werden

✓ Eigene Exceptions konnen definiert werden


Einfuhrung¨ in JAVA - ra.cs.uni- · PDF fileInhalte der Vorlesung Einleitung 1...

Documents

Transcript of Einfuhrung¨ in JAVA - ra.cs.uni- · PDF fileInhalte der Vorlesung Einleitung 1...