Grundlagen Java

-1-
Grundlagen Java
Zahlen
Für Ganzzahlen gibt es u.a. int (mögliche Werte: -2 Mrd. bis +2 Mrd.) und long (mögliche Werte: - 9 Trio bis +9 Trio). Für
Kommazahlen gibt es double und float
Dezimaltrennzeichen ist der Punkt, nicht das Komma! Wird eine float-Variable mit einer Zahl (einem sog. "Literal") initialisiert,
muss "f" angehängt werden, sonst interpretiert sie der Compiler automatisch als "double"!
float z1 = 3.7f; // sonst gibt´s die Fehlermeldung "incompatible types"
double z2 = 4.9; // an double-Variablen muss nichts angehängt werden
Umwandeln Text  int
int x = parseInt(txtEingabe.getText()); // den Inhalt des Textfeldes "txtEingabe" auslesen und in einen int
umwandeln
Umwandeln int Text
int x = 100;
String abc = String.valueOf(x); // die int-Variable "x" in einen String umwandeln und der Variable "abc" zuweisen
Umwandeln Kommazahl → Ganzzahl
= nichts anderes als (auf- bzw. ab)runden (statische Method "round" aus der Klasse "Math"):
float f = 1.6f;
int i = Math.round(f); // In der Math - Klasse gibt´s eine Menge Methoden für mathematische Aufgaben
Strukturen
Es gibt in Java zahlreiche Klassen, die mehrere häufig verwendete Felder enthalten. Da es sich um Klassen handelt, müssen sie vor
Verwendung erzeugt (instanziert) werden:
Point (enthält "x" und "y"):
Point pos = new Point(10,40); // erzeugen und initialisieren: x = 10 und y = 40)
int x = pos.x; // Zugriff
Dimension (enthält "Width" und "Height"):
Dimension d = new Dimension(10,40); // erzeugen und initialisieren: Width = 10 und Height = 40)
int w = d.Width; // Zugriff
Rectangle (enthält x,y,Width und Height):
Rectangle r = new Rectangle(10,8,200,400);
int h = r.Height; // Zugriff
Array
Deklaration:
int[] arZahlen; // dieses Array kann noch nicht verwendet werden. Momentan gibt´s nur eine leere Variable
Instanzierung:
arZahlen = new int[100]; // jetzt bietet das Array Platz für 100 int-Zahlen (die Zahlen selbst können alle Werte
annehmen, die mit int möglich sind, d.h. zwischen -2Mrd bis + 2Mrd)
Zugriff auf Arrays ist erst dann möglich, wenn sie erzeugt (instanziert) wurden!
Deklaration + gleichzeitig Instanzierung:
int[] arZahlen = new int[100];
Deklaration + Initialisierung mit "Wertereihe"
In geschwungener Klammer die Werte angeben, die das Array enthalten soll. Man darf sie nachher zwar ändern, aber nicht mehr
als zu Beginn einfügen: es wird genauso viel Platz reserviert wie Werte eingetragen wurden!
int[] arZahlen = { 4, 23, 435, 8 }; // Platz für genau 4 Integer
-2Zugriff auf Arrays
Mit einem "Index" (= Zahl zwischen 0 und Größe des Arrays -1)
arZahlen[7] = 3788; // Zugriff auf das 8.Element des Arrays (Zählung beginnt mit "0"!)
Wie kann ich ermitteln, wieviel Platz für ein Array reserviert wurde?
int anzahl = arZahlen.length; // Eigenschaft "length" des Arrays = Anzahl der mögl. Elemente
Zweidimensionale Arrays
Zwei eckige Klammern für die zwei Ebenen:
int[][] schachbrett = new int[8][8]; // Array mit zwei Ebenen für je 8 Elemente
Schleifen
for
for(int i = 0; i < 10; i++)
{
;
}
// Schleifenzähler mit 0 initialisieren = "init"
// Abbruchsbedingung (wie lange soll die Schleife laufen?) = "test"
// Änderung des Schleifenzählers nach jedem Durchgang = "update"
Die 3 Bereiche ("init", "test", "update") können auch leer bleiben; als Schleifenzähler kann auch eine bereits zuvor deklarierte
Variable verwendet werden.
Zwei "verschachtelte" for-Schleifen für mehrdimensionale Arrays
Die Länge der beiden Ebenen des Arrays erfährt man durch die Eigenschaft "length". In eckiger Klammer hinter der ArrayVariablen muss die gewünschte Ebene angegeben werden (0 = 1.Ebene, 1 = 2.Ebene):
int[][] schachbrett = new int[8][8];
for(int x = 0; x < schachbrett[0].length; x++) // äußere Schleife. Abbruchbedingung= Anzahl Elemente
der 1.Ebene
{
for(int y = 0; y < schachbrett[1].length; y++
// innere Schleife. Abbruchbedingung= Anzahl Elemente
der 2.Ebene
{
schachbrett[x][y] = 0;
}
}
"Erweiterte" for-Schleife
Statt einer normalen for-Schleife mit Schleifenzähler ist für Arrays (und Listen) auch eine verkürzte Version erlaubt:
int[] arZahlen = new int[10];
for(int c: arZahlen) // bedeutet "nimm alle int´s des Arrays arZahlen und ermögliche den Zugriff auf jeden einzelnen
int mithilfe der Variable c". Statt "c" ist jeder beliebige Name möglich, aber der Datentyp (int)
muss mit dem Datentyp des Arrays übereinstimmen
{
c = 3966; // Zugriff auf die einzelnen Elemente des Arrays über die Variable "c"
}
while
Die Abbruchsbedingung wird zu Beginn überprüft, d.h. möglicherweise läuft die Schleife kein einziges Mal durch! Der
Schleifenzähler muss vorher deklariert werden! Innerhalb der Schleife den Schleifenzähler ändern, sonst gibt´s eine
"Endlosschleife"!
int i = 10; // Schleifenzähler außerhalb der Schleife deklarieren und initialisieren
while(i < 20) // Abbruchbedingung in Klammern
{
;
i++; // Schleifenzähler nach jedem Durchgang ändern!
}
-3do ... while
Im Unterschied zu "while" erfolgt die Prüfung der Abbruchbedingung erst am Ende, d.h. sie wird auf jeden Fall zumindest
einmal durchlaufen!
int i = 10;
do
{
;
i++;
}
while (i < 10);
Kontrollstrukturen
if ... else
In Klammern die Bedingung. Möglich sind: <, >, <=, >=, ==, !=. Beachte "==" für "gleich" und "!=" für "ungleich"!
if(x > 10)
{
;
}
else
{
;
}
switch
Müssen zahlreiche Bedingungen überprüft werden, bietet sich die "Switch" - Struktur an. Jeder Zweig muss mit "break"
abgeschlossen werden. "default" steht für "alle übrigen möglichen Fälle"
int a = 10; // eine Variable, deren Inhalt überprüft werden soll (kann auch ein String sein)
switch(a) // "was steht in a"?
{
case 5: // falls 5, dann ...
{
;
break;
}
case 8: // falls 8, dann ...
{
;
break;
}
default: // in allen anderen Fällen ...
{
;
break;
}
}
-4Methoden
Deklaration:
"Methodenkopf" mit Zugriffsmodifizierer, Rückgabewert, Name und Parameterliste
private void zeichnen(Graphics g, int x, int y, int w, int h)
{
g.drawRectangle(x, y, w, h);
}
Der "Zugriffsmodifizierer" private bedeutet: nur in dieser Klasse sichtbar. "void" bedeutet: es gibt keinen Rückgabewert.
Aufruf:
zeichnen(evt.Graphics, 0, 0, 100, 200);
Methode mit Rückgabewert
Schlüsselwort „return“ schickt den Rückgabewert an den Aufrufer zurück. Jeder Datentyp ist als Rückgabewert erlaubt:
private boolean prüfen(int a, int b) // Im Methodenkopf muss der Datentyp des Rückgabewerts stehen
{
if(a > b) return true; // "return" schickt den Rückgabewert ab (hier: "true")
else return false;
}
Aufruf einer Methode mit Rückgabe und Auswertung des Rückgabewerts:
boolean ergebnis = prüfen(wert1, wert2); // Methode aufrufen und Rückgabewert in einer Variable speichern
if(ergebnis) // Rückgabewert auswerten
{
...
}
Auch in einer einzigen Anweisung möglich:
if(prüfen(wert1, wert2)) { ... }
Statische Methoden
Wie statische Felder werden auch statische Methoden mit dem Klassennamen aufgerufen. In Java gibt es zahlreiche derartige
Klassen, z.B. „Math“ für mathematische Aufgaben:
double
int x1
double
double
y = 23.5;
= Math.round(y); // y auf Ganzzahl runden
x2 = Math.sqrt(y); // √𝑦
x3 = Math.Pow(y,3); // 𝑦 3
Selbsterstellte statische Methoden
Vor dem Rückgabewert "static" einfügen. Statische Methoden sind normalerweise "public" (sie sollen ja außerhalb der Klasse
aufgerufen werden können)
public Class All
{
public static Point umwandeln(int xPixel, int yPixel, int zellgröße)
{
int spalte = xPixel / zellgröße;
int zeile = yPixel / zellgröße;
Point pRet = new Point(spalte, zeile);
return pret;
}
}
Aufruf:
Point aktSpalteZeile = All.umwandeln(evt.getX(), evt.getY(), 36);