Bezeichner, Variablen, Konstanten


Was ist ein Bezeichner?

Ein Bezeichner (Identifier) ist ein Name für ein Programmteil. Um ein Programm schreiben zu können, muss es einen Namen bekommen. Dieser Name, den das Programm erhält, nennt sich Bezeichner. Aber nicht nur das Programm benötigt einen Namen, wenn Sie im weiteren Verlauf dieses Lehrgangs lernen, mit Variablen, Konstanten und Methoden zu arbeiten, müssen auch diese einen eindeutigen Bezeichner (Namen) erhalten.

Regeln zur Wahl von Bezeichnern

Bei der Kreation von Bezeichnern sind Ihnen fast keine Grenzen gesetzt. Eingeschränkt wird Ihr Ideenreichtum von zwei Regeln.

1. Bezeichner müssen mit einem der Zeichen ‘a‘…‘z‘ oder ‘A‘…‘Z‘ oder ‘_‘ oder ‘$‘ beginnen, alle anderen Zeichen sind nicht zulässig.

2. Bezeichner dürfen an keiner Stelle Leerzeichen oder Sonderzeichen enthalten. Das besondere an Java und einigen wenigen anderen Programmiersprachen ist, dass auch Buchstaben aus anderen Alphabeten verwendet werden dürfen. Dadurch ist es auch möglich, die deutschen Umlaute ‘ä‘,‘ü‘ und ‘ö‘ bei der Erstellung von Bezeichnern zu verwenden.

Weiterhin sollten Sie beachten, dass die Programmiersprache Java zwischen Groß- und Kleinschreibung unterscheidet. Dies bedeutet, dass die Wörter Bundeswehrsoldat und BundeswehrSoldat zwei verschiedene Bezeichner sind. Diese Eigenschaft wird als case-sensitive bezeichnet. Dies sorgt zum einen für eine Vielzahl von weiteren Möglichkeiten von Bezeichnern, zum anderen bedeutet dies, dass Sie beim Schreiben Ihrer Bezeichner auf diesen Punkt ein besonderes Augenmerk richten müssen. Sollten Sie zwei Bezeichner gewählt haben, die sich nur in der Groß- / Kleinschreibung unterscheiden, kann dies leicht zur Verwirrung und somit zu Fehlern führen. Prinzipiell sollten Sie die Bezeichner so wählen, dass Sie über den Bezeichner auch erfahren können, was hinter ihm steckt, z. B. MwSt für eine Variable, die einen Mehrwertsteuerwert beinhaltet. Variablen sollten immer selbsterklärend sein, dies trägt zur besseren Lesbarkeit Ihres Programms, auch für Sie selbst, bei.

Reservierte Bezeichner

Neben den oben genannten Einschränkungen zur Schaffung eines Bezeichners gibt es noch einen wichtigen Punkt, den Sie bei der Entfaltung Ihrer Phantasie beachten müssen. Bezeichner dürfen kein sogenanntes reserviertes Wort sein. Ein reserviertes Wort ist ein Bezeichner, der bereits von der Programmiersprache Java verwendet wurde. Da es eine Vielzahl von reservierten Wörtern gibt, macht es an dieser Stelle keinen Sinn, diese auswendig zu lernen. Sie werden im Laufe des Seminars die wichtigsten reservierten Wörter kennenlernen. Um Ihnen schon im Vorfeld einen Überblick zu verschaffen, finden Sie hier eine Liste der in Java reservierten Wörter:

abstract	const	final	int	public	throw
assert	continue	finally	interface	return	throws
boolean	default	float	long	short	transient
break	do	for	native	static	true1)
byte	double	goto	new	strictfp	try
case	else	if	null1)	super	void
catch	enum	implements	package	switch	volatile
char	extends	import	private	synchronized	while
class	false1)	instanceof	protected	this	

Diese reservierten Wörter stellen konstante, vordefinierte Werte dar und werden als Literale bezeichnet.

Kommentare

Kommentare sind bei der Programmierung von besonderer Bedeutung, sie können sogar wichtiger sein als das eigentliche Programm. Selbst wenn Sie Programme aufrufen, die Sie erst vor ein paar Tagen erstellt haben, dann werden Sie i. d. R. ohne Kommentare nicht mehr sagen können, was Sie programmiert haben und vor allen Dingen nicht, warum sie es so programmiert haben, wie es dort steht. Von daher sollten Sie auch bei kleinen Programmen stets darum bemüht sein, Kommentare zu schreiben. Kommentare werden vom Compiler / Interpreter nicht ausgewertet, also nicht übersetzt.

