Bisher haben wir Java-Operatoren der fünf Operatorengruppen (arithmetisch, logisch, relational, bitweise und zuweisungsbasierend) behandelt, wobei jede dieser Gruppe mehrere Operatoren als Gruppenelemente enthält.
Die nun folgenden Operatoren lassen sich keiner dieser fünf Gruppen zuordnen. Sie werden daher als besondere Java-Operatoren bezeichnet.
Ein jeder dieser besonderen Operatoren nimmt in der Programmiersprache Java einen wichtigen Platz ein. Daher sollten sie jedem Java-Programmierer bestens vertraut sein.
In diesem Beitrag werden wir die folgenden besonderen Java-Operatoren behandeln:
- type-cast-Operator
- instanceof-Operator
- new-Operator
- Punkt-Operator
- Fragezeichen-Operator
- Operator für den Zugriff auf Array-Elemente
- Operator für das Aufrufen von Methoden
- Operator für die Verkettung von String-Objekten
Den sizeof-Operator gibt es in Java nicht, da die Länge aller Datentypen in Java exakt festgelegt ist. Er ist daher überflüssig.
Ebensowenig gibt es die beiden aus C bekannten * und & Operatoren. Der Dereferenzierungs-Operator * zur Dereferenzierung eines Zeigers und auch der Adress-Operator & zur Bestimmung der Adresse einer Variablen sind in Java nicht implementiert.
Auch der Komma-Operator von C wurde in Java nicht übernommen. Ihn findet man nur als Ausnahme im Initialisierungsteil der for-Schleife und bei der Variableninitialiserung, bspw. int a = 1, b = 2, c = 3;.
Besondere Java-Operatoren: Der type-cast-Operator
Der type-cast-Operator wird in Java zur expliziten Typumwandlung verwendet.
Er wird häufig benötigt, wenn der Compiler keine automatische implizite Typumwandlung vornimmt.
Dies ist bei einer Zuweisung von größeren an kleinere Datentypen der Fall und auch bei der gezielten Typumwandlung von Objekten.
Mit dem Ausdruck (type) a wird der Teilausdruck a in einen Teilausdruck vom type-Typ umgewandelt.
Zum Beispiel zahlByte = (byte) (256 / 4); oder zahlInt = (int) zahlLong;.
In der folgenden Beispielanwendung wird der type-cast-Operator jeweils für primitive und Referenz-Datentypen verwendet.
Beispiel type-cast-Operator in Java.
/*
* Beispielanwendung BesondereOperatoren in Java.
*/
public class BesondereOperatoren{
public static void main(String[] args) {
int a = 320;
byte b = 20;
byte c;
c = (byte) (a / b); // Explizite Typumwandlung
System.out.println("\na = " + a);
System.out.println("b = " + b);
System.out.println("c = a / b = " + c);
Object objStr = new String("String-Objekt mit Object-Typ Referenz");
String str;
str = (String) objStr;
System.out.println("\nobjStr: " + objStr);
System.out.println("str: " + str);
}
}
Bei der expliziten Typumwandlung aus Zeile 21 handelt es sich zwar um eine einschränkende Konvertierung, von der Vaterklasse Object in Richtung der abgeleiteten Klasse String. Aber um eine zulässige Typumwandlung, da das Objekt auf das die Referenz-Variable objStr referenziert eigentlich ein String-Objekt ist.
In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der oberen Beispielanwendung dargestellt.
Java type-cast-Operator – Ausgabe der Beispielanwendung
Eine ausführliche Beschreibung des type-cast-Operators und über das wichtige Thema Typumwandlung haben wir in den Beitrag: Typumwandlung bzw. Typkonvertierung (type casting) in Java gegeben.
Besondere Java-Operatoren: Der instanceof-Operator
Der instanceof-Operator benötigt zwei Operanden.
Mit ihm kann zur Laufzeit überprüft werden, ob ein Objekt eine Instanz einer bestimmten Klasse ist. Daher auch die Bezeichnung „instanceof“.
Man benutzt den instanceof-Operator zum Überprüfen, ob ein von einem Verweis referenziertes Objekt (1. Operand) zuweisungskompatibel zu einer bestimmten Klasse (2. Operand) ist.
Der zweite Operand muss immer eine Klasse sein.
Mit a instanceof ClassX wird also abgefragt, ob das Objekt a eine Instanz der Klasse ClassX oder einer ihrer Unterklassen (von ClassX abgeleitet) ist. Ist dies der Fall, so wird true zurückgegeben.
Der Compiler versucht das Ergebnis des Ausdrucks a instanceof ClassX bereits zur Compile-Zeit zu ermitteln.
Falls dies nicht möglich sein sollte, wird an dieser Stelle Code vom Java-Compiler generiert, damit die Instanceof-Überprüfung zur Laufzeit durchgeführt werden kann.
In der folgenden Beispielanwendung wird der instanceof-Operator für Object- und String-Instanzen verwendet.
Beispiel instanceof-Operator in Java.
/*
* Beispielanwendung BesondereOperatoren in Java.
*/
import java.util.Vector;
public class BesondereOperatoren{
public static void main(String[] args) {
boolean d;
String normalString = new String();
d = normalString instanceof Object;
System.out.println("\nIs normalString instance of Object: " + d);
d = normalString instanceof String;
System.out.println("Is normalString instance of String: " + d);
//d = normalString instanceof Vector; // Compilerfehler: inconvertible types,
// da Vector und String nicht direkt miteinander verwandt
Object normalObject = new Object();
d = normalObject instanceof Object;
System.out.println("\nIs normalObject instance of Object: " + d);
d = normalObject instanceof String;
System.out.println("Is normalObject instance of String: " + d);
Object objStr = new String("String-Objekt mit Object-Typ Referenz");
String str;
if (objStr instanceof String)
{
str = (String) objStr;
d = str instanceof Object;
System.out.println("\nIs str instance of Object: " + d);
d = str instanceof String;
System.out.println("Is str instance of String: " + d);
d = objStr instanceof Object;
System.out.println("\nIs objStr instance of Object: " + d);
d = objStr instanceof String;
System.out.println("Is objStr instance of String: " + d);
}
}
}
Zuerst wird der Verweis normalString vom String-Datentyp erstellt, dem ein String-Objekt zugewiesen wird. Anschließend wird überprüft, ob der Verweis normalString auf ein Objekt vom Typ Object referenziert, also ob normalString eine Instanz der Klasse Object ist.
Danach wird überprüft, ob normalString eine Instanz der Klasse String ist. Dies ist in beiden Fällen wahr.
Die Zeile 17 ist auskommentiert, da die Abfrage b = normalString instanceof Vector; einen Compilerfehler ergibt. Da die Klassen Vector und String nicht direkt miteinander verwandt sind. Die String-Klasse ist nicht von der Vector-Klasse abgeleiten.
In Zeile 20 wird der Verweis normalObject vom Object-Datentyp erstellt, dem ein Object-Objekt zugewiesen wird. Anschließend wird überprüft, ob der Verweis normalObject auf ein Objekt vom Typ Object referenziert, also ob normalObject eine Instanz der Klasse Object ist.
Danach wird überprüft, ob normalObject eine Instanz der Klasse String ist. Da dies nicht der Fall ist, wird vom instanceof-Operator der Wert false zurückgeliefert.
In Zeile 26 wird dem Verweis objStr vom Object-Datentyp ein String-Objekt zugewiesen, somit verweist objStr auf eine Instanz der String-Klasse.
In Zeile 31 wird dem Verweis str vom String-Datentyp ein String-Objekt mit Hilfe des type-cast-Operators zugewiesen. Die ist zulässig, da objStr auf eine Instanz der String-Klasse enthält.
Im Anschluss wir geprüft, ob objStr und str Instanzen der Klassen Object und String sind. Dies ist für alle vier Abfragen wahr. Siehe Textausgabe weiter unten.
In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der oberen Beispielanwendung dargestellt.
Java instanceof-Operator – Ausgabe der Beispielanwendung
Besondere Java-Operatoren: Der new-Operator
Der new-Operator wird in Java verwendet, um ein Objekt zu erzeugen. Ihm folgt immer ein Konstruktor einer Klasse, durch den das neue Objekt initialisiert wird.
Mit dem Ausdruck String a = new String("Hallo PLHQ."); werden die folgenden drei Schritte ausgeführt:
- 1 – Deklaration: Der Variable
awird der Objekttyp String zugewiesen. - 2 – Instanzierung: Mit Hilfe des new-Operators wird ein neues Objekt erzeugt.
- 3 – Initialisierung: Dem new-Operator folgt der Konstruktor der Klasse String, durch den das neue String-Objekt initialisiert wird.
Durch das Deklarieren einer Referenz-Variable wird noch kein Objekt erzeugt. Um dies zu tun, muss der new-Operator benutzt werden.
Bei einer alleinigen Deklaration wie z.B. String a; bleibt der Wert von a unbestimmt. Und zwar solange bis ein Objekt erzeugt und der Referenz-Variable zugewiesen wurde.
Bevor eine Referenz-Variable benutzt werden kann, muss ihr ein Objekt zugewiesen worden sein. Sonst erhält man einen Compiler-Fehler, da die Referenz-Variable ins Nichts zeigt.
Instanzieren einer Klasse – Erzeugen eines Objekts
Der new-Operator instanziert eine Klasse, indem er für ein neues Objekt Speicher reserviert und einen Verweis zu der Speicheradresse zurückliefert. Zudem ruft der new-Operator den Konstruktor des Objekts auf.
Hinweis: Die Formulierung „Instanzieren einer Klasse“ hat die gleiche Bedeutung wie „Erzeugen eines Objekts“. Eine Instanz einer Klasse ist gleichbedeutend mit einem Objekt vom Typ einer Klasse.
Dem new-Operator muss ein Argument folgen und zwar der Aufruf eines Konstruktors. Der Name des Konstruktors gibt an, welche Klasse zu instanzieren ist.
Der Rückgabewert des new-Operators, die Referenz auf das erzeugte Objekt, wird normalerweise einer Variablen zugewiesen:
String a = new String("Hallo PLHQ.");
Der Rückgabewert kann aber auch direkt in einem Ausdruck genutzt werden:
int laenge = new String("Hallo PLHQ.").length();
Abschließend kann gesagt werden, dass der new-Operator ein sehr wichtiger Operator in der Programmiersprache Java ist, auf den wir in späteren Beiträgen noch öfter eingehen werden.
Besondere Java-Operatoren: Der Punkt-Operator
Der Punkt-Operator (.-Operator) wird benötigt, um auf die Attribute von Objekten zugreifen zu können.
Neben den Objektattributen gibt es noch die statischen Attribute. Diese Attribute existieren nicht einmal pro Objekt, sondern nur einmal pro Klasse. Daher werden sie auch Klassenattribute oder Klassenvariablen genannt.
Möchte man auf ein Objektattribut (eine Instanzvariable) zugreifen, benötigt man eine Referenz auf das Objekt, über die mit dem Punkt-Operator auf das gewünschte Attribut zugegriffen wird:
Rectangle rect = new Rectangle(10,20, 50, 100);
int b = rect.width;
Möchte man auf ein Klassenattribut (eine Klassenvariable) zugreifen, wird keine Referenz auf ein bestimmtes Objekt benötigt. Stattdessen greift man über den Klassennamen auf das Klassenattribut Mithilfe des Punkt-Operators zu:
long c = StrictMath.PI;
In beiden Fällen wird als Rückgabewert der Wert des jeweiligen Attributs und als Rückgabetyp der Datentyp des jeweiligen Attributs zurückgegeben.
In der folgenden Beispielanwendung wird der Punkt-Operator für Instanz- und Klassenvariablen verwendet.
Beispiel Punkt-Operator in Java.
/*
* Beispielanwendung BesondereOperatoren in Java.
*/
import java.lang.StrictMath;
import java.awt.Rectangle;
public class BesondereOperatoren{
public static void main(String[] args) {
Rectangle rect = new Rectangle(10,20, 50, 100);
int xKoordinate = rect.x;
System.out.println("\nX : " + xKoordinate);
System.out.println("Y : " + rect.y);
System.out.println("Width : " + rect.width);
System.out.println("Height: " + rect.height);
double a = StrictMath.PI;
double b = StrictMath.E;
System.out.println("\nPI: " + a);
System.out.println("E : " + b);
int c = new Rectangle().width;
System.out.println("\nc: " + c);
}
}
Der Ausdruck in Zeile 25 erzeugt ein Rectangle-Objekt und holt sich sofort dessen Breite. Es wird die Default-Breite übergeben. Nachdem dieser Ausdruck ausgeführt wurde, liegt keine Referenz zu dem erzeugten Rectangle-Objekt mehr vor, da das Programm die Referenz nirgends gespeichert hat.
Das Rectangle-Objekt ist somit unreferenziert und der zugehörige Speicherplatz kann von dem Java Garbage Collector wieder aufgeräumt und freigegeben werden.
In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der oberen Beispielanwendung dargestellt.
Java Punkt-Operator – Ausgabe der Beispielanwendung
Besondere Java-Operatoren: Der Fragezeichen-Operator
Der Fragezeichen-Operator ist eine Kurzversion der If-Else-Anweisung. Er sollte verwendet werden, um den Quellencode übersichtlicher und lesbarer zu machen. Immer dann, wenn die Ausdrücke kompakt und ohne Seiteneffekte (wie Wertzuweisungen) sind.
Der Ausdruck ergebnis = einfacheBedingung ? wertA : wertB; liest sich wie folgt:
„Falls die einfacheBedingung wahr ist, wird dem ergebnis der Wert von wertA zugewiesen. Andernfalls, wird der Wert von wertB dem ergebnis zugewiesen.
Der Fragezeichen-Operator oder auch Bedingungs-Operator ist der einzige dreistellige Operator in Java, da er drei Operanden erwartet.
Vor dem Fragezeichen wird ein logischer Ausdruck erwartet. Dem Fragezeichen folgen die beiden Rückgabewerte, die durch einen Doppelpunkt voneinander getrennt sind.
Ergibt der logischer Ausdruck true, wird der erste Rückgabewert zurückgegeben. Ergibt der logische Ausdruck false, wird der zweite Rückgabewert zurückgegeben.
Die beiden Rückgabewerte müssen vom selben Datentyp sein. Es sind sowohl primitive als auch Referenz-Datentypen erlaubt.
Der Rückgabedatentyp entspricht immer dem größeren der beiden Datentypen, falls primitive Datentypen verwendet werden. Bei Referenz-Datentypen wird der Datentyp der allgemeineren Klasse zurückgegeben, also welcher näher an der Vaterklasse liegt.
In der folgenden Beispielanwendung wird der Fragezeichen-Operator für primitive und Referenz-Datentypen verwendet.
Beispiel Fragezeichen-Operator in Java.
/*
* Beispielanwendung BesondereOperatoren in Java.
*/
public class BesondereOperatoren{
public static void main(String[] args) {
boolean bedingung;
int zahlInt = 100;
long zahlLong = 200;
int ergebnisInt;
long ergebnisLong;
bedingung = zahlInt < zahlLong;
System.out.println("\nbedingung: " + bedingung);
ergebnisInt = (int) (bedingung ? zahlInt : zahlLong);
System.out.println("\nergebnisInt: " + ergebnisInt);
ergebnisLong = bedingung ? zahlInt : zahlLong;
System.out.println("\nergebnisLong: " + ergebnisLong);
String refStr = new String("Hallo PLGQ.");
Object refObj = new Object();
Object result;
result = (!bedingung) ? refStr : refObj;
System.out.println("\nresult: " + result);
String result2;
//result2 = (String) ((!bedingung) ? refStr : refObj);
// Laufzeitfehler, da Object nicht zu String umgewandelt werden kann
}
}
In Zeile 18 muss der Rückgabedatentyp des Ausdrucks bedingung ? zahlInt : zahlLong explizit umgewandelt werden. Dabei handelt es sich um eine einschränkende Typumwandlung.
Die explizite Typumwandlung ist erforderlich, da der Rückgabedatentyp des oben genannten Ausdrucks dem größeren Datentyp (long größer als int) entspricht. Auch wenn der Wert der int-Variable übergeben wird. Mehr über das Thema Typumwandlung in Java könnt ihr in folgenden Beitrag nachlesen: Typumwandlung bzw. Typkonvertierung (type casting) in Java.
Der Ausdruck in Zeile 35 führt zu einem Laufzeitfehler (ClassCastException). Es wird als Rückgabedatentyp der Datentyp der Vaterklasse zurückgeliefert (Object-Klasse).
Dieser kann mittels expliziter Typumwandlung in einen String-Datentyp umgewandelt werden. Dies führt aber zu einem Programmabsturz während der Laufzeit, sobald das referenzierte Objekt keine Instanz der String-Klasse ist.
Und genau dieser Fehler liegt in Zeile 35 vor. Das vom Fragezeichen-Operator zurückgegebene Object-Objekt ist eine Instanz der Object-Klasse und kann daher nicht in den String-Datentyp umgewandelt werden.
In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der oberen Beispielanwendung dargestellt.
Java Fragezeichen-Operator – Ausgabe der Beispielanwendung
Besondere Java-Operatoren: Der Operator für Zugriffe auf Array-Elemente
Arrays sind ein äußerst bedeutsames Sprachelement in der Programmiersprache Java, daher sollte der Umgang mit ihnen für Programmierer sehr gewohnt sein. Was Arrays sind und wie sie in Java benutzt werden, wird in folgendem Beitrag beschrieben: Arrays in Java – Deklaration, Initialisierung und Zugriff auf Arrays.
In diesem Abschnitt soll es nur um den Zugriff auf Array-Elemente gehen. Dieser erfolgt in Java mit Hilfe von eckigen Klammern [].
Der Zugriff auf eindimensionale Arrays erfolgt über den Ausdruck arrayname[pos]. Hierbei ist arrayname der Name eines Array-Objekts und pos eine Zahl vom int-Datentyp.
Da pos vom int-Datentypen sein muss, ist die maximale Array-Länge auf die größtmögliche Integerzahl (2147483647) begrenzt. Ein Zugriff auf Array-Elemente mittels einer Zahl von long-Datentyp ist nicht zulässig.
Der Ausdruck arrayname[pos] liefert den Inhalt des Array-Elements, welches sich an Position pos befindet, zurück. Hierbei ist unbedingt zu beachten, dass das erste Array-Element an Position 0 liegt und das letzte Element an Position (Arraylänge – 1).
Der Rückgabedatentyp entspricht dem Basisdatentyp des Arrays.
Der Zugriff auf mehrdimensionale Arrays erfolgt auch mit Hilfe eckiger Klammern, in der Form arrayname[posX][posY] für zweidimensionale und arrayname[posX][posY][posZ] für dreidimensionale Arrays.
In der folgenden Beispielanwendung wird der Operator für den Zugriff auf Array-Elemente verwendet.
Beispiel Array-Zugriff-Operator in Java.
/*
* Beispielanwendung BesondereOperatoren in Java.
*/
import java.util.Arrays;
public class BesondereOperatoren{
public static void main(String[] args) {
// Deklaration eines Arrays der String-Objekte enthaelt
String[] stringArray;
// Speicherplatz für 3 String-Objekte zuteilen
stringArray = new String[3];
// Initialisieren des ersten Array-Elements
stringArray[0] = "Hallo";
// Initialisieren des zweiten Array-Elements
stringArray[1] = "PLHQ";
// Initialisieren des dritten Array-Elements
stringArray[2] = "!";
int posInt = 1;
long posLong = 1L;
String element;
element = stringArray[posInt];
System.out.println("\nArray-Element an posInt: " + element);
//element = stringArray[posLong];
// Compiler-Fehler, da nur mit int-Zahl auf Array zugegriffen werden darf
element = stringArray[(int) posLong];
System.out.println("Array-Element an posLong: " + element);
System.out.println("\nArraylaenge: " + stringArray.length);
System.out.println("Arrayinhalt: " + Arrays.toString(stringArray));
}
}
Der Ausdruck in Zeile 32 führt zu einem Compiler-Fehler (possible loss of precision), da über eine long-Variable auf den Array zugegriffen wird. Zwischen den eckigen Klammern wird aber eine int-Variable erwartet.
Möchte man dennoch mit einer long-Variable auf den Array zugreifen, muss eine explizite Typumwandlung durchgeführt werden. Dies geschieht mit dem Ausdruck in Zeile 35.
Es ist bei dieser einschränkenden Typumwandlung aber strengstens darauf zu achten, dass der int-Wertebereich eingehalten wird. Sonst kommt es zu einem Laufzeitfehler (ArrayIndexOutOfBoundsException) oder zu unbestimmten Fehlverhalten der Anwendung.
In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der oberen Beispielanwendung dargestellt.
Java Array-Zugriff-Operator – Ausgabe der Beispielanwendung
Besondere Java-Operatoren: Der Operator für das Aufrufen von Methoden
Methoden sind in Java immer an eine Klasse oder an eine Instanz gebunden. Aus diesem Grund muss auch immer die Klasse oder das Objekt angegeben werden, wenn man in Java eine Methode aufrufen möchte. Außer man befindet sich in der Klasse und die aufzurufende Methode ist statisch.
Aus anderen Programmiersprachen kennt man neben Methoden auch Funktionen, die es in Java aber nicht gibt. Der Hauptunterschied zwischen Methoden und Funktionen ist, dass Funktionen nicht an Klassen gebunden sind.
Der Aufruf von Methoden ist sehr einfach. Für statische Methoden innerhalb der Klasse muss nur der Methodenname gefolgt von der Parameterliste (in runden Klammern) angegeben werden. Die Parameterliste kann auch leer sein:
meineMethode();
meineMethode(wertInt, wertByte, objString);
Der Aufruf von nicht statischen Methoden erfordert zusätzlich die Angabe der Objektreferenz, über die mit dem Punkt-Operator auf die Methode zugegriffen wird:
rechteck.getWidth();
rechteck.setLocation(50, 100);
new Rectangle(2,4).getWidth();
Methoden können, aber müssen nicht, einen Rückgabewert zurückliefern. Der Rückgabetyp wird im Methodenkopf festgelegt und der Rückgabewert entspricht dem von der return-Anweisung übergebenen Wert.
Methoden, die Nebeneffekte besitzen, sollten immer als void deklariert werden und dadurch sofort anzeigen, dass sie keinem Rückgabewert liefern. Sie sollten auch nur innerhalb einer Ausdrucks-Anweisung verwendet werden.
In der folgenden Beispielanwendung wird der Operator für das Aufrufen von Methoden verwendet.
Beispiel Methoden-Aufruf-Operator in Java.
/*
* Beispielanwendung BesondereOperatoren in Java.
*/
import java.awt.Rectangle;
public class BesondereOperatoren{
public static void main(String[] args) {
int laenge = 100, breite = 40, hoehe = 20;
byte anzahlKisten = 12;
int volumen;
volumen = berechnung(laenge, breite, hoehe, anzahlKisten);
System.out.println("\nBenoetigtes Lagervolumen: " + volumen);
Rectangle rechteck = new Rectangle(10,20, 50, 100);
System.out.println("\nX : " + rechteck.x);
System.out.println("Y : " + rechteck.y);
System.out.println("Width : " + rechteck.width);
System.out.println("Height: " + rechteck.height);
breite = (int) rechteck.getWidth();
System.out.println("\nBreite des Rechtecks: " + breite);
rechteck.setLocation(35, 70);
System.out.println("\nX : " + rechteck.x);
System.out.println("Y : " + rechteck.y);
System.out.println("Width : " + rechteck.width);
System.out.println("Height: " + rechteck.height);
}
public static int berechnung(int l, int w, int h, byte n) {
int wert;
wert = l * w * h;
wert = wert * n;
return wert;
}
}
In Zeile 14 rufen wir die statische Methode berechnung(...) mit dem Ausdruck volumen = berechnung(laenge, breite, hoehe, anzahlKisten); auf. Wir benötigen dafür keine Objektreferenz, da es sich um eine statische Methode handelt, die in dieser Klasse in Zeile 39 bis 38 definiert wird.
In Zeile 26 rufen wir mit dem Ausdruck breite = (int) rechteck.getWidth(); die Methode getWidth() auf. Für den Aufruf von getWidth() wird eine Objektreferenz benötigt. Dies ist hier die Referenz-Variable rechteck, welche auf ein Rectangle-Objekt verweist.
Da der von der Methode getWidth() zurückgegebene Wert von double-Datentyp ist, muss eine explizite Typumwandlung nach int durchgeführt werden.
In Zeile Zeile 30 rufen wir mit einer Ausdrucks-Anweisung die void Methode setLocation(...) auf. Diese Methode besitzt einen Nebeneffekt. In der Methode werden Eigenschaften des Objekts rechteck verändert. Da als Rückgabetyp void festgelegt ist, wird kein Wert zurückgeliefert.
In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der oberen Beispielanwendung dargestellt.
Java Methoden-Aufruf-Operator – Ausgabe der Beispielanwendung
Besondere Java-Operatoren: Der Operator für die Verkettung von String-Objekten
Mit Hilfe des +-Operators können in Java String-Objekte mit anderen Objekten verkettet werden. Es können verschiedene Objekte miteinander verkettet werden, wenn mindestens eines davon ein String-Objekt ist.
Nicht String-Objekte werden dabei zunächst in einen String umgewandelt und anschließend mit dem String-Objekt verkettet. Die Verkettung der beiden Operanden ergibt wiederum ein neues String-Objekt, in dem die beiden Operanden unmittelbar hintereinander stehen.
Bei der Verkettung von primitiven Datentypen wird die Konvertierung von dem Java-Compiler durchgeführt. Für Objekte steht die Methode toString() zur Verfügung, die für jeden Objekttyp auf ihre eigene Art implementiert ist.
Hinweis: Bei der Verkettung mit dem +-Operator muss unbedingt auf die Vorrang- und Assoziativitätsregeln geachtet werden. Die beiden folgenden Ausdrücke ergeben nicht die gleiche Zeichenkette: String s1 = "3" + 2 + 1; ist nicht gleich String s2 = 3 + 2 + "1";.
In der folgenden Beispielanwendung wird der Operator für das Verketten von String-Objekten verwendet.
Beispiel String-Verkettung-Operator in Java.
/*
* Beispielanwendung BesondereOperatoren in Java.
*/
public class BesondereOperatoren{
public static void main(String[] args) {
int a = 99;
boolean b = true;
char c = 'P';
double d = -.5e-1D;
String s = "Ein String-Objekt";
Object o = new Object();
System.out.println("\na: " + a);
System.out.println("b: " + b);
System.out.println("c: " + c);
System.out.println("d: " + d);
System.out.println("s: " + s);
System.out.println("o: " + o);
System.out.println("\nAlle zusammen: " + a + b + c + d + s + o);
String s1 = "3" + 2 + 1;
String s2 = 3 + 2 + "1";
System.out.println("\ns1: " + s1);
System.out.println("s2: " + s2);
// Der +-Operator wird von links nach rechts ausgewertet
// und zwar immer 2 Operanden pro Auswertungsschritt.
// Daher werden für s1 alle Operanden als String miteinander verkettet
// und für s2 zuerst 3 + 2 addiert und das Ergebnis anschließend mit dem
// String "1" verkettet.
}
}
In den Zeilen 24 und 25 werden zwei String-Objekte erzeugt. Auf den ersten Blick scheint es, als würden sie die gleiche Zeichenkette ergeben. Aufgrund der Vorrang- und Assoziativitätsregeln ist dies aber nicht der Fall.
Da der +-Operator von links nach rechts ausgewertet wird, ergeben die beiden Ausdrücke andere Resultate. Pro Auswertungsschritt werden immer 2 Operanden ausgewertet. Daher wird für s1 zunächst der String „3“ mit der Zahl 2 verkettet. Dazu wird die Zahl 2 in einen String der Form „2“ konvertiert. Anschließend werden die beiden Strings „3“ und „2“ miteinander verkettet zu „32“. Als Nächstes wird der neue String „32“ auf die gleiche Art mit der Zahl 1 zu dem String „321“ verkettet.
Für s2 werden zunächst die beiden Zahlen 3 und 2 miteinander addiert. Das Ergebnis 5 wird anschließend mit dem String „1“ verkettet. Dazu wird die Zahl 5 in einen String umgewandelt zu „5“ und dieser dann mit „1“ zu dem String „51“ verkettet.
Somit ergibt sich für s1 = "321" und für s2 = "51".
In der unteren Abbildung ist die Kommandozeilen-Ausgabe zu der oberen Beispielanwendung dargestellt.
Java String-Verkettung-Operator – Ausgabe der Beispielanwendung
Comments 3
Sehr gut und übersichtlich, danke dafür 🙂
Pingback: Operatoren, Ausdrücke und Anweisungen in Java
Pingback: Java-Grundlagen: Ausdrücke, die kleinsten ausführbaren Einheiten in Java