Erzeugungsausdrücke in Java
Das Objekt "java.lang.System.out" existiert bereits beim Start der Methode "main" einer Java -Applikation.
Es ist aber auch möglich, zur Laufzeit weitere Objekte einer Klasse zu erzeugen. Wir haben dies auch schon getan, etwa in manchen Fällen der Verwendung des Plusoperators »+« mit Operanden vom Typ »java.lang.String«.
Solche zur Laufzeit erzeugte Objekte werden manchmal auch als dynamische Objekte im Gegensatz zu den während eines Programm ständig bestehenden statischen Entitäten genannt.
Daher werden auch die Operationen einer Klasse also statische Operationen bezeichnet. Klassen werden ja in Java nicht zur Laufzeit erzeugt, und sie damit sozusagen statisch. Die Operationen von Objekten kann man also auch als nicht-statische Operationen einer Klasse bezeichnen.
Die Erzeugung eines Objekts einer Klasse kann auch mit Hilfe eines Erzeugungsausdrucks erfolgen – dies ist das Thema dieser Lektion. Wir gehen hier eine vereinfachte Produktionsregel für solche Erzeugungsausdrücke an. Die angegebene Klasse wird der Typ des erzeugten Objekts. Das erzeugte Objekt ist dann der Wert des Erzeugungsausdrucks.
- Erzeugungsausdruck
- 〈ClassInstanceCreationExpression 〉 ::=
- "new" 〈Class 〉 "(" [〈ArgumentList 〉] ")".
Beispielsweise ist der Wert des Erzeugungsausdrucks »new java.lang.Object()« ein neues Objekt der Klasse »java.lang.Object«, der Typ des Ausdrucks »new java.lang.Object()« ist dabei ebenfalls »java.lang.Object«, der Wert des Erzeugungsausdrucks »new java.lang.String()« ist ein neues Objekt der Klasse »java.lang.String«, der Typ des Erzeugungsausdrucks »new java.lang.String()« ist dabei ebenfalls »java.lang.String«, und so weiter.
Bei der Auswertung solch eines Erzeugungsausdrucks wird ein neues Objekt der Klasse 〈Class 〉 erzeugt. Der Wert des Ausdrucks ist das erzeugte Objekt. Die Bindungskraft (Priorität) dieses Operators ist dieselbe, wie die eines Vorzeichens, er bindet also stärker als eine Multiplikation.
»new« ist ein Schlüsselwort.
Hinter »new« sind als Referenztyp nur Klassen, aber keine Schnittstellen oder andere Arten von Referenztypen möglich.
Referenztypname
|
.----------------------'----------------------.
| |Klassenname Schnittstellenname
nach "new" moeglich NICHT nach "new" moeglich
ℛ Ausdrucktyp Der Typ eines Ausdrucks kann ein Referenztyp (also eine Klasse oder eine Schnittstelle ) sein.
ℛ Objekttyp Der Typ eines Objekts ist immer eine Klasse.
In dem folgenden Programm wird ein Objekt der Klasse "java.lang.Object" erzeugt, allerdings hat die Ausführung dieses Programms keine von außen erkennbare Wirkung.
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ new java.lang.Object(); }}System.out
ℛ Erzeugungsregel Ein Erzeugungsausdruck hat den hinter »new« angegebenen Typ. Sein Wert ist ein Objekt, welches die hinter »new« angegebene Klasse hat.
Lesehinweis Der Nutzen von Exemplarerzeugungsausdrücken wird erst gegen Ende dieser Lektion erkennbar werden – insbesondere bei den Übungsaufgaben. Daher bitte etwas Geduld, wenn es zunächst nicht gleich erkennbar wird, wofür Exemplarerzeugungsausdrücke gut sind!
Erzeugungsargumente
Etwaige Ausdrücke in den runden Klammern werden (wie bei einem Aufruf) Argumente genannt. Die Regeln für die Argumentliste in den runden Klammern sind wie bei einem Methodenaufruf.
Erzeugungsanweisungen
Ein Erzeugungsausdruck darf vor ein Semikolon »;« geschrieben werden, um mit ihm zusammen eine Anweisung zu bilden (wie oben schon zu sehen war).
Unterschiede zwischen Objekten und Klassen (erweitert)
Objekte und Verzeichnisklassen sind beides Sammlungen von Methoden und Feldern, aber nur Objekte lassen sich im Quelltext durch Ausdrücke angeben, Klassen werden im Quelltext durch Namen angegeben, die keine Ausdrücke sind.
Es ist möglich, während des Programmablaufs neue Objekte zu erzeugen, es ist aber nicht möglich, während des Programmablaufs neue Klassen zu erzeugen.
Ein Erzeugungsausdruck mit dem Schlüsselwort "new" ist wie eine Maschine, die ein neues Objekt einer Klasse herstellt.
Erzeugung und Benennung eines Objektes
Hier werden zwei java.lang.String-Objekte erzeugt. Bei der hier gezeigten Art der Erzeugung ist ihre Länge gleich »0«.
Main.javapublic class Main
{ public static void main( final java.lang.String[] args )
{ final java.lang.String s = new java.lang.String();
final java.lang.String t = new java.lang.String();
java.lang.System.out.println( s.length() );
java.lang.System.out.println( t.length() ); }}transcript0
0
Argumente von Erzeugungsausdrücken
In einem Erzeugungsausdruck können bei einigen Klassen auch Ausdrücke innerhalb der runden Klammern verwendet werden.
Beispielsweise kann zu einer Zeichenfolge »s« mit »new java.lang.String( s )« eine neue Zeichenfolge erzeugt werden. Obwohl die neue Zeichenfolge den gleichen Text enthält, handelt es sich dann doch um eine andere Folge.
Main.javapublic class Main
{ public static void main( final java.lang.String[] args )
{ final java.lang.String a = "Hallo!";
final java.lang.String s = new java.lang.String( "Hallo!" );
final java.lang.String t = new java.lang.String( "Hallo!" );
final java.lang.String u = new java.lang.String( "Delta!" );
java.lang.System.out.println( a );
java.lang.System.out.println( s );
java.lang.System.out.println( t );
java.lang.System.out.println( u ); }}transcriptHallo!
Hallo!
Hallo!
Delta!
Solche Ausdrücke in den Klammern eines Erzeugungsausdrucks nennen wir auch Argumente des Erzeugungsausdrucks (in Analogie zu Argumenten eines Aufrufs).
Man beachte daß in der Deklaration "final java.lang.String s = new java.lang.String( "Hallo!" );" der Typ "java.lang.String" zwiefach auftritt: Zuerst als Typ der Konstanten "s" und dann also Typ eines neu anzulegenden Objekts.
Ein beliebter Flüchtigkeitsfehler ist es bei manchen Programmierern, das Schlüsselwort "new" zu vergessen, da die scheinbare Deklaration "final java.lang.String s = java.lang.String( "Hallo!" );" auch plausibel aussieht und in einigen anderen Programmiersprachen so möglich ist.
Bei Verwendung eines java.lang.String-Literals ist die ausdrücklich Erzeugung mit einem Erzeugungsausdruck natürlich meist unnötig kompliziert, da anstelle des Ausdrucks "new java.lang.String( "Hallo!" )" meist einfach der Ausdruck ""Hallo!"" verwendet werden kann. In anderen Fällen, die wir später sehen werden, kann der Gebrauch von »new« aber nötig sein.
Dokumentation von Argumenten von Erzeugungsausdrücken
Die Dokumentation der möglichen Argumente eines Erzeugungsausdrucks findet sich unter “Constructor Summary ” in der verwendeten Klasse.
Konstruktoren
Der Wert des Erzeugungsausdrucks »new java.lang.String( "" )« ist ein Objekt vom Typ »java.lang.String« mit dem Wert »""«. Der Ausdruck »""« ist ein Argument dieses Erzeugungsausdrucks. Woher weiß man aber, welche Argumente hier zulässig sind? Das kann der Dokumentation der Klasse »java.lang.String« unter der Überschrift “Constructor Summary ” („Konstruktoren“) entnommen werden.
- java.lang.String-Erzeugungsparameter (Synopse)
java.lang
Class java.lang.String
Constructor Summary
String()
Constructs a newly allocated String object that
represents an empty character sequence.String( String s )
Constructs a newly allocated String object that
represents the same sequence of characters as the
argument.
Die Angaben in den runden Klammern der Proklamationen der Konstruktoren bezeichnen wird als Parameterbeschreibungen. Entsprechend können Konstruktoren also auch Parameter haben (in Analogie zu Methoden). Man kann das über die Dokumentation von Parametern bei Methoden Gesagte auf die Parameter von Konstruktoren übertragen.
Die Dokumentation der Klasse gibt hier an, daß eine Erzeugungsmöglichkeit, einen sogenannten Konstruktor, ohne Parameter und eine Erzeugungsmöglichkeit mit einem Parameter vom Typ »java.lang.String« in der Klasse enthalten ist wird.
Der folgende Quellcode zeigt die Verwendung beider Konstruktoren.
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ final java.lang.String s = new java.lang.String();
final java.lang.String t = new java.lang.String( "" );
java.lang.System.out.println( s );
java.lang.System.out.println( t );
java.lang.System.out.println( s.getClass() == t.getClass() ); }}transcript
true
Ein Konstruktor in der Dokumentation einer Klasse beschreibt eine Möglichkeit zum Schreiben eines Erzeugungsausdrucks, indem er den hinter »new« zu schreibenden Typ angibt (beispielsweise »java.lang.String«) und durch eine Liste von Parameterdeklarationen wie bei der Dokumentation einer Methode angibt, welche Argumente in solch einem Erzeugungsaudruck verwendet werden können. (Ähnlich wie bei der Dokumentation von Methoden.)
Überladene Konstruktoren
Für die Argumentliste 〈ArgumentList 〉 eines Erzeugungsausdruck zu einer bestimmten Klasse gibt es oft verschiedene zulässige Möglichkeiten der Anzahl und der Typen der Argumente. Durch verschiedene Typen von Argumentlisten können Objekte in verschiedener Weise erzeugt werden.
So kann ein Objekt der Klasse "java.lang.String" beispielsweise mit einer leeren Argumentliste erzeugt werden, um dem leeren Text zu repräsentieren, oder mit einem anderen String, um dessen Text zu repräsentieren.
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ java.lang.System.out.println( new java.lang.String() );
java.lang.System.out.println( new java.lang.String( "Hallo!" ) ); }}System.out
Hallo!
Hinweis für den Dozenten ► N: Hilfe bei Argumenten von Erzeugungsausdrücken
Priorität
Ein Erzeugungsausdruck gilt als ein Primärausdruck und hat damit eine „sehr hohe Priorität“, so daß er in der Regel nicht eingeklammert werden muß, wenn er als Operand verwendet werden soll, wie das folgende Beispiel zeigt.
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ java.lang.System.out.println( new java.lang.String( "Hallo!" ).length() ); }}transcript6
Benennung eines neuen Objektes
Wenn ein neues Objekt einer Klasse erzeugt und benannt werden soll, dann muß der Klassenname meistens doppelt notiert werden. In der Deklaration "final java.lang.String s = new java.lang.String();" gibt das erste "java.lang.String" den Type der Konstante an und das zweite "java.lang.String" den Typ des zu erstellenden Objekts.
Objektbenennungfinal java.lang.String s = new java.lang.String();
Wegen einer vermeintlichen Redundanz dieser Deklaration oder aufgrund von Übertragungen aus anderen Programmiersprachen wird zur Erzeugung einer Konstanten für ein neues java.lang.String-Objekt manchmal versehentlich fälschlicherweise nur "final java.lang.String s;" geschrieben. Dadurch wird aber kein neues Objekt erzeugt, sondern nur eine nicht-initialisierte Konstante. Zur Erzeugung einer Konstanten, deren Wert ein neues Objekt einer Klasse ist, darf also der Erzeugungsausdruck nicht vergessen werden.
Allerdings muß der Typ eines Namens nicht mit dem Typ des Objektes, welches der Wert des Namens ist, übereinstimmen, in einer Deklaration mit Erzeugung können auch zwei verschiedene Typen auftreten. Der Typ des Namens muß ein Obertyp des Typs des Initialisierungsausdrucks sein.
Objektbenennung 1final java.lang.Object o = new java.lang.String();
- ? Übungsfrage
- Welcher Fehler findet sich in dem folgenden Programm?
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ final java.lang.Object o;
java.lang.System.out.println( o ); }}
Syntax
Das folgende Syntaxdiagramm für Ausdrücke wurde um die Syntax für Erzeugungsausdrücke erweitert.
- Neue, erweiterte Syntax (vereinfacht)
Ausdruck
.----------.
---.----------->| Literal |---------------------------.---->
| '----------' |
| .----------. |
'----------->| Name |---------------------------'
| '----------' |
| .-. .----------. |
'--->( - )-->| Ausdruck |---------------------------'
| '-' '----------' |
| .-. .----------. |
'--->( + )-->| Ausdruck |---------------------------'
| '-' '----------' |
| .-. .----------. .-. |
'--->( ( )-->| Ausdruck |-->( ) )-------------------'
| '-' '----------' '-' |
| .----------. .-. .----------. |
'----------->| Ausdruck |-->( / )-->| Ausdruck |----'
| '----------' '-' '----------' |
| .----------. .-. .----------. |
'----------->| Ausdruck |-->( + )-->| Ausdruck |----'
| '----------' '-' '----------' |
| .----------. .-. .----------. |
'----------->| Ausdruck |-->( - )-->| Ausdruck |----'
| '----------' '-' '----------' |
| .----------. .-. .----------. |
'----------->| Ausdruck |-->( * )-->| Ausdruck |----'
| '----------' '-' '----------' |
| .---------------------. |
'----------->| statischer Aufruf |----------------'
| '---------------------' |
| .---------------------------. |
'----------->| nicht-statischer Aufruf |----------'
| '---------------------------' |
| .----------------------. |
'----------->| Erzeugungsausdruck |---------------'
'----------------------'
Name
.-----------------------.
| .------. .-. v .------------------------.
---'--->| Name |-->( . )---'--->| Bezeichnerzeichenfolge |--->
'------' '-' '------------------------'statischer Aufruf
.-------. .-. .---------------. .-.
--->| Name |--->( ( )--->| Ausdruckliste |--->( ) )--->
'-------' '-' '---------------' '-'nicht-statischer Aufruf
.-----------. .-. .------------. .-. .---------------. .-.
--->| Ausdruck |--->( . )--->| Bezeichner |--->( ( )--->| Ausdruckliste |--->( ) )--->
'-----------' '-' '------------' '-' '---------------' '-'Ausdruckliste
.---------------------------.
| .----------. v
---'---.--->| Ausdruck |---.---'--->
^ '----------' |
| .-. |
'-------( , )<------'
'-'Erzeugungsausdruck
.---. .-------. .-. .---------------. .-.
--->( new )--->| Name |--->( ( )--->| Ausdruckliste |--->( ) )--->
'---' '-------' '-' '---------------' '-'
»new« ist ein Schlüsselwort. (Wie schon weiter oben gesagt.)
Hinter »new« muß in der Regel Leeraum eingefügt werden, um jenes Schlüsselwort von dem folgenden Namen einer Klasse abzutrennen.
Anforderungen
Zu einem Erzeugungsausdruck muß es in der Klasse, deren Name hinter »new« folgt, einen Konstruktor geben, dessen Parameterliste zu der Ausdruckliste des Exemplarerzeugungsausdrucks paßt (so wie bei einer Methode die Parameterliste zur Argumentliste des Aufrufs passen muß).
Typregeln
Der Typ des Ausdrucks »new T (…)« ist »T «, also der hinter »new« angegebene Typ.
Der Typ des Objekts, welches der Wert des Ausdrucks »new T (…)« ist, ist ebenfalls »T «, also der hinter »new« angegebene Typ.
Semantik
Bei der Auswertung eines Erzeugungsausdrucks wird der am besten zur verwendeten Argumentliste passende Konstruktor verwendet, um eine neues Objekt der angegebenen Klasse zu initialisieren (also einzurichten). Der Wert des Erzeugungsausdrucks ist dann jenes neue Objekt nach jener Initialisierung.
Verschachtelte Erzeugungsausdrücke
Häufig kommen auch verschachtelte Erzeugungsausdrücke wie »new java.lang.Integer( new java.lang.String( "4" ))« vor. Dabei wird mit dem inneren Ausdruck ein Objekt erzeugt, das dann als Argument des äußeren Ausdruckes dient. An dieser Stelle des Kurses können wir aber noch kein sinnvolles Beispiel für solch eine Verschachtelung zeigen.
Die Zweifelsregel
ℛ Zweifelsregel Im Zweifelsfall wähle man als Variablentyp den Typ des erzeugten Objektes.
- Beispiele zur Zweifelsregel
final java.lang.String s = new java.lang.String();
final var s = new java.lang.String();
Echte Obertypen für Variablentypen
Stilistisch etwas besser ist es manchmal, wenn der Typ der Variablen gerade so weit oben ist, wie dies angesichts der folgenden Verwendung noch möglich ist.
Im folgenden Programm wird beispielsweise nach der Deklaration von »sequence« nur die Methode »length()« benötigt. Dafür reicht bereits die Schnittstelle »java.lang.CharSequence« aus. Der Typ »java.lang.String« ist nicht unbedingt nötig.
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ final java.lang.CharSequence sequence = "abc";
java.lang.System.out.println( sequence.length() ); }}- Protokoll
3
Ein Vorteil dieser Vorgehensweise besteht darin, daß es dann später einfacher ist, bei Bedarf (wenn dies das Programm beispielsweise schneller macht) für die Variable ein Objekt einer anderen Klasse einzusetzen, ohne daß der Typ der Variablen nochmals angepaßt werden muß.
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ final java.lang.CharSequence sequence = new java.lang.StringBuilder( "abc" );
java.lang.System.out.println( sequence.length() ); }}- Protokoll
3
Auch wenn man heute »var« verwenden könnte, dokumentiert ein möglichst hochstehender Obertyp besser, welche Methoden im Rest des Codes wirklich benötigt werden.
Übungsfragen
? Übungsfrage
Der Typ einer Variablen muß ein __________ des Typ des in der Variablen enthaltenen Objektes sein.
Welches Wort muß an Stelle der Lücke stehen? („Obertyp“ oder „Untertyp“?)
? Übungsfrage 1
Der Typ eines Argumentes muß ein __________ des Typs des zu ihm gehörenden Parameters sein.
Welches Wort muß an Stelle der Lücke stehen? („Obertyp“ oder „Untertyp“?)
? Übungsfrage 2
Der Typ einer Variablen, die in einer Zuweisung links vom Gleichheitszeichen steht, muß ein __________ des Typs des Ausdrucks auf der rechten Seite des Gleichheitszeichens sein.
Welches Wort muß an Stelle der Lücke stehen? („Obertyp“ oder „Untertyp“?)
? Übungsfrage 3
Welchen Typ hat ein Aufruf der nicht-statischen Methode »intValue()« aus der Klasse »java.lang.Integer«?
Können Sie der Dokumentation entnehmen, welchen Nutzen diese Methoden haben soll?
? Übungsfrage 4 ⃖
Welcher der beiden unten beschriebenen Konstruktoren wird für die Auswertung des Erzeugungsausdrucks »new java.lang.String()« herangezogen (also verwendet)?
Welcher der beiden unten beschriebenen Konstruktoren wird für die Auswertung des Erzeugungsausdrucks »new java.lang.String( "abc" )« herangezogen?
- java.lang.String-Konstruktoren (Auszug)
java.lang
Class java.lang.String
Constructor Summary
String()
Constructs a newly allocated String object that
represents an empty character sequence.String( String s )
Constructs a newly allocated String object that
represents the same sequence of characters as the
argument.
Übungsaufgaben
/ Übungsaufgabe
- java.lang.Integer-Erzeugungsparameter (Synopse)
java.lang
Class java.lang.IntegerConstructor Summary
Integer( int i )
- Erzeugt eine neues Objekt der Klasse »java.lang.Integer« mit dem angegebenen int-Wert.
Erzeugen Sie ein neues Objekt der Klasse »java.lang.Integer«, indem Sie einen Erzeugungsausdruck mit einem int-Argument verwenden, und geben Sie das neue Objekt mit Hilfe von »java.lang.System.out.println« aus.
Zusatzanforderung Geben Sie dann auch noch das Ergebnis des Aufrufs der Methode »intValue()« jenes Objektes aus.
- Unter einem int-Argument verstehen wir hier ein Argument, dessen Typ der Typ »int« ist.
- Ein Erzeugungsausdruck endet mit einer eingeklammerten Ausdruckliste. Ein Argument eines Erzeugungsausdrucks ist einer der Ausdrücke jener Ausdruckliste.
/ Einführung von Namen (Beispielaufgabe)
Das folgende Beispiel zeigt wie ein Name für den Wert eines Ausdrucks eingeführt wird. Dabei wird der Ausdruck durch einen noch verfügbaren Namen ersetzt, der Name wird dann davor so definiert, daß sein Wert der Wert des ersetzten Ausdrucks ist. (Diese Umstellung ist nicht immer ein Refaktor, aber sie ist es in den folgenden Aufgaben.)
- Vor der Einführung eines Namens (Aufgabe)
java.lang.System.out.println( 2 );
- Nach der Einführung eines Namens (Lösung)
final int i = 2;
java.lang.System.out.println( i );
Beachten Sie, wie der Programmierer oben den richtigen Typ – nämlich »int« – für den neuen Namen festgelegt hat. Auch bei den folgenden Aufgaben ist es wichtig, jeweils den richtigen Typ festzulegen. Im allgemeinen sollte dies der Typ des Initialisierungsausdrucks der Namensdeklaration sein.
/ Objekterzeugung ⃗
Erzeugen Sie ein neues Objekt der Klasse »java.lang.Double«, indem Sie einen Erzeugungsausdruck verwenden, und geben Sie das neue Objekt mit Hilfe von »java.lang.System.out.println« aus.
Zusatzanforderung Geben Sie dann auch noch das Ergebnis des Aufrufs der Methode »doubleValue()« jenes Objektes aus.
/ Einführung von Namen
Führen Sie einen Namen für den Ausdruck in den Klammern hinter »println« ein!
- Vor der Einführung eines Namens (Aufgabe)
java.lang.System.out.println( new java.lang.Object() );
/ Einführung von Namen (1)
Führen Sie einen Namen für den Ausdruck in den Klammern hinter »println« ein!
- Vor der Einführung eines Namens (Aufgabe)
java.lang.System.out.println
( new java.awt.geom.Point2D.Double( 8, 1 ) );
An diesem Beispiel kann man nun auch den Nutzen von Erzeugungsausdrücken besser erkennen: Ohne »new« könnte man gar keine Objekte der Klasse »java.awt.geom.Point2D.Double« anlegen!
»java.awt.geom.Point2D.Double« ist der Name einer Klasse.
Ein Typ kann auch in einem anderen Typ enthalten sein. Die Klasse »java.awt.geom.Point2D.Double« ist in dem Typ »java.awt.geom.Point2D« enthalten. Daher ergibt sich der Name »Point2D.Double«.
/ Übungsaufgabe
Erzeugen Sie ein neues Objekt der Klasse »java.lang.String«, indem Sie einen Erzeugungsausdruck verwenden, und geben Sie das neue Objekt mit Hilfe von »java.lang.System.out.println« aus.
Erzeugen Sie alsdann ein neues Objekt der Klasse »java.lang.StringBuilder«, indem Sie einen Erzeugungsausdruck mit dem zuvor erzeugten java.lang.String-Objekt als Argument verwenden, und geben Sie auch dieses neue Objekt mit Hilfe von »java.lang.System.out.println« aus.
Zusatzanforderung Geben Sie dann auch noch die Ergebnisse des Aufrufs der Methoden »getClass()« jener beiden Objekte aus.
/ Aufruf von Methoden eines Objektes
Rufen Sie die Methode »deleteCharAt(int)« des Objekts »new java.lang.StringBuilder( "Pluto" )« mit dem Argumentwert »2« auf, aber geben Sie dabei noch nichts aus. Erst dahinter soll dann noch eine Ausgabeanweisung folgen, mit der jenes Objekt dann ausgegeben wird. (Hierfür wird eine Variable für das Objekt benötigt!)
(zusätzliche Hilfestellung: Es soll also insgesamt nur einmal »new« verwendet werden und »deleteCharAt( 2 )« soll nicht in den Klammern hinter »println« stehen.)
/ Übungsaufgabe 1
Erzeugen Sie zwei neue Objekt der Klasse »java.lang.String« mit derselben Zeichenfolge, indem Sie jeweils einen Erzeugungsausdruck mit einem Zeichenfolgenliteral als Argument verwenden, und geben Sie den Wert des Aufrufs der Methode »equals« des einen Objektes mit dem anderen Objekt als Argumentwert aus. Geben Sie dann noch den Wert eines Vergleichs der beiden Objekte mit »==« aus.
/ Übungsaufgabe 2
Erzeugen Sie ein neues Objekt der Klasse »java.lang.NoSuchMethodException«, indem Sie einen Erzeugungsausdruck ohne Argumente verwenden, und geben Sie das neue Objekt mit Hilfe von »java.lang.System.out.println« aus.
Erzeugen Sie danach ein weiteres neues Objekt der Klasse »java.lang.RuntimeException«, indem Sie einen Erzeugungsausdruck verwenden, in welchem das Objekt als Argument verwendet wird, welches gemäß der Angaben im vorigen Absatz erzeugt wurde, und geben Sie das zweite neue Objekt nun ebenfalls mit Hilfe von »java.lang.System.out.println« aus.
Das zweite Objekt enthält eine Methode »getCause()«, die ein Objekt zurückgibt. Rufen Sie jene Methode auf und geben Sie den Wert des Aufrufs aus. Um welches Objekt handelt es sich bei diesem Wert vermutlich?
/ Einführung von Namen (2) ⃗
Führen Sie in dem folgenden Programm einen Namen für den Wert des Ausdrucks »"4"« ein und ersetzen Sie die Vorkommen des Ausdrucks »"4"« in Erzeugungsausdrücken dann durch jenen Namen.
Führen Sie dann einen Namen für das neu erzeugte java.lang.String-Objekt ein und ersetzen Sie dann das Argument des java.lang.Integer-Erzeugungsausdrucks durch jenen Namen.
Führen Sie dann einen Namen für das neu erzeugte java.lang.Integer-Objekt ein und ersetzen Sie dann das Argument von »println« durch jenen Namen.
Das Programm soll nach all diesen Ersetzungen immer noch »4« ausgeben.
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ java.lang.System.out.println
( new java.lang.Integer
( new java.lang.String( "4" ))); }}Protokoll4
/ Einführung von Namen (3) ⃗
Vor dem Kapitel zu JavaFX werden einige JavaFX -Programme schon als Übungsmaterial verwendet. Es ist aber nicht nötig, bei den folgenden Übungen bereits die Bedeutung der einzelne JavaFX -Klassen zu kennen. Diese werden etwas später im Kurs noch erklärt werden.
Weisen Sie das Objekt »new javafx.scene.control.TextField( "jkl" )« einem Namen zu. Rufen Sie dann die Methode »getText()« jenes Objektes auf und geben Sie den Wert des Aufrufs dann mit Hilfe von »java.lang.System.out.println« aus.
Die Lösung (Blockeinträge) sollte dafür in den folgenden Rahmen an die Stelle der Ellipse »…« geschrieben werden. (Dieser Rahmen wird später im Kurs erklärt werden.)
Main.javapublic final class Main extends
javafx.application.Application
{ public void start
( final javafx.stage.Stage stage )
{…
javafx.application.Platform.exit(); }}
(Dieses Programm kann im 202. Jahrzehnt möglicherweise nicht mit einigen älteren Entwicklungsumgebungen gestartet werden.)
/ Einführung von Namen (4) ⃗
Überarbeiten Sie das folgende Programm, indem Sie für das vom zweiten Erzeugungsausdruck erzeugte Objekt den Namen »textField« am Anfang des Blocks deklarieren. Jener Name soll dann bei der Erzeugung des javafx.scene.Scene-Objekts als Argument verwendet werden. Das Programm sollte sich nach der Änderung wieder so wie zuvor verhalten.
(Der Aufbau dieses Programmes wird später ausführlicher erklärt werden.)
(Solche Programme mit JavaFX können durch Schließen ihres Fensters beendet werden.)
Main.javapublic final class Main extends
javafx.application.Application
{ public void start( final javafx.stage.Stage stage )
{ final javafx.scene.Scene s = new javafx.scene.Scene
( new javafx.scene.control.TextField
( "äöüÄÖÜ߀" ));
stage.setScene( s );
stage.show(); }}
/ Übungsaufgabe 3
Ersetzen Sie den Typ »java.util.ArrayList< java.lang.Integer >« der Variablen »list« in der Deklaration der Variablen durch einen in der Typhierarchie möglichst weit obenstehenden Typ, so daß der Rest des Programms weiterhin unverändert ablaufen kann.
Main.javapublic final class Main
{ public static void main( final java.lang.String[] args )
{ finaljava.util.ArrayList< java.lang.Integer >
list = new java.util.ArrayList< java.lang.Integer >();
list.add( 3 );
java.lang.System.out.println( list.get( 0 )); }}- Protokoll
3
Bei der Erledigung dieser Aufgabe sollen die ersten drei und die letzten drei Zeilen des Programms nicht verändert werden.
/ Übungsaufgabe 4
Ersetzen sie im Ergebnis der vorigen Übungsaufgabe nun den Typ des erzeugten Objekts (»java.util.ArrayList< java.lang.Integer >«) durch einen anderen Untertyp des Variablentyps, so daß der Rest des Programms weiterhin unverändert ablaufen kann.
main-Methode für ältere Entwicklungsumgebungen *
Bei einigen älteren Entwicklungsumgebungen ist bei Verwendungen der Methode »start(javafx.stage.Stage)« noch die folgende statische main-Methode hinzuzufügen.
main-Methodepublic static void main( final java.lang.String[] args )
{ javafx.application.Application.launch( args ); }- Aussprachehinweis
“launch ” /lɔnʧ/ (n)