Im Allgemeinen wird zwischen einzeiligen Kommentaren und Kommentarblöcken unterschieden. Wie diese erstellt werden, zeigt Ihnen der nächste Abschnitt.

Einzeilige Kommentare

Um einen einzeiligen Kommentar einzufügen, bedienen Sie sich des // (Doppelslash). Alle Zeichen in einer Zeile die nach // stehen, werden als Kommentar gewertet. In der nächsten Zeile ist diese Eigenschaft wieder aufgehoben.

Beispiel:

// Dies ist ein Kommentar

System.out.println ("R2D2") ; //Das hinter dem Doppelslash auch,

// das davor nicht

Kommentarblöcke

Um einen Kommentarblöcke einzufügen, bedienen Sie sich der Zeichenkombinationen /* für den Beginn und */ für das Ende des Kommentarblocks. Alles was sich nun innerhalb dieser Markierungen befindet, gehört zu einem Kommentar.

Beispiele:

	Kommentarblöcke:
	/*	Das ist ein
		Kommentarblock
        */

	/* Das ist auch ein Kommentarblock */ 

Literale

Literale ist der Sammelbegriff für alle „festen“ Werte, die Sie in ihrem Sourcecode eingeben. Hierzu zählen Wahrheitswerte, wie die reservierten Wörter true und false, sowie Zeichen und Zahlen. Zu beachten ist dabei, dass für Gleitkommawerte als Dezimaltrennzeichen der Punkt verwendet wird und nicht, wie in Deutschland sonst üblich, das Komma.

Beispiel:

3.14 // richtig
3,14 // falsch

Numerische Literale können vorzeichenbehaftet sein. Um einen negativen Wert anzugeben, wird ihm das – Zeichen vorangestellt. Positive Werte können mit einem + Zeichen versehen werden, dies ist jedoch nicht nötig, da Programmiersprachen numerische Werte im Allgemeinen ohne explizites Vorzeichen als positiv betrachten. Neben der „normalen“ dezimalen Darstellung können Gleitkommawerte auch in der Exponentialschreibweise angegeben werden. Hierbei sind zwei unterschiedliche Schreibweisen möglich. Ein Wert wie 8,85 * 10-12 kann in der folgenden Schreibweise angegeben werden.

Beispiele:

8.85e-12 oder

8.85E-12

Variablen

Bei Berechnungen werden in einem Programm häufig Formeln verwendet, um einen Wert in einen anderen Wert umzurechnen, z. B. Temperaturumrechnungen von °Celsius nach °Fahrenheit. Um nun jede mögliche Temperatur von °C in °F umrechnen zu können, werden innerhalb der Formeln Variablen benutzt. Variablen sind Platzhalter, die, wie der Name es schon ausdrückt, variable Werte annehmen können. Dies dürfte Ihnen bereits aus der Schulmathematik bekannt sein. Im Bereich der Programmierung repräsentieren diese Platzhalter, die durch einen Bezeichner angesprochen werden können, Speicherbereiche im RAM. Diese Speicherbereiche haben eine bestimmte Größe, die Sie durch die Wahl der Datentypen, die im folgenden Abschnitt erläutert werden, beeinflussen können.

Rechnerintern stehen die Bezeichner für Speicheradressen im Arbeitsspeicher.

Durch die Eigenschaft, dass die Inhalte der Arbeitsspeicherzellen nicht fest eingebrannt sind, sondern immer neu beschrieben werden können, sind diese als Depot für variable Werte gut geeignet. Ändert sich ein Wert, dann wird der Speicherbereich mit dem neuen Wert gefüllt. Um Variablen nutzen zu können, müssen Sie zunächst definiert werden. D. h. es muss bestimmt werden, welchen Datentyp sie haben. Dies ist notwendig, damit der Computer weiß welche Datenstruktur er in die Speicherzellen eintragen muss.

Definitionsvorschrift:

Datentyp Bezeichner; // Definitionsvorschrift

Um mehrere Variablen des gleichen Datentyps zu definieren, können sie weitere Bezeichner, durch Komma getrennt, anfügen:

