ChristophTutorials - (Video)Tutorialseite und IT-Blog

Zitat der Woche

Früher hatten wir die spanische Inquisition. Jetzt haben wir die Kompatibilität.
- Herbert Klaeren

Letzte Artikel

Zufällige Artikel

Verzeichnisse

Blogverzeichnis - Blog Verzeichnis bloggerei.de Blogverzeichnis Blog Verzeichnis Blog Top Liste - by TopBlogs.de Blog Button
Datenschutzerklärung
Impressum
Java - Variablen - Primitive - 22.03.2011
Variablen in der Programmierung sind etwas völlig anderes, als die in der Mathematik. Sie dienen dazu verschiedene Arten von Werten zu Speichern. Es gibt Variablentypen für Ganzzahlen, Kommazahlen, Zeichen und Zeichenketten. In diesem Tutorial wird zunächst nur der Umgang mit den sogenannten primitiven Datentypen erklärt. Das sind alle eben aufgezählten, außer den Variablen für Zeichenketten.
Variablen am Beispiel von int
Beginnen wir mit den Ganzzahlen. Der Variablentyp dafür heißt int (Kurzform von Integer). Um einen Wert speichern zu können muss eine Variable erst einmal erzeugt werden. Das Erzeugen nennt sich Deklarieren. Dabei wird im Speicher Platz für die Variable reserviert. Außer einem Typ hat eine Variable auch noch eine Name. So könnte die Deklaration einer Integer-Variable aussehen:
int EineVariable;
Erst kommt der Variablentyp, dann durch ein oder mehrere Leerzeichen getrennt, der Variablenname und zu Schluss kommt natürlich das Semikolon.

Die Variable soll natürlich auch einen Wert erhalten. Der Variablenname und der Wert werden durch ein Gleichheitszeichen getrennt und es wird natürlich wieder mit einem Semikolon abgeschlossen:
int EineVariable; //Erzeugen der Variable
EineVariable = 5; //Wertzuweisung
Ich nutzte Kommentare um es zu verdeutlichen.

Man kann den Wert auch schon direkt bei der Deklaration zuweisen:
int EineVariable = 5;
Ausgeben und Rechnen
Es wäre natürlich langweilig, wenn man nicht mit Variablen rechnen und sie nicht einmal ausgeben könnte. Wie kennen aus dem Grundlagen-Tutorial schon den Befehl zum Ausgeben von Werten. Wir erzeugen also eine Variable und geben sie direkt aus:
public class AusgebenEinesInt {
	public static void main(String[] args) {
                int Ausgabe = 123;
                System.out.println(Ausgabe);
        }
}
Nun wollen wir ein wenig rechnen. Dafür gelten die üblichen Grundrechenoperatoren, nur "Geteilt" wird als "/" und "Mal" als "*" geschrieben. Es gilt Punkt- vor Strichrechnung und man kann Klammern setzen:
public class AusgebenEinesInt {
	public static void main(String[] args) {
                int ErsterWert;
                int ZweiterWert = 132;
                int DritterWert = 50;

                ErsterWert = ZweiterWert+DritterWert;
                System.out.println(ErsterWert); //182

                ZweiterWert = DritterWert*ErsterWert;
                System.out.println(ZweiterWert); //9100

                System.out.println(ZweiterWert-ErsterWert*2); //8736

                System.out.println((ZweiterWert+100)-DritterWert); //9150
        }
}
long, short und byte
Die Datentypen long, short und byte nehmen ebenfalls Ganzzahlen auf, jedoch können sie größere oder kleinere Zahlen aufnehmen und verbrauchen mehr oder weniger Speicherplatz.

Ein byte belegt, welch eine Überraschung, ein byte und kann Zahlen von -128 bis 127 aufnehmen. Ein short nimmt 2 byte ein und kann Zahlen im Bereich von -32.768 bis 32.767 speichern. Der eben schon genutzte int nimmt 4 byte ein und Speichert Zahlen von -2.147.483.648 bis 2.147.483.647. Ein long benötigt 8 byte und nimmt Zahlen von -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807 auf. Die Zuweisung ist fast dieselbe.

