Sie sind auf Seite 1von 10

Java - Eine kleine Lernhilfe

oder
Grundregeln der
Java-Programmierung
Hanjo Hingsen
Version 1.0 beta vom 13. Februar 2004

Die aktuelle Version dieses Dokumentes finden Sie unter: http://fom.hingsenmedia.de


1
Haftungsausschluss:

Ich habe dieses Dokument nach bestem Wissen und Gewissen erstellt. Ich kann allerdings
trotzdem keinerlei Haftung für die Richtigkeit und/oder Fehlerfreiheit dieses Dokumentes
übernehmen. Jeder, der diese Unterlage nicht nur als Bieruntersetzer benutzt, tut dies
auf eigene Gefahr.

Copyright
c 2004, Hanjo Hingsen

1
Es sei allerdings erwähnt, dass ich diese Unterlage selber zur Klausurvorbereitung nutze und aus-
schließlich zu diesem Zweck erstellt habe.

1
Inhaltsverzeichnis
1 Java-Konventionen 3
1.1 Dateinamen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Klassennamen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4 Methodennamen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5 Variablenbezeichner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.6 Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Datentypen 5
2.1 elementare Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 komplexe Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3 Kurzschreibweisen 5
3.1 Ein kurzes If-Then-else: x:=1? a : c; . . . . . . . . . . . . . . . . . . . . 6
3.2 Inkrementieren und Dekrementieren in Pre- und Postfix . . . . . . . . . . 6

4 Die Methode main 6

5 Schlüsselwörter und Ihre Bedeutung 7


5.1 A bis C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
5.2 D bis F . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
5.3 G bis N . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5.4 M bis S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.5 T bis Z . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

6 Sonstiges 9
6.1 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6.2 Switch(es) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6.3 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2
Motivation
Manch einer mag sich eventuell Fragen: „Was soll das ganze hier? Wozu dient dieses Do-
kument?“. Die Antwort ist eigentlich ganz einfach. Zum einen ist dieses Dokument eine
Fingerübung im Umgang mit LATEX. Zum anderen wollte ich die Dinge rund um Java,
die man einfach als Basics wissen muss zusammenfassen. Es geht dabei im Wesentlichen
um Dinge, die man im Prinzip Auswendig lernen muss; die wenig mit Logik oder so zu
tun haben, als viel mehr mit einfach Wissen. Diesen Hintergrund hat dieses Dokument
und so soll es verstanden werden. Es ist keine vollständige Einführung in Java. Es soll
lediglich als Hilfe bei der Vorbereitung auf unsere Java-Klausur dienen un die Lücken in
den Unterlagen zur Vorlesung schließen. Ich hoffe, dass es diesem Anspruch genügt. So,
und nun viel Spass oder besser Erfolg beim Lesen...

Achja, dieses Dokument folgt keinem besonderen pädagogischen Konzept. Es ist durch-
aus möglich, dass dem einen oder anderen die hier niedergeschriebenen Dinge etwas un-
sortiert und/oder wahllos erscheinen mögen.
Im Prinzip ist das auch so...

1 Java-Konventionen
Konventionen sind kann Regeln. Kein muß. Sie sollten aber im Sinne eines einheitlichen
Standards und der stark verbesserten späteren Wartbarkeit der Software eingehalten
werden. Sie einzuhalten gilt als „Guter Stil“. Achtung! In diesem Zusammenhang sei
angemerkt, dass Java zwischen Groß-/Kleinschreibung unterscheidet2 . Wenn man also
einmal damit anfängt muß man sich auch weiter daran halten. Der Bezeichner „wert“
ist ein anderer als „Wert“. Des weiteren ist zu beachten, dass deutsche Umlaute3 in den
Bezeichnern sehr wohl erlaubt sind. Das ist zwar etwas gewöhnungsbedürftig, aber wie
gesagt, es funktioniert...

1.1 Dateinamen
Entsprechen immer dem Namen der ersten Klasse in der Datei (class .......). Gleiche
Schreibweise beachten! Somit gilt auch hier die gleiche Konvention wie für Klassen.

1.2 Packages
Die Namen von Packages werden komplett klein geschrieben.

2
Wird auch als „Case-Sensitivität“ bezeichnet.
3
sprich: äÄ, öÖ, üÜ, ß