Definitionsvorschrift: mehrere Bezeichner vom gleichen Datentyp Datentyp Bezeichner_1, Bezeichner_2, … ;

Die Definition muss vor der Stelle im Programm erfolgen, an der die Variable das erste Mal genutzt wird.

Um mit Variablen rechnen zu können, müssen diese Variablen einen Wert zugewiesen bekommen. Diesen Vorgang der erstmaligen Wertzuweisung wird Initialisierung genannt. Ist eine Variable nicht initialisiert, kommt es zu Fehlern, da im Arbeitsspeicher, vor der Initialisierung, noch der „Datenmüll“ von anderen Programmen im Speicherbereich eingetragen ist. Daher sollten Sie eine Variable direkt nach der Definition stets mit einem Wert initialisieren, dann sind sie auf der sicheren Seite. Der Gültigkeitsbereich einer Variablen definiert sich durch den Codeblock, in dem die Variable definiert wurde. Ein Codeblock beginnt mit einer geschweiften Klammer und endet ebenso.

Beispiel:
{
	{
	   Hier wird die Variable definiert
	   und in Folge verwendet
        }
        Hier ist die Variable unbekannt
}

Elementare Standard-Datentypen

In jeder Programmiersprache stehen Ihnen elementare Standard-Datentypen zur Verfügung. Hier sprechen wir von den primitiven Datentypen. Wie diese Typen bezeichnet werden, ist bei den einzelnen Programmiersprachen zwar unterschiedlich, die Bedeutung ist jedoch sehr ähnlich. Diese Typen werden in Gruppen unterteilt. Bei den numerischen Datentypen, also den Gleitkommazahlen und den Zahlen ohne Nachkommaanteil, finden sich regelmäßig mehrere Datentypen wieder. Dies bedeutet, dass bei der Definition einer Variablen, die Zahlen ohne Nachkommaanteil aufnehmen soll, die Möglichkeit besteht, zwischen verschiedenen Datentypen auszuwählen. Warum reicht nicht ein Datentyp für alle Zahlen ohne Nachkommaanteil? Die Antwort darauf ist recht einfach. Es gibt Variablen, bei denen der Programmierer vor der Laufzeit des Programms bereits weiß, dass diese Variablen nur Werte bis zu einer bestimmten Größe annehmen können. Daher wäre es verschwenderisch, für diese Variablen Speicherbereiche zu belegen, die doppelt oder mehrfach so groß sind, wie eigentlich notwendig. Bei der Wahl des richtigen Datentyps bei Gleitkommazahlen richtet sich die Entscheidung nicht nur nach der möglichen Größe der Gleitkommazahl, sondern auch danach, wie genau, das heißt mit wie vielen Nachkommastellen, eine Gleitkommazahl dargestellt werden soll. In den folgenden Abschnitten werden die Datentypen, nach Gruppen sortiert, erläutert.

Die Ganzzahl-Datentypen

Als Ganzzahl-Datentyp werden die Datentypen bezeichnet, die nur Zahlen ohne Nachkommaanteil aufnehmen können. Dabei existieren, je nach Programmiersprache, Datentypen, die nur positive Werte incl. Null, aufnehmen können, sowie Datentypen, die sowohl negative als auch positive Werte aufnehmen können. Bei der Programmiersprache Java existieren vier verschiedene Ganzzahl-Datentypen, die sowohl negative als auch positive Werte aufnehmen können. In der folgenden Tabelle werden diese mit ihren Zahlenbereichen und dem Speicherbedarf, den eine Variable dieses Typs hat, aufgelistet.

Datentyp	Wertebereich	Speicherbedarf
byte	          -128 … 127	1 Byte
short	        -32768 … 32767	2 Byte
int	-2.147.483.648 … 2.147.483.647	
                                4 Byte
long-9.223.372.036.854.775.808 … 9.223.372.036.854.775.807	
                                8 Byte

Anzumerken ist noch, dass eine Ganzzahl immer exakt dargestellt wird, d. h. es treten keine Rundungsfehler auf.

