Kurzeinführung in Java - ias.uni-stuttgart.de

Universität Stuttgart
Institut für Automatisierungs- und Softwaretechnik
Prof. Dr.-Ing. Dr. h. c. P. Göhner
Java-Intensivkurs am IAS
Kurzeinführung
Inhaltsverzeichnis
WAS IST JAVA? ........................................................................................................................................................ 2
JAVA UND OBJEKTORIENTIERUNG.................................................................................................................. 4
BLICK IN DIE ZUKUNFT ... .................................................................................................................................... 5
DIE PROGRAMMIERSPRACHE JAVA ................................................................................................................ 6
Werkzeuge des JDK .............................................................................................................................................. 6
Unterschiede zu C und C++ ................................................................................................................................ 7
JAVA – KURZREFERENZ ....................................................................................................................................... 9
Schlüsselwörter .................................................................................................................................................... 9
Kommentare ......................................................................................................................................................... 9
Konstanten............................................................................................................................................................ 9
Einfache Datentypen ............................................................................................................................................ 9
Escape-Sequenzen in Zeichenketten ................................................................................................................... 10
Klassen ............................................................................................................................................................... 10
Methoden ............................................................................................................................................................ 10
Objekt ................................................................................................................................................................. 11
Modifier .............................................................................................................................................................. 11
Arrays ................................................................................................................................................................. 12
if Statement ......................................................................................................................................................... 13
while Statement .................................................................................................................................................. 13
do while Statement ............................................................................................................................................. 14
for Statement ...................................................................................................................................................... 14
switch Statement ................................................................................................................................................. 14
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 2/15
Was ist Java?
Sun: " Java is a simple, object-oriented, distributed, interpreted, robust, secure, architectural neutral,
portable, high-performance, multithreaded, and dynamic language."
Java ist eine Allzweckprogrammiersprache.
1990 entwickelte James Gosling bei Sun, einem bekannten Hersteller von UNIX-Workstations, eine
Programmiersprache namens Oak für sein Projekt „Imagination“, einen SGML-Editor. Sie stellte im
Wesentlichen eine Abwandlung von C++ und Objective C dar, in die alle Ideen eingeflossen waren, die
frustrierte Entwickler in jahrelanger Erfahrung gesammelt hatten.
Im April 1991 gründete Sun die Tochterfirma First Person Inc., die versuchen sollte, Oak als interne
Programmiersprache für Heimelektronik vom Videorecorder bis zum Toaster, zu vermarkten. 1993 suchte
Time Warner nach Ideen für die Settop-Boxen für das interaktive Fernsehen. Im Hinblick auf diese
Anwendungen musste die Programmiersprache gewisse Anforderungen erfüllen. Sie musste in Echtzeit
laufen, sicher und zuverlässig sein sowie sehr kompakt. Aus dieser Zeit stammt auch noch das
Maskottchen Duke.
Leider hatte das Projekt nicht den rechten Erfolg und die Firma wurde aufgelöst. Zu dieser Zeit begann
jedoch gerade das WWW seinen Siegeszug und Patrick Naughton programmierte an einem Wochenende
einen HTML-Browser, der Oak-Applets starten konnte. Daraus entstand der heutige HotJava-Browser
und das neue Zielgebiet der Programmiersprache wurde das Internet.
Auch Internet-Programme müssen kompakt sein.
Vor allem die Gegenspieler von Microsoft gebrauchen im Zusammenhang mit Windows gern den Begriff
Fatware, denn in viele Programme werden doppelt und dreifach Standardbibliotheken eingebunden, die
die Programme aufblähen. In Java gibt es ein Standard-API, dessen Klassen auf dem lokalen Rechner
liegen, ein kleines Java-Applet kann so auch mit wenigen hundert Bytes auskommen, wogegen z.B. ein
leeres Delphi- oder C++-Programm kaum unter 100k groß ist.
Außerdem braucht man einen sicheren Schutz gegen Viren oder das Ausspionieren des Rechners.
Java-Programme werden vor der Ausführung überprüft, dadurch können z.B. keine Informationen an
fremde Rechner geschickt werden und der Rechner kann durch fehlerhafte Programme nicht abstürzen.
Fehleranfällige und überflüssige Elemente wie Pointer, Operatorüberladung, Speicherfreigabe oder die
Benutzung beliebiger Zahlen als Booleantypen wurden eliminiert, was zu einheitlicheren Programmen
und leichterer Pflege führt.
Der Name Java entstand in einer Brainstorming-Session bei Sun.
Er geht auf das Slangwort für Kaffee in den USA zurück, welches Hauptexportgut der Insel Java ist. Es
ist ein Anspielung auf das heiße und aromatische Getränk, welches Programmierer gern und viel trinken.
Sun: "Write once, run anywhere, on anything, safely."
Java ist portabel.
Ein kompiliertes Java-Programm besteht aus dem so genannten Bytecode mit den Befehlen eines
virtuellen Prozessors. Bytecode und Klassenformat sind vollkommen hardware-unabhängig. Die JavaPlattform wurde schon von vielen Herstellern in ihre Betriebssysteme integriert. Zu nennen sind hier u.a.
Linux, Windows (ab Win95 OSR2), OS/2 4.0 und natürlich Sun Solaris.
Was brauche ich zur Java-Programmierung?
Die folgenden Erklärungen gehen davon aus, dass sie das kostenlose JDK von JavaSoft
[http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html#javasejdk] benutzen.
Offizielle Distributionen gibt es für WinXP,Vista,7,8, Solaris, MacOS und Linux. Das Entwicklerkit
enthält den Compiler, das API (Application Programming Interface), einen Appletviewer, Debugger und
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 3/15
andere Werkzeuge. Zu allen Programmen und Klassen ist der Sourcecode enthalten. Die aktuelle Version
des Entwicklerkits ist 7.9. Auch die im HTML-Format vorliegende Dokumentation wird unbedingt
benötigt [http://docs.oracle.com/javase/7/docs/api/].
Wer vorher mit Turbo Pascal o.ä. gearbeitet hat, wird eine integrierte Entwicklungsumgebung mehr
vermissen, als jemand der es gewöhnt ist, unter UNIX zu programmieren. Das JDK enthält den
Kommandozeilencompiler javac, der mit bestimmten Parametern, z.B. der Quelldatei aufgerufen werden
muss und eine .class-Datei erzeugt, bzw. eine Vielzahl von Fehlermeldungen erzeugt.
Die Quelldatei wird mit einem normalen Texteditor erzeugt. Es empfiehlt sich natürlich ein Editor, der
Autoindent (automatisches Einrücken) beherrscht, wie z.B. der von Turbo Pascal und auch Syntax
Highlighting (Schlüsselwörter sowie Kommentare und Zeichenketten werden farbig hervorgehoben) ist
ganz nützlich. Es gibt natürlich gerade für Windows auch eine Menge integrierter Umgebungen, die einen
guten Editor besitzen und den Compiler automatisch aufrufen können. Zu nennen sind hier u.a.
Eclipse [http://www.eclipse.org] und NetBeans [http://netbeans.org/], die beide als OpenSource im
Internet zu haben sind.
Auch kommerzielle Programme werden angeboten, wie z.B. Forte for Java von Sun, Borland’s JBuilder,
Symantec Café und viele andere, diese wurden aber weitgehend von den beiden oben genanngen
OpenSource Umgebungen verdrängt. Für den Anfang reichen aber ein guter Editor und das JDK
vollkommen.
Wenn Ihre Entwicklungsumgebung dies nicht per Mausklick für Sie tut, starten Sie das übersetzte
Programm durch Eingabe von „java name“. Applets werden in eine HTML-Seite eingebettet und müssen
mit einem Java-kompatiblen Browser betrachtet werden.
Der Syntax für das Einbetten von Java-Applets ist folgender:
<APPLET
CODEBASE = codebaseURL
ARCHIVE = archiveList
CODE = appletFile ...or...
ALT = alternateText
// Pfad für Klassendateien
// jar-Archive, die Daten
// und Klassen enthalten
OBJECT = serializedApplet
// wenn Java abgeschaltet ist
NAME = appletInstanceName
WIDTH = pixels HEIGHT = pixels
ALIGN = alignment
VSPACE = pixels HSPACE = pixels
// Fenstergröße
// Ausrichtung
// Abstand
>
<PARAM NAME = appletAttribute1 VALUE = value>
// zu übergebende
// Parameter
<PARAM NAME = appletAttribute2 VALUE = value>
. . .
alternateHTML
// wenn Browser kein Java
// versteht
</APPLET>
Programmcode muss leicht lesbar und verständlich sein.
Der Compiler sucht beim Übersetzen nach Tokens, dazwischen liegende Zeichen (Leerzeichen,
Zeilenumbrüche, ...) und Kommentare werden ignoriert. Nutzen Sie dies, um ihren Quellcode
übersichtlich zu gestalten. Rücken Sie dazu Blöcke ein, d.h. z.B. nach einer öffnenden Klammer rücken
Sie die folgenden Zeilen mit zwei Leerzeichen oder TAB ein, bis wieder eine schließende Klammer folgt.
Dies erhöht die Leserlichkeit drastisch. Weiterhin ist es üblich, Schleifenvariablen i,j,k,... bzw. counter
oder Ähnliches zu nennen.
Im Gegensatz zu PASCAL ist Java case-sensitiv, d.h. der Compiler unterscheidet Groß- und
Kleinschreibung. Vergeben Sie Namen nicht nach Rechtschreibregeln, sondern nach der optimalen
Übersicht. Es empfiehlt sich, bei aus mehreren Wörtern zusammengesetzten Namen, den ersten klein und
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 4/15
die folgenden groß zu schreiben, z.B. printScreen(); oder Ähnliches. Per Konvention beginnen
Variablennamen mit einem kleinen und Klassennamen mit einem großen Buchstaben. Beachten Sie
jedoch, dass Sie eine einmal gewählte Schreibweise im ganzen Programm beibehalten müssen. Eine
häufige Fehlerquelle ist auch das Benennen von Variablen mit reservierten Worten.
Java und Objektorientierung
Programmsprachen kann man zum Beispiel nach ihrer Entfernung von der Maschine einteilen.
Der schnellste und kompakteste Code ist zweifelsfrei durch Assemblerprogrammierung zu erreichen. Die
Maschine wird direkt programmiert, einzige Erleichterungen bieten Sprungziele, Makros und
Trivialnamen für Befehle.
Später entwickelten sich Interpretersprachen wie z.B. BASIC, die sehr weit von der Maschine entfernt
waren. Im Gegensatz zur Maschinensprache sind die Befehle hier sehr komplex, z.B. wird das
„Bildschirm löschen“-Kommando (Cls) intern in viele kleine Einzelaktionen zerlegt. Der Quelltext wird
hier zur Laufzeit Befehl für Befehl übersetzt und ausgeführt. Das führt oft zu inakzeptablen Laufzeiten.
Compiler setzen hier an. Der Quelltext wird schon vor der Laufzeit übersetzt und als
Maschinenprogramm gespeichert. Der Anwender hat mit dem Quelltext nichts zu tun und startet die
Binärdatei. Das ist das heute übliche Prinzip z.B. unter DOS oder Windows. Die übersetzten Programme
sind natürlich längst nicht so optimiert wie „handprogrammierte“ Maschinenprogramme, aber durch die
Komplexität moderner Prozessoren wie z.B. des Pentiums kann nur noch ein Compiler wissen, welcher
Code wegen Branch prediction, Register renaming, Cache-Größe und ähnlichem am schnellsten sein
wird. Außerdem, wer will schon in einem 60.000 Zeilen-Assemblercode einen Fehler suchen?
Objektorientierte Sprachen wie Java haben neue Konzepte zu bieten.
Das Ziel ist in erster Linie leicht zu wartender und pflegender Code. Dazu bedient man sich der Art wie
auch Menschen die Dinge um sich herum wahrnehmen. Ein elementarer Begriff ist der der Klasse.
Klassen enthalten wieder verwendbaren Code zur Erstellung von Objekten. Sie können entweder
instantiiert, um individuelle Objekte zu erzeugen oder in Subklassen erweitert werden. Dem
menschlichen Verständnis ähnlich ist nun z.B., dass man Objekten auf Grund der Superklassen
(übergeordnete Klassen) von denen sie abstammen, Eigenschaften zuordnen kann. Da z.B. ein VW Polo
ein VW ist (von der Superklasse VW abstammt), der wiederum ein Auto ist (von der Superklasse Auto
abstammt), kann man sagen, dass ein Polo vier Räder hat, da er diese Eigenschaft von der Superklasse
Auto erbt. Ein Polo kann wiederum auch aus verschiedenen Objekten zusammengesetzt sein (composite
object), z.B. aus vier Rädern (Subsysteme).
Ein Beispiel für eine Subklasse ist z.B., dass man schon eine fertige Klasse besitzt, die ein Rechteck
behandelt, es z.B. zeichnet, seinen Flächeninhalt berechnet, usw. Will man nun auch farbige Rechtecke
zeichnen, kann man eine Subklasse von Rechteck anlegen, in der man die Methoden überschreibt, die
anders sind. Alle anderen werden geerbt. Ein Beispiel wäre z.B., die Zeichenmethode des farbigen
Rechtecks so zu implementieren, dass man die Systemfarbe ändert, dann die fertige Zeichenmethode von
Rechteck aufruft und die Systemfarbe danach wieder zurücksetzt.
Die objektorientierte Programmierung beruht auf einer Hierarchie, in der Klassen nach unten hin immer
spezieller und nach oben immer abstrakter werden. Ein Objekt ist ein abstrakter Datentyp mit seinen
Methoden. Auf private Daten, Instanzvariablen (private Variablen) und private Methoden kann nicht
direkt, sondern nur über öffentlichen Methoden zugegriffen werden.
Dieses Prinzip nennt man Kapselung.
Stellen Sie sich eine Liste vor, die verschiedene Daten enthält. Sie verwalten z.B. Kundendaten.
Angenommen die Anzahl der Aufträge pro Kunde ist anfangs auf einen 8bit-Datentyp beschränkt und Sie
ändern diesen später in einen 16bit-Datentyp, so müssen Sie alle Funktionen, die auf die Liste zugreifen,
umschreiben. Haben Sie nun viele Programme, die dies tun, so können leicht Fehler entstehen.
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 5/15
In der objektorientierten Programmierung werden die Daten lokal zusammen mit dem Methoden in einer
Klasse zusammengefasst, die auf sie zugreifen. Um beispielsweise ein Listenelement zu entfernen,
würden Sie dem Objekt Liste den Auftrag delete(item) geben. Wie dies jedoch intern realisiert ist, ist für
das Hauptprogramm nicht ersichtlich. Ein einzelnes Element erhält man z.B. über den Aufruf der
Methode „objectAtIndex(index)“ der Klasse Liste. Direkt auf die Liste zuzugreifen, ist nicht möglich.
You must image a system as a collection of classes and methods that knows how to perform tasks.
Man kann Methoden in unterschiedlichen Klassen gleiche Namen geben.
So kann man komplizierte Methodennamen vermeiden. Dies entspricht auch der menschlichen
Wahrnehmung und wird Polymorphie genannt. Wenn man z.B. an einem Radio oder an einer Lampe den
Einschalter drückt, können intern ganz unterschiedliche Prozesse ausgelöst werden, dem Benutzer ist dies
aber egal, er will nur, dass das Gerät eingeschaltet wird. Was er damit auslöst, ist nur im Zusammenhang
mit dem jeweiligen Objekt eindeutig.
class Bildschirm {
Methode clear { Code für Bildschirm löschen; }
Methode write { Code zum auf den Bildschirm schreiben; }
}
Hauptprogramm {
ein Bildschirm-Objekt namens screen anlegen
dem screen sagen, er soll seine clear-Methode aufrufen
dem screen sagen, er soll seine write-Methode aufrufen (evtl. mit Parameter)
...
}
Blick in die Zukunft ...
Java schafft neue Vertriebsmöglichkeiten.
Die vier klassischen Begriffe was das Copyright betrifft, sind bislang Public domain (alle Rechte
aufgegeben), Freeware (kostenlose Weitergabe erlaubt), Shareware (kostenlose Testversion, bei
intensiver Nutzung muss Vollversion erworben werden) und Vollversion (entgeltlich erworben,
Weitergabe verboten). In Zukunft könnte es mit Java auch Software zum Mieten geben, bei der man für
jede Nutzung bezahlen muss.
Unix- und Internetfans wird der fehlende Sourcecode bei vielen Applets nicht gefallen, da dies mit einer
Philosophie kollidiert.
Eines von Suns Mottos ist „Think authors not publishers“.
Man eliminiert den Mittelsmann zwischen Autor und Kunde. Oft fehlen Firmen Geld und Beziehungen,
Software weltweit bewerben und verkaufen zu können. Bisher! Im Internet kann sich jede Firma
präsentieren, Produkte und Service anbieten, ohne Mittelsmann. So werden auch viele zeitraubende
Vorgänge überflüssig und man kann Software direkt günstiger anbieten. Dies ist die Chance für den
besten Autor, zu gewinnen.
Java läuft überall.
Microsofts Philosophie war immer, dass die Anwendung auf ein Betriebssystem aufsetzt, das wiederum
auf eine bestimmte Hardware aufsetzt. In Zukunft könnten die Nutzer in die Situation kommen, wo es
genügend Software in Java gibt und man die Hardware wählt, die diese Programme am schnellsten
ausführt.
Sun: „The network is the computer“
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 6/15
Zuguterletzt ist es auch für den Programmierer eine Erleichterung, plattformunabhängig entwickeln zu
können.
Vorbei die Zeit in der man für ein paar unterstützte Plattformen in mühsamer Arbeit ein abstraktes
Klassenmodell bauen musste, für jede Plattform eigene Grafik-, Sound- und andere Routinen. Selbst mit
dem so portablen C++ kann das echt in Arbeit ausarten.
Die Programmiersprache Java
Werkzeuge des JDK
Sie erhalten immer eine Hilfe zu den Programmen, wenn Sie sie ohne Parameter aufrufen. Des Weiteren
befindet sich eine genaue Beschreibung aller Optionen und Programmfunktionen in der HTML-OnlineDokumentation. Die folgenden Informationen stellen nur eine kleine Übersicht dar.
Ein Programm mit der Endung „_g“ ist immer die ohne Optimierung compilierte und so besser debugbare
Version.
Allgemeines:
javac- der Java-Compiler übersetzt die Java-Quelltexte in den Bytecode
Beispiel: javac -classpath src;src\old -d classes -O -deprecation test.java
kompiliert die Quelldatei test.java in src oder src\old, gibt Fehlermeldungen zu veralteten Aufrufen aus,
führt eine Optimierung durch und speichert die Klassendatei im Pfad classes.
java - der Java-Interpreter führt Programme im Bytecode aus.
Beispiel: java -cs ls cpp
führt das Programm „ls.class“ mit dem Parameter „cpp“ aus und übergibt an den java-Interpreter die
Option -cs.
javadoc - Generiert aus im Quellcode enthaltenen DocComments eine API-Dokumentation
Beispiel: javadoc -version -author -noindex -notree test.java
erzeugt eine Dokumentation zur Klasse test, @version- und @author-Tags werden hierbei berücksichtigt
und index.html und tree.html nicht erzeugt.
Neben normalem Text können DocComments auch besondere Tags enthalten.
@see Klasse#Methode
Hyperlink
@param Name Text
beschreibt Parameter einer Methode
@return Text
beschreibt Rückgabewert einer Methode
@exception Klasse Text
beschreibt Ausnahmebehandlung einer Methode
@author Text
Autor der Klasse
@deprecated
Klasse oder Methode als veraltet deklarieren
@version Text
Version bzw. Datum der Klasse
appletviewer - einfacher Applet-Anzeiger für Leute ohne Webbrowser
Beispiel: appletviewer test.html
lädt die HTML-Datei test.html und führt das darin mittels <APPLET>-Tag eingebettete Applet aus.
jdb - mit dem Java-Debugger „entwurmt“ man Programme
javah - Headerfile- und C-Stub-File-Generator für das Einbinden von C-Code
javap - der Java-Profiler disassembliert Klassendateien und zeigt den Bytecode an
RMI (Remote Method Invocation) Tools
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 7/15
rmic - generiert Stub- und Skelettklassen für Javaobjekte, die verteilte Programmierung benutzen
rmiregistry - wird für verteilte Programmierung benutzt
serialver - liefert die Seriennummer einer Klasse
Internationalization Tools
native2ascii - konvertiert Text ins Unicode-Format
JAR (Java Archiver) Tool
jar - Packer, der es erlaubt, mehrere Klassen und Ressourcen in einer Datei zu speichern
Digital Signing Tool
javakey - erzeugt digitale Unterschriften für Archive und verwaltet Schlüssel
Unterschiede zu C und C++
Im Unterschied zu C unterstützt die Sprache JAVA nicht alle Standard-C-Operatoren.
Es gleichen sich jedoch die Vorrangs- und Assoziativitätsregeln. Java unterstützt jedoch beispielsweise
nicht den Operator sizeof. Da es auch keine Pointer gibt (statt dessen Referenzen), existieren auch der
Adress- und Pointeroperator nicht.
Neu ist beispielsweise, der „+“-Operator zum Verketten von Strings. Der instanceof-Operator liefert true
oder false je nachdem, ob ein Object eine Instanz einer angegebenen Klasse ist oder nicht.
Zum normalen >> (shift right) Operator kommt der >>>-Operator, der eine Zahl grundsätzlich als nicht
vorzeichenbehaftet behandelt.
Werden & und | (bitweises AND und OR) auf boolean-Typen angewandt, wirken Sie automatisch wie
logisches AND und OR, mit dem Unterschied, dass bei && und || der auf der rechten Seite stehende
Operand nicht mehr ausgeführt wird, sobald das Ergebnis der Auswertung des linken Operanden schon
feststeht. Boolean ist ein eigenständiger Typ, daher kann nicht jeder Typ als boolean-Typ verwendet
werden, sondern andere Typen müssen mittels Vergleichsoperationen umgewandelt werden.
In Java werden Zugriffe auf Felder über deren Grenzen hinaus nicht wie in C zugelassen, sondern
erzeugen Ausnahmen. Typen sind in Java streng definiert, im Gegensatz zu C, wo man nie weiß, ob
beispielsweise char auf dem aktuellen Compiler signed oder unsigned ist. Der Ausweg war oft, eigene
Typen zu definieren und dann immer den eigenen Typ, z.B. byte als unsigned char zu benutzen, was für
Außenstehende zu schwer lesbaren Programmen führte.
Java-Code ist generell sehr gut lesbar, denn durch klar definierte Typen (ein großes Manko von C++),
Unterbindung von Operator-Überladung, Pointerarithmetik und anderes (z.B. kann es nicht mehr
passieren, dass man bei if(a==0) ein Gleichheitszeichen vergisst), ist alles eindeutig interpretierbar.
Einige Eigenschaften von C++ wurden bei Java weggelassen.
Operator-Overloading (+,-, ...)
typedef Statements (eigene Typen, in Java statt dessen Objekte)
Strukturen, Unions und Funktionen (keine globalen Funktionen)
Präprozessor (z.B. #define,#ifdef ...)
goto (dafür benannte Schleifenendziele, u.ä.)
Zeiger (dafür Referenzen)
Mehrfachvererbung (Ausnahme: Interfaces)
Präprozessor (eigene Typen nur als Objekte, import statt #include)
Java bietet auch viel Neues.
Thread-Modell (unabhängige Tasks innerhalb eines Programmes)
Automatische Speicherverwaltung (kein explizites Freigeben mehr)
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 8/15
dynamisches Laden und Binden (late binding)
Sicherheitsmodell (Überprüfung vor Ausführung)
portabel ohne Neucompilierung (Bytecode)
UniCode-Zeichenketten sowie echte Strings und Felder
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 9/15
Java – Kurzreferenz
Schlüsselwörter
Java kennt folgende reservierte Wörter, von denen noch nicht alle unterstützt werden:
abstract
boolean
break
byte
byvalue
case
cast
catch
char
class
const
continue
default
do
double
else
extends
false
final
finally
float
for
future
generic
goto
if
implements
import
inner
instanceof
int
interface
long
native
new
null
operator
outer
package
private
protected
public
rest
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
var
void
volatile
while
Nicht unterstützt: byvalue, cast, const, future, generic, goto, inner,
operator, outer, rest, var
Kommentare
Java kennt drei Arten von Kommentaren
1. Die C Kommentarzeichen /* welche bis zum nächsten */ gelten.
Bsp: /* das ist ein C Kommentar */
2. Die C++ Kommentarzeichen // welcher am Ende der Zeile endet.
Bsp: // das ist ein C++ Kommentar, der am Ende der Zeile endet
3. Die Kommentarzeichen /** welche bis zum nächsten */ gelten. Das Utility javadoc kann aus diesen
Kommentaren Online-Hilfen im HTML Format generieren.
Konstanten
Konstanten werden die Schlüsselwörter static final vorgestellt. Bsp: die Zahl
ist wie folgt deklariert: public static final double PI=3.14159;
in der Klasse Math
Einfache Datentypen
Typ
boolean
char
byte
short
int
long
float
IAS, 2012
enthält
true oder
false
Unicode
Zeichen
signed integer
signed integer
signed integer
signed integer
IEEE 754
floating point
Default
false
Grösse
1 Bit
Min Wert
false
Max Wert
true
\u0000
16 Bits
\u0000
\uFFFF
0
0
0
0
0.0
8 Bits
16 Bits
32 Bits
64 Bits
32 Bits
-128
-32768
-2147483648
-9223372036854775808
1.40239846E-45
127
32767
2147483647
9223372036854775807
3.40282347E+38
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
double
Seite 10/15
IEEE 754
0.0
floating point
64 Bit
4.94065645841246544E-324
1.79769313486231570E+308
Beachten Sie, dass Strings keine char-Felder, sondern vollwertige Objekte sind (siehe java.lang.String
und java.lang.StringBuffer). Spezielle oder nationale Codes können auch mit der Escape-Sequenz
„\uxxxx“ im UniCode-Format eingebunden werden, wobei „xxxx“ für eine 16bit-Hexadezimalzahl steht.
Escape-Sequenzen in Zeichenketten
Darstellung
\n
\r
\b
\t
\f
\’
\“
\\
\uXXXX
Bedeutung
new line
cariage return
backspace
tabulator
form feed
Hochkomma
Anführungszeichen
backslash
Unicode-Zeichen
Klassen
Die Klassendefinition sieht wie folgt aus:
class NameDerKlasse {
...
}
Beispiel:
class Figure {...}
Wird eine neue Subklasse programmiert, dann muss nach dem Namen das Schlüsselwort extends gefolgt
vom Namen der Superklasse folgen:
class NameDerSubklasse extends NamerDerSuperklasse {...}
Beispiel:
class Circle extends Figure {...}
Implementiert eine Klasse ein Interface, dann folgt nach dem Namen der Klasse das Schlüsselwort
implements gefolgt vom Namen des Interfaces:
class NameDerKlasse implements NameDesInterfaces {...}
Beispiel:
class Computer implements Observer {...}
Methoden
Beispiel:
double doSomething(int n, double x) {...}
Eine Methode besteht aus einem Rückgabewert (double), einem Methodennamen (doSomething), einer
Parameterliste (int n, double x) und einem Methodenkörper ({...}), der die eigentliche Funktionalität
enthält. Optional können weitere Modifier angegeben werden.
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 11/15
Klassenmethoden wird das Schlüsselwort static vorangestellt:
Beispiel:
Exponenzialfunktion in der Klasse Math:
public static double exp(double x) {...}
Methoden, denen das Schlüsselwort void vorangestellt wird geben nichts zurück.
Objekt
Objekte werden mit new erzeugt.
Beispiel:
Figure fig;
fig = new Figure();
Erzeugt ein neues Figure-Objekt.
Modifier
Modifier beschreiben spezielle Eigenschaften von Klassen, Variablen, Methoden...
Die meisten von Ihnen existieren aus Sicherheitsgründen, aber viele haben auch einen starken Einfluss
auf Codegröße und Performance. Standardmäßig ist eine Variable im aktuellen Package zugänglich.
synchronized
Methoden, die Engpassstellen darstellen werden bei mehreren Threads nur exklusiv ausgeführt. So wird
verhindert, dass z.B. ein nur halb aktualisierter Eintrag in einer Datenbank gelesen wird.
final
Finale (endgültige) Variablen sind Konstanten. Finale Methoden können durch keine neue
Implementation in Subklassen mehr überschrieben werden und von finalen Klassen dürfen keine
Subklassen mehr gebildet werden. Da man z.B. finale Methoden in Subklassen nicht überschreiben kann,
sollten Passwortabfragen final deklariert werden, außerdem kann der Compiler finalen Code besser
optimieren.
abstract
Abstrakte Klassen dürfen abstrakte (unvollständig implementierte) Methoden besitzen. Diese müssen
dann Subklassen implementieren. Abstrakte Klassen können nicht instantiiert werden.
static
static- Variablen (Klassenvariablen) und Methoden (implizit final!) gibt es im Gegensatz zu
Instanzvariablen nur je einmal pro Klasse und nicht je einmal pro Instanz. Static-Methoden können auch
nur mit static-Variablen und Methoden arbeiten.
public
Öffentliche Klassen, Methoden und Variablen sind überall zugänglich, also sowohl importiert als auch in
Subklassen.
private
Diese Variable oder Methode ist nur innerhalb der aktuellen Klasse verfügbar und wird auch nicht
mitvererbt.
protected
Diese Variable oder Methode ist nur innerhalb der aktuellen Klasse und deren Subklassen verfügbar.
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 12/15
transient
Dieser Modifier wird derzeit noch nicht benutzt und in ist späteren Versionen für Low-Level-Funktionen
und Datenbankzugriffe gedacht.
volatile
Dieser Modifier kennzeichnet, dass eine Variable asynchron aktualisiert wird und überwacht Operationen
damit besonders.
threadsafe
Durch dieses Schlüsselwort weiß der Compiler, dass die Variable nicht von mehreren Threads
gleichzeitig manipuliert wird und wird versuchen, sie in einem Register statt einem Speicherplatz
unterzubringen.
native
Eine solche Methode wird nicht in Java-Code, sondern in Assembler oder C implementiert (nicht
portabel). Siehe dazu die javah-Dokumentation.
Arrays
Beispiel:
double v[] = new double[10];
instanziert einen Array v mit 10 Elementen des Basistyps double. Mit a[0],..., a[9] kann auf
die einzelnen Felder des Arrays zugegriffen werden.
Allgemein:
Typ/Klasse VariablenNamen[] = new Typ/Klasse[Grösse];
Es ist ebenfalls möglich zuerst den Array zu deklarieren und die Grösse später festzulegen.
Beispiel:
double v[]; // deklariert einen Array
...
v = new double[10]; // alloziert 10 Elemente vom Typ double
Mehrdimensionale Arrays werden durch Anhängen von mehreren [] deklariert.
Beispiel:
double m[][] = new double[10][20];
deklariert einen 10x20 Array vom Typ double.
Allgemein:
Typ/Klasse VariablenNamen[][]..[] =
new Typ/Klasse[1 Dim.][2 Dim]..[n Dim];
oder
Typ/Klasse VariablenNamen[][]..[];
...
VariablenNamen = new Type/Klasse[1 Dim][2 Dim]...[n Dim];
Alle Bereichsüberschreitungen bei Arrays werden überwacht. Die Länge eines Arrays kann jederzeit
abgefragt werden:
int arraylaenge = v.length;
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
wichtige Operatoren
Operator
+ (Addition)
- (Subtraktion)
* (Multiplikation)
/ (Division)
% (Modulo)
<,<=,>=, > (arithmetisch)
== (Gleichheit)
!= (Ungleich)
&& (Boolean Und)
|| (Boolean OR)
= (Zuweisung)
Seite 13/15
Beispiel
a+b
a-b
a*b
a/b
a%b
a>b
a == b
a != b
(a > 5) && (b == 7)
(a != 2.0) || (b > 2.718)
a = 3.141;
Klasse/Typ
byte, short, int, long, float,
double, String
byte, short, int, long, float, double
byte, short, int, long, float, double
byte, short, int, long, float, double
byte, short, int, long
byte, short, int, long, float, double
alle
alle
boolean
boolean
alle
if Statement
if Statements werden gleich wie Pascal IF Statements programmiert, ausser dass die Bedingung
geklammert wird und BEGIN durch { und END durch } ersetzt werden.
Beispiel:
if (a > 5) {
System.out.println(“a grösser 5“);
} else {
System.out.println(“a ist kleiner oder gleich 5“);
}
Allgemein:
if (Bedingung) { // Code falls Bedingung erfüllt
...
} else { // Code falls Bedingung nicht erfüllt
...
}
if Statements können auch kaskadiert werden, wie das folgende Beispiel zeigt:
if ( (a > 5) && (b < -3) ) {
....
} else if (c == 7) {
...
} else {
...
}
while Statement
Beispiel:
i = 10;
while(i > 5) {
System.out.println(“i =“ + i);
i = i-1;
}
Gibt die Zahlen 10 9 8 7 6 auf den Bildschirm aus.
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 14/15
Allgemein:
while (Bedingung) {
...
// Code falls Bedingung erfüllt
}
do while Statement
Das do while Statement funktioniert wie das Pascalkonstrukt REPEAT ... UNTIL.
Beispiel:
i = 10;
do {
System.out.println((“i =“ + i);
i = i-1;
} while(i > 5);
Gibt die Zahlen 10 9 8 7 6 5 auf den Bildschirm aus.
for Statement
Ähnlich dem FOR-Statement in Pascal. In Klammern stehen 3 Anweisungen:
Initialisierung ; Fortsetzungsbedingung ; Inkrement.
Beispiel:
for(i=0; i < v.length; i=i+1) {
v[i] = 1.0;
}
Setzt alle Felder des 1 dimensionalen Arrays v auf 1.0.
Allgemein:
for (Initialiserung; Fortsetzungsbedingung; Änderung der Laufvariable)
{
... // Schleifencode
}
switch Statement
Beispiel:
switch (Scanner.nextCmd) {
case Scanner.Error: PrintError(); break;
case Scanner.Fire: Fire(); break;
default: Debug();
}
Entspricht dem Code
cmd = Scanner.nextCmd;
if (cmd == Scanner.Error) {
PrintError();
} else if (cmd == Scanner.Fire) {
Fire();
} else {
Debug();
}
Allgemein:
switch (Integerwert) {
case Wert1:
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3
Java-Intensivkurs am IAS
Seite 15/15
Code für Wert1;
break;
case Wert2:
Code für Wert2;
break;
...
default:
Code für Default;
}
Soll derselbe Code für mehrere Bedingungen ausgeführt werden, dann können case Statements
hintereinander kaskadiert werden.
case Wert1:
case Wert2:
Code für Wert1 und Wert2
break;
Bemerkung: Falls Sie in einem switch Befehl einen Fehler vermuten, dann schauen Sie zuerst nach, ob
Sie alle notwendigen break Befehle eingegeben haben. Häufig ist das Vergessen dieses Befehles
Ursache des Fehlers. Fehlende break -Befehle haben zur Folge, dass der Code aller folgenden caseStatements abgearbeitet wird; solange bis ein break erscheint.
IAS, 2012
java-kurzeinfuehrung-v13.docxx, Vers. 1.3