3
1.3 Klassennamen
Bei Klassennamen beginnt jedes (Teil-)Wort mit einem großen Buchstaben.
Beispiel: DasIstEinGuterKlassenname

1.4 Methodennamen
Bei Methodennamen beginnt das erste (Teil-)Wort klein uns alle folgenden (Teil-)Wörter
werden groß geschrieben.
Beispiel: dieserMethodennameEntsprichtDerKonvention

1.5 Variablenbezeichner
Zeichenketten aus Buchstaben, Ziffern, Unterstrichen (_) und Dollarzeichen ($) Sie dür-
fen nicht mit einer Ziffer beginnen und keine Leerzeichen enthalten! Auch alle ande-
ren Sonderzeichen (außer den oben erwähnten) sind verboten. Bezüglich der Groß-
/Kleinschreibung existieren für Bezeichner die selben Konventionen, wie für Methoden.
Beipiele für gültige Bezeichner:

• $Wert

• _Wert

• Wert

• wert

• wert_

• Trick17

Beispiele für ungültige Bezeichner:

• 17Trick

• Variablen Name

• Wert-100

1.6 Konstanten
Variablen, die mittels final zu einer Konstanten gemacht wurden, werden komplett
GROß geschrieben.

4
2 Datentypen
Datentypen sind ganz allgemein erst einmal wie folgt definiert:
Datentypen haben einen fest eingegrenzten Wertebereich sowie Operationen, die auf
diesen Datentyp deklariert sind. Man unterscheidet 2 Arten von Datentypen:

2.1 elementare Datentypen


Die folgenden elementaren Datentypen sind in Java definiert:
int byte char
double float long
void boolean short
Die einzelnen Wertebereiche sollen im Moment nicht weiter interessieren. Auf die her-
vorgehobenen Typen sind im Wesentlichen die Operationen Plus(+), Minus(-), Multipli-
zieren(*) und Dividieren(/) definert. Diese Aufzählung ist allerdings weder vollständig
noch abschließend. Der Datentyp void stellt eine Besonderheit unter den Datentypen
dar4 . Er hat keinen Wertebereich. Eine Variable oder Methode, die als void deklariert
wird, liefert kein auswertbares Ergebnis zurück. Klassischer Anwendungsfall, ist die Me-
thode main. Näheres zu dieser Methode finden Sie in Kapitel 4.

2.2 komplexe Datentypen


Zur Zeit ist mir in Java nur ein einziger vordefinierter komplexer Datentyp bekannt:
String. Das ist auch der Grund, warum das Schlüsselwort String in Java in Variablen-
deklarationen immer groß geschrieben wird. String ist eine Klasse. Die Schreibweise:
String variable; ist nur die Kurzschreibweise für: String variable = new String();. Beide
Schreibweisen funktionieren und sind alternativ anwendbar.

3 Kurzschreibweisen
„Programmierer sind faul.“ Das behauptet dieser Berufszweig von sich selbst. Meiner
Meinung nach trifft das auf C -Programmierer in besonderem Maße zu. Nur einem C-
Programmierer geht ein beühmtes Zitat wie „2b || !2b“ 5 wirklich leicht von der Hand.
Aber nun ja... . Da sich Java bekanntermaßen kräftig bei der C und C++ Syntax
bedient hat, gibt es auch in Java entsprechend kuriose Schreibweisen. Warum, das im
einzelnen so ist, entzieht sich meiner Kenntnis. Möglicherweise ist das Laufzeitverhalten
dieser Kurzformen besser als das der langen. Sollte jemand Informationen darüber haben,
würde ich mich über eine Nachricht freuen. Diese Kurzformen möchte ich nun hier im
einzelnen erörtern:

4
Ich bin mir im Moment nicht einmal ganz sicher, ob das überhaupt wirklich ein Datentyp ist.
5
frei nach William Shakespear’s „To be or not to be.“

5
3.1 Ein kurzes If-Then-else: x:=1? a : c;
1 x :=1? a : c ;
Tja. Das ist es nun. Sieht schon etwas seltsam aus, oder? Die lange Schreibweise für
diesen Ausdruck lautet:

1 i f ( x==1) then // Wenn x g l e i c h 1 i s t , dann