Ein wichtiger Unterschied, wenn man einen long benötigt ist, dass man ein l oder L hinter die Zahl schreiben muss, da sie sonst zu erst als int aufgefasst und dann konvertiert wird, was bei großen Zahlen zu Fehlern führt. Hier die Initialisierung von byte-, short- und long-Variablen:
byte a = 25;
short b = 1500;
long c = 411372036854005804L;
float und double
Die Variablentypen float und double können Kommazahlen speichern. Ein float belegt 4 byte, wie ein int, ein double belegt 8 byte, wie ein long. Die ganzen Speicherbelegungen muss man sich übrigens nicht unbedingt merken. Der Umgang ist ähnlich, wie mit den Ganzzahltypen. Wenn man sicher gehen will, dass ein float verwendet wird, muss man nun ein f oder F hinter die Zahl setzen. Das ist heute jedoch, genauso, wie die Nutzung kleinerer Datentypen als int nicht mehr nötig, da es genug Speicher gibt. Statt einem Komma wird natürlich der in Amerika übliche Punkt verwendet. Nun wieder die Initialisierung der Variablen:
float f = 98.349f;
double d = 3249.234823;
Weitere Operatoren
Häufig muss man eine Variable um einen bestimmten Wert vervielfachen oder etwas hinzu addieren. Dafür gibt es noch verkürzte Schreibweisen:
public class KurzeRechnung {
	public static void main(String[] args) {
                int EinWert = 100;
                int ZweiterWert = 55;

                EinWert += ZweiterWert;
                //EinWert = EinWert + ZweiterWert;
                System.out.println(EinWert); //155

                ZweiterWert *= ErsterWert;
                //ZweiterWert = ZweiterWert * ErsterWert;
                System.out.println(ZweiterWert); //8525

                EinWert -= ZweiterWert;
                //EinWert = EinWert - ZweiterWert;
                System.out.println(EinWert); //-8370

                ZweiterWert /= ErsterWert;
                //ZweiterWert = ZweiterWert / ErsterWert;
                System.out.println(ZweiterWert); //-1
        }
}
Häufig muss man eine Variable auch um 1 hoch zählen oder 1 abziehen. Das sieht dann folgendermaßen aus:
public class plusMinusEins {
	public static void main(String[] args) {
                int EinWert = 100;
                
                EinWert++; //EinWert = EinWert + 1;
                System.out.println(EinWert); //101

                EinWert--; //EinWert = EinWert - 1;
                System.out.println(EinWert); //100
        }
}
Wahrheitswerte
In der Programmierung werden auch manchmal Wahrheitswerte gebraucht. Der dafür nötige Typ heißt boolean und kann die Werte true für wahr und false für falsch annehmen. Ein kurzes Beispiel:
public class wahrUndFalsch {
	public static void main(String[] args) {
                boolean Wahrheit = true;
                System.out.println(Wahrheit); //true

                Wahrheit = false;
                System.out.println(Wahrheit); //false
        }
}
Zeichen
Auch Buchstaben, Ziffern und sonstige Zeichen lassen sich speichern. Das funktioniert wieder sehr ähnlich. Das zu speichernde Zeichen wird jedoch in einfache Anführungszeichen (') gesetzt. Zum Beispiel so:
public class zeichen {
	public static void main(String[] args) {
                boolean einZeichen = 'a';
                System.out.println(einZeichen); //a
        }
}
Gültige Variablenbezeichner
Der Variablenname muss mit einem Groß-, Kleinbuchstaben, Dollarzeichen oder Unterstrich beginnen. Dann dürfen zusätzlich auch Ziffern folgen. Es sind auch Umlaute erlaubt.

Kommentare:

- kein Kommentar -
Um einen Kommentar zu schreiben ist eine Anmeldung nötig.