Bei der Verwendung von Ganzzahl-Literalen verwendet Java standardmäßig das Format int, d. h. im Arbeitsspeicher werden 4 Byte zur Speicherung benötigt. Wenn Sie eine Ganzzahl-Literale als long, also mit 8 Byte benötigen, dann müssen Sie dem Wert ein L nachstellen. Dies kann auftreten, wenn Sie einer Variablen vom Typ long einen Wert zuweisen wollen.

Beispiel:

4788L // Diese Zahl ist ein Literal vom Datentyp long

Die Gleitkomma-Datentypen

Als Gleitkomma-Datentyp werden die Datentypen bezeichnet, die Zahlen mit Nachkommaanteil aufnehmen können. Dabei existieren, je nach Programmiersprache verschieden viele Gleitkomma-Datentypen. Bei der Programmiersprache Java existieren zwei verschiedene Gleitkomma-Datentypen. In der folgenden Tabelle werden diese mit ihrer Genauigkeitsdarstellung und dem Speicherbedarf aufgelistet.

Datentyp	Genauigkeit	Speicherbedarf
float	          7 Stellen	4 Byte
double	         15 Stellen	8 Byte 

Standardmäßig wird der Datentyp double verwendet, da die derzeit vorhanden Computer über ausreichend Arbeitsspeicher verfügen. Weiterhin entstehen bei der Verwendung von float als Datentyp zu große Rundungsfehler.

Der Datentyp boolean

Bei diesem Datentyp handelt es sich um die Darstellung von Wahrheitswerten. Hierbei kann eine Variable vom Datentyp boolean zwei Werte annehmen: true oder false. In anderen Programmiersprachen kann der Wert true auch über die Ziffer 1 und der Wert false über die Ziffer 0 dargestellt werden, dies ist bei Java nicht möglich.

Zeichencodes, ASCII, ANSI, Unicode-System

Bevor im nächsten Abschnitt der Datentyp char erläutert wird, ist es zunächst notwendig, den Begriff Zeichencodes zu erklären. Zeichencodes sind Abbildungen von Zeichen auf Zahlen. D. h., in Zeichencodes werden die einzelnen Zeichen „durchnummeriert“ auf Zahlen abgebildet. Wenn in Programmen Zeichen verwendet werden, stellt der Computer diese intern durch eine Zahl dar, da er nur mit Nullen und Einsen arbeiten kann. Soll ein Zeichen auf dem Bildschirm angezeigt werden, dann wird die Zahlenkombination, die der Computer verwendet, in einer Tabelle gesucht und das entsprechende Zeichen dargestellt. Bekannte Zeichencodes sind der ASCII-Code (American Standard Code for Information Interchange) und der ANSI-Code (American National Standards Institute). Beide Codes sind sehr ähnlich. Der ASCII-Code, ein amerikanischer Normcode auf 7-Bit-Basis, wurde, da die Darstellung meist über ein Byte erfolgte, später auf 8 Bit erweitert. Der Standard ASCII-Code ist jedoch immer noch der 7-Bit-Code. Über diesen Code können 27 = 128 Zeichen abgebildet werden. Neben Zeichen zur Darstellung von Buchstaben oder Zahlen, enthält der ASCII-Code noch Zeichen zur Steuerung. Hierunter fallen alle Zeichen bis zur Ziffer 32. Diese Zeichen können u. a. zur Steuerung von Druckern verwendet werden. Der ANSI-Code unterscheidet sich nur in einigen Zeichen zum ASCII-Code, die Zeichen mit den Nummern 32 – 127 des ANSI-Codes sind identisch mit denen im ASCII-Code. In den Werten 128 bis 255 des ANSI-Codes finden sich etliche Sonderzeichen wie deutsche Umlaute, französische Akzentzeichen oder das spanische N. Der ANSI-Code wurde von der amerikanischen Nationalen Normierungsbehörde normiert und trägt daher den Namen dieser Behörde. Heute wird der ASCII-Code regelmäßig von Nicht-Windows-Programmen, der ANSI-Code hingegen von Windows und Windows-Programmen verwendet. Bei einer eventuell notwendigen Konvertierung vom ANSI-Code in den ASCII-Code können Probleme auftreten, da bestimmte Zeichen im ASCII-Code nicht enthalten sind.