2 x=a ; // e r s e t z e den Wert i n x mit dem i n a
3 e l s e x=c ; // a n s o n s t e n e r s e t z e den Wert i n x mit dem i n c
Diese Kurzschreibform kann auch (genau wie die lange) ineinander geschachtelt wer-
den. D.h. es darf sowohl im ’Ja’- als auch im ’Nein’-Teil eine erneute if-Abfrage kommen
(oder auch jeder sonstige Ausdruck). Ich bevorzuge das zwar nicht, weil ich es für un-
übersichtlich und schwerer wartbar halte, aber wer’s mag...

3.2 Inkrementieren und Dekrementieren in Pre- und Postfix


Zu diesen Kurzschreibweisen gehört auch das In- und Dekrementieren, also das Herauf-
und Herunterzählen. Die klassische Schreibweise für einen solchen Vorgang ist:
1 x=x +1 ; // Nehme x und e r h o e h e s e i n e n Wert um 1
In Kurzschreiweise lautet dieser Befehl:
1 x++; // Nehme x und e r h o e h e s e i n e n Wert um 1
Analog dazu funktioniert der x−−; Befehl für das Verringern um 1. Wenn größere
Sprünge als 1 erforderlich sind kann man auf diese Kurzschreibweise zurückgreifen:
1 x+=5; // Nehme x und e r h o e h e s e i n e n Wert um 5
Wenn man diese Kurzformen in Schleifen (speziell der for-Schleife) einsetzt muss man
allerdings etwas aufpassen. Bei der x++; Variante wird die Abbruch Bedingung erst
geprüft und danach die Variable um 1 erhöht. Bei der ++x; ist es genau andersherum.
Es wird zuerst x um 1 erhöht und danach erst wird die Abbruchbedingung überprüft.
Das kann also dazu führen, dass wenn man nicht aufpasst, die Abbruchbedingung schon
vor dem ersten Schleifendurchlauf erfüllt ist und somit die Schleife nicht ein einziges
Mal durchlaufen wird. Das kann durchaus erwünscht sein, aber man sollte halt darauf
aufpassen. Alles hier gesagte gilt natürlich für x−−; und −−x; analog.

4 Die Methode main


In Java gibt es, speziell wenn man Objekt orientiert programmiert, diverse Methoden,
die in einem Programm vorhanden sein müssen. In reinen Text-Modus Appliaktionen
gibt es nur eine einzige Muß-Methode. Die Methode main. Der Grund dafür, dass diese
Methode vorhanden sein muß, liegt darin, dass diese Methode automatisch als erstes

6
vom Interpreter aufgerufen wird, wenn das Programm gestartet wird. Wenn eine Appli-
kation keine main-Methode hat, kann sie auch nicht gestartet werden.

Eine weitere Sache, die man einfach nur auswendig lernen kann ist die Sache mit der
Parameter-Übergabe. Die korrekte Schreibweise lautet:
1 public s t a t i c void main ( S t r i n g a r g s [ ] ) ;
Ich habe mir die Kombination über folgende Eselsbrücke gemerkt: Ein Programm kann
im Prinzip beliebig viele Partameter haben. Diese Parameter werden dem Programm als
Liste und in Java speziell als Array übergeben.
Es hat sich herausgestellt, dass die Schreibweise:
1 public s t a t i c void main ( S t r i n g [ ] a r g s ) ;
auch funktioniert. Die Deklaration und die interne Arbeitsweise ist eine andere, aber der
Effekt ist der selbe. Und nur dass zählt.

5 Schlüsselwörter und Ihre Bedeutung


Also, innerhalb der Vorlesung haben wir 38 Schlüsselwörter besprochen. Hier kommt
eine Auflistung und eine kurze Erklärung dazu. Es wird allerdings so sein, dass die
Erklärungen erneut Fragen aufwerfen. Diese werde ich aber nur in den seltensten Fällen
auch beantworten.

5.1 A bis C
abstract Deklariert eine Klasse oder eine Methode als „Abstract“. Also nicht fertig im-
plementiert.

boolean Datentyp; Kann nur die Werte True und False annehmen.

break Bricht die Abarebeitung des aktuellen Code-Blocks( ... ) ab und verlässt ihn.

byte Datentyp; Nimmt Werte zwischen 0 und 255 an.

case Fallunterscheidung in einem switch.

char Datentyp; Kann nur einzelne Zeichen aufnehmen.

class Deklaration einer Klasse.

5.2 D bis F
continue Bricht einen Schleifenrunpf ab und springt sofort wieder in die Prüfung.

