s01 – Variablen

 

Variablen dienen dazu, Daten zu speichern. Da es verschiedene Arten von Daten gib (z.B. Zahlen, Text, …), muss es auch verschiedene Arten von Variablen geben. Jede Variable kann genau einen Wert abspeichern.
In Java muss man dem Computer zuerst mitteilen, dass man im weiteren Verlauf des Programmes eine Variable benutzen möchte. Die Syntax für diese “Mitteilung” ist:

Variablentyp Variablenname;

Um der Variable später einen Wert zuzuweisen, benutzt man die folgende Syntax:

Variablenname = Wert;

Boolsche Variablen

Eine Boolsche Variable kann entweder den Wert “true” oder den Wert “false” enthalten. Der Speicherplatz, den eine Boolsche Variable belegt, ist daher nur ein Bit.

Deklaration einer Boolschen Variable:

boolean bName;

Zuweisung von Werten:

bName = true;

Beispiele zum Umgang mit Boolschen Variablen:

boolean b1;		// Variablen werden nur deklariert
boolean b2, b3;		// Zwei Variablen werden deklariert
boolean b4 = true;	// Variable wird deklariert und gleich initialisiert
boolean b5 = false, b6 = true; // Zwei Variablen werden
			//deklariert und initialisiert

b1 = true;	// Variable wird initialisiert
b2 = b1;	// Variable wird initialisiert mit dem gleichen Wert wie b1
b3 = !b1;	// Variable wird initialisiert mit dem gegenteiligen Wert von b1

b4 = !b4;	// b4 war true, wird nun zu false

Logische Operatoren

mit boolschen Variablen können Logische Operationen realisiert werden.
Hierfür benutzt man die folgenden Operatoren:

Indifferenz (==)
Beispiel:

boolean b1 = 4 == 5; // b1 wird der Wert false zugewiesen, da nicht 4 == 5 gilt
boolean b2 = false;
boolean b3 = b1 == b2; // b3 wird der Wert true zugewiesen, da b1 == b2 gilt

Differenz (!=)
Beispiel:

boolean b1 = 4 != 5; // b1 wird der Wert true zugewiesen, da 4 != 5 gilt
boolean b2 = false;
boolean b3 = b1 != b2; // b3 wird true zugewiesen, da b1 true und b2 false ist

Die weiteren logischen Operatoren benötigen andere Datentypen und werden daher im nächsten Abschnitt besprochen.

ganzzahlige Variablen

Integervariablen
Eine ganzzahlige Variable vom Typ Integer kann Zahlen im Bereich-2.147.483.648 bis+2.147.483.647 speichern. Dieser Bereich ergibt sich dadurch, dass für die Variable 4 Byte im Arbeitsspeicher benutzt werden. 4 Byte entsprechen 4*8 = 32 Bit.

Deklaration einer Integervariable:

int iName;

Zuweisung von Werten:

iName = 17;

Beispiele zum Umgang mit ganzzahligen Variablen und den vier Grundrechenarten:

int i1, i2;
int i3 = 5;

i1 = 8+2;	// i1 wird direkt der Wert 10 zugewiesen
i2 = i1-i3;	// i2 wird der Wert 10-5 = 5 zugewiesen

i3 = i1+3;	// i3 Wird der Wert 10+3 = 13 zugewiesen

i1 = i1+2; 	// i1 wird um den Wert 2 erhöht, also i1 = 12
i1 += 2;	// andere Art, i1 um 2 zu erhöhen, also i1 = 14
i1 ++;		// Möglichkeit, i1 um 1 zu erhöhen
++ i1;		// macht das gleiche wie i1 ++

i2 = i2 * 3;	// i2 wird mit 3 multipliziert, also i2 = 15
i2 *= 2;	// i2 wird mit 2 multipliziert, also i2 = 30
i2 /= 3;	// i2 wird durch 3 geteilt, also i2 = 10
i2 --;		// i2 wird um 1 verkleinert, also i2 = 9
-- i2;		// macht das gleiche wie i2 --, also i2 = 8
i2 -= 15;	// i2 = -7, Zahlen können auch negativ sein

i3 /= 2;	// i3 wird durch 2 geteilt (13 / 2 = 6,5)
	// es können aber nur ganze Zahlen gespeichert werden
	// daher werden die Nachkommastellen gelöscht: i3 = 6

Weitere logische Operationen mit ganzzahligen Variablen
< kleiner
> größer
<= kleiner oder gleich
>= größer oder gleich

Beispiele:

int i1 = 5, i2 = 7, i3 = 7;
boolean b1, b2, b3, b4;
b1 = i1 < 7;	// b1 wird der Wert true zugewiesen
b2 = i1 > i2;	// b2 wird der Wert false zugewiesen
b3 = i2 < i3;	// b3 wird der Wert false zugewiesen
b4 = i2 <= i3;	// b4 wird der Wert true zugewiesen

Verknüpfung von logischen Operationen
logische Operationen können verknüpft werden, wenn zum Beispiel gleichzeitig zwei Bedingungen oder mindestens eine von zwei Bedingungen gelten soll.
Für diesen Zweck gibt es die folgenden Operatoren:

&& logisches UND
|| logisches ODER

Beispiele:

boolean b1, b2, b3, b4;
b1 = true;
b2 = false;

b3 = (b1 &amp;amp;amp;amp;&amp;amp;amp;amp; b2)		// b3 wird der Wert false zugewiesen
b4 = (b1 || b2)		// b4 wird der Wert true zugewiesen

Tabelle:
true && true -> true
true && false -> false
false && true -> false
false && false -> false

true || true -> true
true || false -> true
false || true -> true
false || false -> false

long-Variablen
Bei vielen Berechnungen reicht der Wertebereich von normalen Integervariablen nicht aus. Daher benutzt man in diesem Fall stattdessen den Datentyp long, dessen Wertebereich-9.223.372.036.854.775.808 bis+9.223.372.036.854.775.807 ist.
Der Umgang mit long-Variablen erfolgt analog zu Ingeger-Variablen.

unsigned-Variablen
Wenn man nur mit positiven Zahlen arbeitet, kann man unsigned-Variablen nutzen. Es können dann zwar keine negativen, aber doppelt so große positiven Zahlen gespeichert werden.

short-Variablen
Um Speicherplatz zu sparen, kann man für Variablen, die ausschließlich kleine Werte annehmen sollen, short-Variablen benutzen. Dies führt aber häufig zu Inkompatibilitäten und wird wegen der heutzutage nahezu unbegrenzten Verfügbarkeit von Speicherplatz kaum noch benutzt.

Fließkommavariablen

float-Variablen
Ganze Zahlen reichen häufig nicht aus, wenn man zum Beispiel Divisionen genauer berechnen möchte. Zu diesem Zweck gibt es Fließkommavariablen vom Typ float.

Deklaration einer Fließkommavariable:

float fName;

Zuweisung von Werten:

fName = 3.14;

Beispiele zum Umgang mit Fließkommavariablen:

float f1, f2;
float f3 = 1.4, f4 = .5;	// wenn vor dem Komma eine Null steht,
		//kann diese weggelassen werden
f1 = f3 / 2.;	// Reelle Zahlen sollten, wenn sie ganzzahlig sind,
		//mit einem Punkt versehen werden
		// f1 = .7
f1 ++;		// f2 wird um 1 erhöht (funktioniert auch bei float), also f1 = 1.7
f2 = f3 ++;	// zwei Befehle kombiniert. f3 wird zuerst erhöht,
		// dann wird zugewiesen
		// also: f3 = 2.4, f2 = 2.4

Float-Variablen haben eine Größe von 4 Byte, es können daher nur etwa 7 Nachkommastellen gespeichert werden. Um genauere Werte speichern zu können, benutzt man den Datentyp double.

double-Variablen
Variablen vom Typ double haben die doppelte Genauigkeit verglichen mit der von float. Es werden 8 Byte verbraucht, daher können etwa 14 Nachkommastellen genau gespeichert werden.
Der Umgang mit double-Variablen erfolgt analog zu float.

Zeichen

Um einzelne Zeichen speichern zu können, nutzt man den Datentyp char.

Deklaration:

char cName;

Zuweisung von Werten:

cName = 'x';

Einzelne Zeichen sollten immer in char-Variablen gespeichert werden, statt in Strings (wäre auch möglich), da die char-Variable besser verarbeitbar ist und so zum Beispiel auch einfach in eine Zahl umgewandelt werden kann (das kleine a hat dabei zum Beispiel die Nummer 97).

Zeichenketten

Um ganze Zeichenketten speichern zu können, kann man entweder eine Reihung von char-Variablen, oder aber eine String-Variable benutzen.
Strings sind Variablen, die Zeichenketten speichern können. Sie ermöglichen den einfachen Umgang mit Text, denn da sie keine Grunddatentypen sondern Klassen sind, haben sie nützliche Funktionen.

Deklaration:

String sName;

Zuweisung von Werten:

sName = "asd";

Im Gegensatz zu einzelnen Zeichen wird hier nicht mit ‘…’ zugewiesen, sondern mit “…”.

Beispiele zum Umgang mit Strings:

String s1, s2;
String s3 = "hallo";
s2 = "welt";
s2 = " "+s2;	// es wird ein Leerzeichen vor die Zeichenkette gehängt
s1 = s3+s2;	// s3 = "hallo welt"
s2 = "17+23 = "+(17+23);	// s2 = "17+23 = 40"

Praktische Methoden der Klasse String:

  • int length()-gibt Anzahl der Zeichen zurück
  • boolean equals(String)-prüft auf Gleichheit
  • int indexOf-gibt die Position des übergebenen Zeichens zurück
  • charAt(int)-gibt Zeichen an der übergebenen Position zurück
  • String substring(int, int)-gibt Teilstring zwischen den beiden Positionen zurück
  • String toUpperCase()-gibt String als Großbuchstaben zurück
  • String toLowerCase()-gibt String als Kleinbuchstaben zurück

Für die formatierte Ausgabe enthält das Package API: java.text entsprechende fertige Klassen für Datum, Währung, Zahlen usw. länderspezifisch bereit.

Ähnliche Artikel

Kommentar verfassen