Neben den Zeichencodes existiert noch ein System, das in den letzten Jahren bei der Darstellung von Zeichen an Bedeutung gewonnen hat. Bei dem Unicode-System handelt es sich nicht um einen eigenständigen Zeichencode, sondern um eine Vereinigung einer Vielzahl von Zeichencodes aus verschiedenen Schriftkulturen. Er enthält sowohl unsere normalerweise als lateinisch bezeichneten Schriftzeichen als auch griechische, hebräische, arabische und viele weitere. Durch dieses System ist es dem Programmierer leicht möglich, Software für die unterschiedlichsten Schriftkulturen herzustellen, ohne die Laufzeitumgebung der Schriftkultur anzupassen. Da dieses System mehr als 255 Zeichen umfasst, benötigt es zur Abbildung eines einzelnen Zeichens zwei Byte pro Zeichen im Arbeitsspeicher. Wenn Sie bei MS-Word™ den Menüpunkt Einfügen-Symbol anwählen, können sie sich die Zeichen des UNICODES ansehen.

Der Datentyp char

Nachdem nun im vorhergehenden Abschnitt erläutert wurde, was ein Zeichencode ist, kommen wir nun zum Datentyp char. Dieser Datentyp dient dazu, einzelne alphanumerische Zeichen aufzunehmen. Je nach Programmiersprache und verwendetem Zeichencode ist der Speicherbedarf eines Zeichens unterschiedlich groß. In Java beträgt der Speicherbedarf immer zwei Byte, da die Programmiersprache Java zur Abbildung von Zeichen das Unicode-System verwendet.

Literale vom Datentyp char werden in einzelne Hochkommata ' ' gesetzt.

Beispiel: 'A' // dies ist ein Literal vom Datentyp char

Wichtig ist, dass der Datentyp char immer genau ein Zeichen aufnehmen kann. Wenn Sie mehr als ein Zeichen darstellen wollen, handelt es sich um einen String. Dieser Datentyp wird im nächsten Abschnitt erklärt.

Weiterhin müssen Sie eine Unterscheidung zwischen einer Zahl 1 und dem Zeichen '1' treffen. Die Zahl 1 wird im Computer intern auch als 1 dargestellt, das Zeichen '1' wird intern durch die Zahl 49 dargestellt (siehe ASCII-Code-Tabelle). Die Folge aus dieser Unterscheidung ist, dass eine Addition von '1' + '1' nicht zwei ergibt, sondern 98. Diese Zahl entspricht dann dem Zeichen 'b'. Zur Steuerung von Ausgaben auf Drucker oder Bildschirm können so genannte Escape-Sequenzen genutzt werden. Eine Escape-Sequenz beginnt immer mit dem Zeichen (Backslash), gefolgt von einem oder mehreren Zeichen. Der Computer übersetzt, sobald er auf einen trifft, die direkt folgenden Zeichen als ein einziges Zeichen.

In der folgenden Tabelle finden Sie die gängigsten Escape-Sequenzen. Diese werden auch von anderen Programmiersprachen wie C und C++ verwendet.

Escape -Sequenz Steuersignal
\n Neue Zeile
\t Tabulator
\b Backspace
\" Anführungszeichen
\' Hochkomma
\ \ Backslash
\u…
Bsp.: u0040 Ein spezielles Zeichen. Das Zeichen wird über den HEX-Code des Unicode-Systems angegeben. Das Ergebnis ist das Zeichen @.

Der Datentyp String

Beim Datentyp String handelt es sich, im Gegensatz zu den vorgenannten, um keinen primitiven Datentyp, da er mehr kann, als nur Werte im Arbeitsspeicher aufzunehmen. Dieser Datentyp dient zur Aufnahme von Zeichenketten. Diese Zeichenketten sind eine Aneinanderreihung von einzelnen Zeichen, wobei auch ein einzelnes Zeichen vom Datentyp String sein kann. Ein Literale vom Datentyp String wird in Anführungszeichen gesetzt:

"Auto" // Das ist ein String.
"A" // auch das ist ein
String. Wichtig ist, dass ein String kein char ist, auch nicht wenn nur ein Zeichen im String steht.

Zusammenfassendes Beispiel:

Im folgenden Beispiel wird zu jedem hier behandelten Datentyp eine Variable definiert.

public static void main (String[] args)
{		
// Definition einer Variablen vom … 
	byte a ; 	// Datentyp byte
	short b;	// Datentyp short
	int c ;	// Datentyp int
	long d ;	// Datentyp long
	float e ;	// Datentyp float
	double f;	// Datentyp double
	char g;	// Datentyp char
	boolean h;	// Datentyp boolean
	String i;	// Datentyp String
}

