Kurzeinführung Java - Fakultät Informatik Uni Stuttgart

Informatik Verbund Stuttgart
der Universität Stuttgart
Java-Tutorium
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++ ..........................................................................................................................8
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..................................................................................................................................................14
while Statement............................................................................................................................................14
do while Statement .......................................................................................................................................15
for Statement................................................................................................................................................15
switch Statement ..........................................................................................................................................15
UNIX-KURZEINFÜHRUNG............................................................................................................................. 17
Dateibezeichner ...........................................................................................................................................17
Unix Kommandos.........................................................................................................................................17
JAVA QUIZ........................................................................................................................................................ 18
Multiple choice ............................................................................................................................................18
Wahr oder falsch?........................................................................................................................................19
IVS, 2000
IVS-Java-Tutorium
Seite 2/20
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 Java-Plattform
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?
IVS, 2000
IVS-Java-Tutorium
Seite 3/20
Die folgenden Erklärungen gehen davon aus, dass sie das kostenlose JDK von JavaSoft
[http://www.javasoft.com] benutzen. Offizielle Distributionen gibt es für Win95/NT, Solaris und MacOS.
Das Entwicklerkit enthält den Compiler, das API (Application Programming Interface), einen
Appletviewer, Debugger und andere Werkzeuge. Zu allen Programmen und Klassen ist der Sourcecode
enthalten. Die aktuelle Version des Entwicklerkits ist 1.2. Auch die im HTML-Format vorliegende
Dokumentation wird unbedingt benötigt. Alles in allem nimmt das ganze einiges über 30 MB
Festplattenplatz ein. Wenn Sie nur auf die Version 1.0.2 zurückgreifen können, werden sich die meisten
Programme nicht übersetzen lassen.
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 95 auch eine Menge integrierter Umgebungen, die
einen guten Editor besitzen und den Compiler automatisch aufrufen können. Zu nennen sind hier u.a. Jpad
[http://www.modelworks.com] und Kawa [http://www.fni.net/kawa], die beide als Shareware im Internet
zu haben sind.
Auch kommerzielle Programme werden angeboten, wie z.B. der Java Workshop von Sun, Visual J++ von
Microsoft, Borland’s OpenJ-Builder, Symantec Café und viele andere. 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“. Im neuen Windows 95 (OSR2) ist Java schon eingebaut, der
Interpreter (mit schneller JIT-Compiler) heißt hier jview. Bisher wird aber nur Sprachversion 1.02
unterstützt. Unter Linux lassen sich die Programme direkt starten, bisher allerdings ebenfalls erst Version
1.02. 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 abgescha ltet 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.
IVS, 2000
IVS-Java-Tutorium
Seite 4/20
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
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 wiederverwendbaren 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 aufgrund 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.
IVS, 2000
IVS-Java-Tutorium
Seite 5/20
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.
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“.
IVS, 2000
IVS-Java-Tutorium
Seite 6/20
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 (jetzt existieren schon über eine halbe Million Programme) und man die
Hardware wählt, die diese Programme am schnellsten ausführt. Heute gibt es z.B. den RISC-PC von
Acorn, der extrem wenig Strom verbraucht, bei einer mit einem Pentium Pro vergleichbaren Leistung auch
mit 200 MHz nur Bruchteile kostet und eine der schnellsten Java-Plattformen ist. Er ist aber bisher für
Privatanwender weniger eine Alternative, da Allerweltssoftware auf dieser zum Intel x86 inkompatiblen
Architektur nicht lauffähig ist. Das könnte sich bald ändern. Es gibt sogar schon eine Java-Version von
Corel Office, der in den USA verbreitetsten Office-Software. Wer auf proprietäre (herstellerabhängige)
Software setzt, wird es also in Zukunft (hoffentlich) schwer haben.
Java hat die Macht, einiges zu verändern.
Sun hat schon die ersten Prozessoren auf dem Markt, die Java-Bytecode hardwaremäßig verarbeiten
können, Features wie Bilddekomprimierung und Speicherverwaltung bereits im Microcode enthalten und
sehr preisgünstig sind. Des Weiteren ist schon eine kleine Version des Chips um einen zweistelligen Faktor
schneller als ein Just in Time Compiler (JIT) auf einem schnellen Pentium. Die Chips heißen pico- micround Ultra-Java und sollen zwischen $25 und $100 kosten.
Sun: „The network is the computer“
JavaOS wird das Betriebssystem für Netzcomputer (NCs).
Sun vertreibt jetzt schon JavaStations, so genannte Zero administration clients, die ihr Betriebssystem und
alle Applicationen von einem Server laden und keine lokalen Massenspeicher oder leistungfähige
Prozessoren benötigen. Muss ein Gerät ausgetauscht werden, kann sofort weitergearbeitet werden. Neue
Updates des Betriebssystems oder von Applikationen werden automatisch von allen Clients genutzt. Da das
Einrichten und Verwalten (ganz zu Schweigen von den vielen Problemen) von Windows-Arbeitsrechnern
schon bei geringer Anzahl zur Sisyphusarbeit wird, sicher eine erfolgversprechende Sache.
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.
IVS, 2000
IVS-Java-Tutorium
Seite 7/20
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.java
lädt die HTML-Datei test.java 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
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
IVS, 2000
IVS-Java-Tutorium
Seite 8/20
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)
• dynamisches Laden und Binden (late binding)
• Sicherheitsmodell (Überprüfung vor Ausführung)
• portabel ohne Neucompilierung (Bytecode)
• UniCode-Zeichenketten sowie echte Strings und Felder
IVS, 2000
IVS-Java-Tutorium
Seite 9/20
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 π in der Klasse Math ist
wie folgt deklariert: public static final double PI=3.14159;
Einfache Datentypen
Typ
boolean
char
byte
short
int
IVS, 2000
enthält
true oder
false
Unicode
Zeichen
signed
integer
signed
integer
signed
integer
Default
false
Grösse
1 Bit
Min Wert
false
Max Wert
true
\u0000
16 Bits
\u0000
\uFFFF
0
8 Bits
-128
127
0
16 Bits
-32768
32767
0
32 Bits
-2147483648
2147483647
IVS-Java-Tutorium
long
float
double
Seite 10/20
signed
0
integer
IEEE 754
0.0
floating point
IEEE 754
0.0
floating point
64 Bits
-9223372036854775808
9223372036854775807
32 Bits
±1.40239846E-45
±3.40282347E+38
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) {...}
IVS, 2000
IVS-Java-Tutorium
Seite 11/20
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.
Klassenmethoden wird das Schlüsselwort static vorangestellt:
Beispiel:
Exponentialfunktion 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
IVS, 2000
IVS-Java-Tutorium
Seite 12/20
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.
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];
IVS, 2000
IVS-Java-Tutorium
Seite 13/20
Alle Bereichsüberschreitungen bei Arrays werden überwacht. Die Länge eines Arrays kann jederzeit
abgefragt werden:
int arraylaenge = v.length;
IVS, 2000
IVS-Java-Tutorium
wichtige Operatoren
Operator
+ (Addition)
- (Subtraktion)
* (Multiplikation)
/ (Division)
% (Modulo)
<,<=,>=, > (arithmetisch)
== (Gleichheit)
!= (Ungleich)
&& (Boolean Und)
|| (Boolean OR)
= (Zuweisung)
Seite 14/20
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.
IVS, 2000
IVS-Java-Tutorium
Seite 15/20
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:
Code für Wert1;
break;
IVS, 2000
IVS-Java-Tutorium
Seite 16/20
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 case-Statements
abgearbeitet wird; solange bis ein break erscheint.
IVS, 2000
IVS-Java-Tutorium
Seite 17/20
Unix-Kurzeinführung
Dateibezeichner
Ein Unix-Dateibezeichner besteht aus drei Teilen
• Pfad
• Dateiname
• Dateisuffix (Extension)
Beispiel:
/users/gruppe99/beispiel.txt
Unix Kommandos
pwd
gibt das aktuelle Arbeitsverzeichnis zurück
ls <pfad>
listet alle Dateinamen in dem Verzeichnis <pfad> oder im aktuellem
Verzeichnis, falls kein <pfad> angegeben wurde
cat <dat> | more
gibt die Datei <dat> seitenweise auf dem Bildschirm aus
cd <pfad>
wechselt das Arbeitsverzeichnis
rm <dat>
löscht unwiderruflich die Datei <dat>
cp <dat1> <dat2>
kopiert Inhalt der Datei <dat1> in <dat2>
mv <dat1> <dat2>
verschiebt die Datei <dat1> nach <dat2>
IVS, 2000
IVS-Java-Tutorium
Seite 18/20
Java Quiz
Versuchen Sie mit Hilfe der folgenden Fragen Ihre Java-Kenntnisse zu vervollständigen.
Multiple choice
Kreuzen Sie die korrekten Alternativen an. Es ist mindestens eine richtig.
Aufgabe 1.1: Welcher Befehl dient dazu, die fertig übersetzte Application „test“ auszuführen?
¨ javac test.java
¨ java test.class
¨ java test
¨ java TEST
Aufgabe 1.2: Was ist ein gültiger Dateiname für eine Quelldatei, die die öffentlich Klasse “Config“ enthält?
¨ test.java
¨ config.java ¨ Config.java ¨ Config.jav
¨ config.c
Aufgabe 1.3: Welches sind in Java gültige Bezeichner?
¨ störung
¨ _count
¨ double
¨ “var“
¨ counter
¨ f22 ¨ 2x
¨ $test$
¨ %init
Aufgabe 1.4: Welcher Ausdruck legt ein neues String-Objekt an?
¨ String st=“Dies ist ein Test.“;
¨ String st=new String(“Dies ist ein Test.“);
¨ String st=new String("ein "+"test"); ¨ String st;
¨ String st=null;
Aufgabe 1.5: Welcher Ausdruck legt eine Variable vom Typ int an?
¨ int i=new int(53);
¨ int i=25;
¨ int i=new int(4.2);
¨ int i=8+5;
¨ int i;
Aufgabe 1.6: Was sind gültige Datentypen in Java?
¨ int ¨ String
¨ File ¨ Double
¨ byte ¨ word¨ boolean
¨ char ¨ Integer
¨ long
Aufgabe 1.7: Welche der folgenden Schleifen wird genau zehnmal ausgeführt?
¨ for (int i=0; i<10; i++) {}
¨ int i=11; while (--i>0) {}
¨ for (int i=1; i<=10; i++) {}
¨ for (int i=1; i<10; i++) {}
¨ int j=11; do { j--; } while (j>1);
¨ for (int k=0; k<13; k++) { if (k==9) break; }
IVS, 2000
IVS-Java-Tutorium
Seite 19/20
Wahr oder falsch?
Entscheiden Sie sich, ob Sie den folgenden Aussagen zustimmen (þ), oder nicht (ý).
¨ Java ist eine Interpretersprache, d.h. der Quellcode wird während der Ausführung in Maschinenbefehle
umgesetzt.
¨ Java ist wie C++ eine objektorientierte, höhere Programmiersprache.
¨ Bei der Eingabe eines Java-Programmes muss man darauf achten, keine zusätzlichen Zeilenumbrüche
oder Leerzeichen zwischen den Befehlen einzufügen, da es sonst zu Fehlern kommen kann.
¨ Wenn die Kapazität eines „int“ (32 bit) nicht ausreicht, kann man mit der Vorsilbe „long“ einen 64 bit
„long int“ Datentypen vereinbaren.
¨ In Java kann man wegen der Einschränkungen des hier verwendeten ASCII-Zeichensatzes nicht alle
nationalen Sonderzeichen verwenden.
¨ Wenn ein Java-Programm keine „import“-Befehle enthält, benötigt es keine anderen Packages und kann
ohne die Standardklassen ausgeführt werden.
¨ Nach dem Übersetzen durch den Compiler wird das Java-Programm mit seinen Bibliotheken zu einer
ausführbaren Datei (z.B. „test.exe“) zusammengelinkt.
¨ Die in der Hauptklasse einer Application befindliche main-Methode muss zwingend als static deklariert
werden, damit sie trotz einer beliebigen Anzahl von Instanzen nur einmal existiert.
¨ In einer Klasse als „private“ deklarierte Methoden können ausschließlich von der Klasse selbst und
deren Subklassen, nicht aber von solchen, die eine Instanz der Klasse nutzen, aufgerufen werden.
¨ Eine Klasse kann nur dann gleichzeitig „abstract“ und „final“ sein, wenn in Subklassen keine ihrer
Methoden überschrieben wird.
¨ Der Ausdruck „i+=1“ ist identisch mit den Ausdrücken „i++“, „++i“ und „i=i+1“.
¨ Im Unterschied zu C++ sind Strings in Java keine aus chars zusammengesetzten Felder, sondern
vollwertige Objekte.
¨ Man kann Zeichenketten mit dem „+“-Operator verknüpfen.
¨ Greift man bei Feldern auf Elemente außerhalb des definierten Bereiches zu, kann das zu
unvorhergesehenen Resultaten führen.
¨ Mit Applications kann man weder Benutzeroberflächen noch Menüs, o.ä. darstellen.
¨ Applications können auf beliebige lokale oder Netzresourcen zugreifen, so weit der Benutzer den nötigen
Zugang dazu hat.
¨ Zur Ausführung von Applets benötigt man einen Java-kompatiblen WWW-Browser.
¨ Wird einer Methode eine Variable als Argument übergeben, so arbeitet diese mit einer lokalen Kopie der
Variable.
¨ Wenn die Variable „i“ vom Typ „int“ ist, erzeugt folgender Ausdruck einen Compilerfehler: „if(i);“.
¨ Eine Variable vom Typ „int“ kann verlustfrei in den Typ „float“ umgewandelt werden.
¨ Wenn man beim Aufruf einer Methode die Klammern hinter dem Namen weglässt, wird diese wie eine
Variable behandelt.
¨ Wenn eine Klasse eine Methode ihrer Superklasse überschreibt, kann sie auf die überschriebene
Methode der Superklasse nicht mehr zugreifen.
IVS, 2000
IVS-Java-Tutorium
Seite 20/20
¨ Wenn man vergisst, angeforderten Speicher bei Beenden eines Java-Programmes wieder freizugeben,
kann das System aufgrund der nicht zugeordneten Ressourcen instabil werden.
¨ Ein „switch“-Block führt je nach Inhalt einer beliebigen Variable unterschiedlichen Programmcode aus.
IVS, 2000