default Es gibt 2 Verwendungen:

7
1. explizit: Fallunterscheidung im switch: „Alles andere“ außer den case’es.
2. implizit: Zugriffsmodifizierer für Klassen

do 2ter Teil der While-do-Schleife

double Datentyp; Großer Fließkomma-Typ

else „Ansonsten“-Zweig einer If-then-else Bedingung

extends Leitet die Erweiterung einer Klasse ein. Klasse-2 extends Klasse-1; (Klasse-2
erweitert die Funktionen der Klasse-1)

false Wert des Datentyps boolean

final Definiert eine Klasse, eine Methode oder eine Variable als endgültig fertig und
nicht mehr veränderbar(Konstant).

float Datentyp: Kleiner Fließkomma-Typ

for Leitet eine for-to-do Schleife ein. Quasi eine organisierte while-do-Schleife.

5.3 G bis N
if Leitet eine if-then-else Abfrage ein. Format: If (Bedingung) then ... else ...;

implements Weist daruf hin, dass in dieser Methode ein Interface implementiert wird.
Bsp: Klasse1 implements ActionListener;

int Datentyp: positive und negative ganze Zahlen - Klein

interface Deklariert eine Methode zu einem Interface. Es wird also eine allgemeine
Schnittstelle definiert, aber noch nicht implementiert.

instanceof Prüft, ob ein (zu übergebendes) Objekt eine Instanz einer bestimmten Klasse
ist. Bsp: if (MeineKlasse1 instanceof Klasse1) then ...

long Datentyp: positive und negative ganze Zahlen - Groß

new Erzeugt eine neue Instanz einer Klasse

null Explizietes Löschen einer Objekt-Referenz und somit freigeben des Speichers. Bsp:
MeinObjektKreis=null;

8
5.4 M bis S
package Fasst eine Sammlung von Klassen zu einem sowohl logischen als auch physi-
schen Paket zusammen.

private Zugriffsmodifizierer: Deklariert eine Klasse, Methode oder Variable als privat
also nur lokal sichtbar. Bei Variablen ist z.B. der Zugriff „von Aussen“ nicht mehr
möglich. Stichwort: Setter / Getter

protected Zugriffsmodifizierer: Deklariert eine Klasse, Methode oder Variable als pro-
tected.

public Zugriffsmodifizierer: Deklariert eine Klasse, Methode oder Variable als public.

return Rücksprung aus einer Methode mit Rücklieferung eines Wertes. Bsp: return a *
b;

short Datentyp: Kleiner Bruder von Long.

static Zugriffsmodifizierer: Deklariert eine Methode als Statisch. Also schon vorhanden
und benutzbar, noch bevor es eine Instanz dieser Klasse gibt. Bsp: Math.random()

super Zugriff auf Methoden der direkten Oberklasse6 .

switch Leitet eine Fallunterscheidungs-Kontrollstruktur ein.

5.5 T bis Z
this Expliziter Zugriff auf die eingene Klasse. Z.B. bei verschatteten Feldern.

true Wert des Datentyps boolean

void Definiert, dass eine Methode keinen Wert zurückliefert. Also zu einer Prozedur
wird.

while Leitet eine while-do-Schleife ein. Format: while(Bedingung) do ...;

6 Sonstiges
Hier kommt jetzt unsortiert so diverses, dass ich nirgendwo anders hinschreiben konnte:

6
Ich weiß im Moment nicht, ob nur Zugriff auf den Konstruktor möglich ist, oder auf alle Methoden.

9
6.1 Kontrollstrukturen
Folgende 3 Kontrollstrukturen sind notwendig, damit man mit einer Programmiersprache
auch wirklich Programme schreiben kann.

1. Sequenzen:Abarbeitung Zeile für Zeile

2. Bedingungen:Wenn der Fall XY eintritt, mache dieses

3. Schleifen:Wiederhole diesen Vorgang solange, bis ...

6.2 Switch(es)
Die switch-Kontrollstruktur funktioniert nur mit (int) Zahlen oder char’s. String’s und
Fließkommzahlen tauchen nicht.

6.3 Arrays
Jedes einzelne Feld eines Arrays kann wiederum ein Array beliebiger Länge enthalten. D.
h., dass man nicht nur eine tabellenartige Struktur erzeugen kann, sondern eine Struktur
möglich ist, die einem Kreutzworträtsel ähnelt.

10