Zuweisungen

Nachdem Sie im vorhergehenden Abschnitt die einzelnen Datentypen kennengelernt haben, ist es nun an der Zeit, mit diesen Variablen zu arbeiten. Als erstes soll nun erläutert werden, wie Sie den Variablen Werte zuweisen können. Nach der Definition einer Variablen ist deren Inhalt zunächst noch unbestimmt. Würde ein Programmierer versuchen, diesen Inhalt auszugeben, bekäme er eine Fehlermeldung. Um eine solche Fehlermeldung zu vermeiden, muss den Variablen vor dem ersten Gebrauch ein Wert zugewiesen werden. Diese erste Wertzuweisung wird als Initialisierung bezeichnet. Eine Wertzuweisung erfolgt nach folgender Syntax:
Variablenbezeichner = Ausdruck ;
Dabei wird dem Variablenbezeichner über das Zuweisungsoperator = der Wert des Ausdrucks zugewiesen. Ein Ausdruck kann dabei ein Literal, eine andere Variable oder eine Anweisung (Statement) sein.

Beispiel:
double zahl ; // Typdefinition
zahl = 312.74 ; // Initialisierung der Variablen Zahl mit einem Wert

Da es sich bei dem Bezeichner zahl um eine Variable handelt, kann der Inhalt nach der ersten Zuweisung, im weiteren Verlauf des Programms, durch einen anderen Wert überschrieben werden. Der Wert, der vor dem Überschreiben in dem Bezeichner enthalten war, geht dabei verloren.

Beispiel:

double zahl; // Typdefinition
zahl = 312.74 ; // Initialisierung der Variablen mit dem Wert 312.74
zahl = 741.28 ; // Hier wird der Inhalt der Variablen zahl mit dem Wert 741.28 überschrieben

Um den Vorgang des Initialisierens nicht zu vergessen, ist es gängig, bereits bei der Definition der Variablen die erste Zuweisung vorzunehmen.

Beispiel:

double zahl = 312.74 ; // Typdefinition und Initialisierung einer Variablen in einer Anweisung

Im Folgenden werden Ihnen die Zuweisungen zu allen primitiven Datentypen und dem Datentyp String am Beispiel von Literalen gezeigt.

public static void main (String[] args)
{	// Definition und Initialisierung einer 
	// Variablen vom … 
	byte a=8 ;              // Datentyp byte
	short b=8;              // Datentyp short
	int c=8 ;               // Datentyp int
	long d=8L ;             // Datentyp long
	float e=1.1F ;          // Datentyp float
	double f=1.1;           // Datentyp double
	char g= ‘A‘ ;           // Datentyp char
	boolean h=true;         // Datentyp boolean
	String i= "Ein String";	// Datentyp String
}

Konstanten

In Programmen werden oft Werte benötigt, die sich nicht ändern. Diese Werte werden als Konstanten bezeichnet. Ein typisches Beispiel für eine Konstante ist die Zahl π (pi), die den Wert 3.14159 … hat. Um diese Zahl nicht jedes Mal bei Berechnungen zu schreiben, bedient sich der Programmierer der Definition einer Konstanten. Eine Konstanten-Definition unterscheidet sich dabei nur unwesentlich von der Definition einer Variablen. Wie Sie sich erinnern, sieht die Definition einer Variablen wie folgt aus:

Datentyp Bezeichner; // Definition einer Variablen

Soll nun eine Konstante definiert werden, wird das Wort final der Definition vorangestellt.

final Datentyp Bezeichner; // Definitionsvorschrift einer Konstanten

Üblicherweise wird auch hier bei der Definition die Initialisierung vorgenommen.

Beispiel:

public static void main (String[] args)
{	// Definition und Initialisierung einer 
	// Konstanten
	final double pi = 3.1415 ;// Die Konstante pi 
}

Die Konstante pi kann nun überall im Programm verwendet werden, ohne den Zahlenwert jedes Mal schreiben zu müssen.

Wichtig: Nach der Initialisierung, wobei es egal ist, ob dies bei der Definition geschieht oder im weiteren Verlauf des Programms, kann einer Konstante kein anderer Wert zugewiesen werden.