JShell ist eine neue Funktion in Java 9, um das Ausführen von Codeausschnitten zu erleichtern. JShell-Codeschnipsel sind genau das Gleiche wie Java-Quellcode in einer Datei für eine Anwendung. Wie in einem früheren Artikel, „Using JShell in Java 9 in NetBeans 9.0, Part 3“, besprochen, lässt JShell mehrere Modifikatoren nicht zu – einschließlich default, access,synced, public, private und protected – die in einer Quellcodedatei unterstützt werden . JShell ist hauptsächlich zum Testen und Debuggen von Java-Code und nicht zum Ausführen vollständiger Anwendungen konzipiert. In diesem Fortsetzungsartikel werden wir Snippets für Klassen, Schnittstellen und Arrays ausführen. Wir haben NetBeans 9 wie in den früheren Artikeln verwendet. Wir werden auch ungeprüfte Ausnahmen diskutieren. Dieser Artikel hat die folgenden Abschnitte:
- Klassen verwenden
- Ändern einer Klasse
- Klassen auflisten
- Klassenkonstruktoren verwenden
- Erweitern einer Klasse
- Überschreiben einer Methode
- Schnittstellen verwenden
- Eine Standardimplementierung für eine Methode verwenden
- Eine Schnittstellenmethode als statisch deklarieren
- Arrays verwenden
- Ungeprüfte Ausnahmen verwenden
- Schlussfolgerung
Klassen verwenden
In diesem Abschnitt werden wir das Ausführen von Codeausschnitten für Klassen besprechen. Deklarieren Sie eine einfache Klasse C wie folgt.
[1]-> class C {
}
| created class C
Klasse C wird erstellt. Im Gegensatz zu einer Methode, die direkt aufgerufen werden kann, muss eine Klasse zuerst wie folgt instanziiert werden.
[3]-> new C() | $1 ==> [email protected]
Eine neue Instanz der Klasse C, $1 wird erstellt. Wie bei Methodendeklarationen können Klassendeklarationen geändert werden, indem die Klasse erneut deklariert wird. Eine Klasse kann eine Schnittstelle mit implements implementieren . Deklarieren Sie als Beispiel eine Schnittstelle I .
[1]-> interface I{}
| created interface I
Erstellen Sie die Klasse C um die Schnittstelle I zu implementieren .
[3]-> class C implements I{}
| replaced class C
[4]->
Klasse C , die zuvor erstellt wurde, wird ersetzt.
Eine Klassendeklaration in JShell hat nicht das Konzept einer Anwendung, wie es eine in einer Datei deklarierte Java-Klasse hätte. Eine Java-Klasse in einer Datei mit dem public static void main(String[] argv) Methode ist eine Java-Anwendung. Das öffentliche statische void main(String[] argv) -Methode kann in JShell hinzugefügt werden, ist aber nur ein weiteres Code-Snippet. Erstellen Sie eine Klasse Hallo das beinhaltet die Methode public static void main(String[] argv) .
[1]-> class Hello{
public static void main(String[] argv){System.out.println
(argv[0]+argv[1]);}
}
| created class Hello
[2]->
Der main(String[]) Methode ist eine statische -Methode und wird für die Klasse und nicht für eine Instanz einer Klasse definiert. Erstellen Sie einen String[] Array zur Versorgung von main(String[]) Methode.
String[] strArray={"Hello"," JShell"}; Rufen Sie main(String[]) auf Methode mit dem String[] als Argument.
Hello.main(strArray)
Eine Hello-JShell-Nachricht wird ausgegeben, wie in Abbildung 1 gezeigt.
Abbildung 1: Aufruf einer statischen Methode in einer Klasse
Ändern einer Klasse
Eine Klasse kann nach Bedarf geändert werden, indem eine ihrer Methodendeklarationen geändert oder gelöscht oder neue Methoden hinzugefügt werden. Deklarieren Sie die Klasse erneut Hallo ohne main(String[]) -Methode und die Klasse wird ersetzt.
[4]-> class Hello{
}
| replaced class Hello
[5]->
Fügen Sie main(String[]) erneut hinzu Methode, aber mit einer etwas anderen System.out.println Erklärung. Klasse Hallo wieder ersetzt wird.
[5]-> class Hello{
public static void main(String[] argv)
{System.out.println(argv[0]);}
}
| replaced class Hello
[5]->
Rufen Sie die statische auf Methode main(String[]) mit Hello.main(strArray) für eine andere Ausgabe, wie in Abbildung 2 gezeigt.
Abbildung 2: Aufrufen einer Variante der Methode main
Die Möglichkeit, eine Klasse zu ersetzen, ist beim Entwickeln einer Klasse nützlich. Es kann jeweils eine Methode hinzugefügt und klassengetestet werden. Fügen Sie als Beispiel eine zweite Methode hello(String) hinzu . Nochmals Klasse Hallo wird ersetzt.
[9]-> class Hello{
void main(String[] argv){System.out.println(argv[0]);}
String hello(String name){return name;}
}
| replaced class Hello
Die Methode hello(String) hinzugefügt, da es sich um eine Instanzmethode handelt, würde eine Klasseninstanz zum Aufrufen benötigen. Erstellen Sie eine Klasseninstanz.
[10]-> new Hello() | $2 ==> [email protected]
Rufen Sie die Methode hello(String) auf mit der Klasseninstanz $2 .
[11]-> $2.hello("John")
| $6 ==> "John"
Auflistungsklassen
Eine Java-Klasse ist ein Typ. Eine Schnittstelle ist auch ein Typ. Alle in der JShell-Session definierten Typen werden mit /types aufgelistet Befehl. Definieren Sie einige Klassen und Schnittstellen.
[4]-> [1]-> class C{}
| created class C
[2]-> class D{}
| created class D
[3]-> class B{}
| created class B
[4]-> interface I{}
| created interface I
[5]-> interface J{}
| created interface J
Führen Sie /types aus Befehl und alle Klassen und Schnittstellen werden aufgelistet.
[6]-> /types | class C | class D | class B | interface I | interface J
Klassenkonstruktoren verwenden
Die No-Arg-Klasse ist implizit in einer Klasse definiert, wenn sie keine Konstruktoren mit Argumenten definiert. Wir hatten zuvor eine Klasse C instanziiert die keine Konstruktoren explizit mit new C() deklariert haben . Der No-Arg-Konstruktor kann explizit definiert werden.
Erstellen Sie als Nächstes eine Klasse Hallo die einen Klassenkonstruktor deklariert. Der Konstruktor hat einen Parameter vom Typ String . Der Konstruktor kann mit public deklariert werden Modifikator und ist implizit öffentlich wenn nicht auf öffentlich gesetzt .
[6]->
class Hello{
String name;
public Hello(String name){this.name=name;}
void hello(){System.out.println("Hello "+name);}
}
Erstellen Sie eine Instanz der Klasse Hallo .
Hello hello=new Hello("John") Rufen Sie die Instanzmethode hello() auf um eine Nachricht auszugeben, wie in Abbildung 3 gezeigt.
Abbildung 3: Verwenden einer Klasse mit einem Konstruktor
Verlängern einer Klasse
Eine Klasse kann wie in einer Java-Quellcodedatei mit Erweiterungen erweitert werden. Erstellen Sie als Beispiel die Klasse D die einen Variablennamen vom Typ tt>String, einen No-Arg-Konstruktor und eine Methode hello(String) deklariert . Das Hallo(String) -Methode gibt ein "Hallo" aus Nachricht mit dem Namen arg angegeben.
class D{
String name="Michael";
public D(){}
void hello(String name){System.out.println("Hello "+name);}
}
Erstellen Sie eine Klasse C das die Klasse C erweitert und deklariert das hello() Methode, die die Klasse D nicht überschreibt ist Hallo(String) Methode und Parameter sind unterschiedlich. Das Hallo() Methode ruft einen Feldnamen auf, der von der Klasse D geerbt wird .
class C extends D{
void hello(){System.out.println("Hello "+name);}
}
Klasse C instanziieren und rufen Sie hello() auf Methode.
new C().hello()
Eine „Hallo“-Nachricht wird ausgegeben, wie in Abbildung 4 gezeigt. Der name Feldwert, der in der Klasse D gesetzt ist verwendet wird.
Abbildung 4: Erweitern einer Klasse
Wenn wir hello(String) aufgerufen haben Methode dieser Klasse C erbt von der Klasse D , würden wir eine andere Ausgabe erhalten, wie in Abbildung 5 gezeigt.
Abbildung 5: Aufrufen einer geerbten Methode von einer erweiterten Klasse
Überschreiben einer Methode
Eine Klasse kann eine von einer erweiterten Klasse geerbte Methode überschreiben, indem sie ihre eigene Methodendefinition bereitstellt. Erstellen Sie eine Klasse D das ein Feld name deklariert und eine Methode hello() .
class D{
String name="Michael";
void hello(){System.out.println("Hello "+name);}
}
Deklarieren Sie eine Klasse C die die Klasse D erweitert und überschreibt das hello() Methode. Klasse C blendet auch das Feld name aus .
class C extends D{
String name="John";
void hello(){System.out.println("Hello "+name);
}
Erstellen Sie eine Instanz der Klasse C und rufen Sie die Methode hello() auf .
new C().hello()
Das Hallo() Methode aus der Klasse C wird aufgerufen, weil es die Methode der Klasse D überschreibt . Das Feld name in der Klasse C blendet das Feld name aus in der Klasse D . Die Nachrichtenausgabe ist in Abbildung 6 dargestellt.
Abbildung 6: Überschreiben einer Methode
Wenn Klasse C blendet das Feld name nicht aus ab Klasse D , der Name Feld in der Klasse D verwendet wird, wie in Abbildung 7 gezeigt.
Abbildung 7: Zugriff auf das Feld von der erweiterten Klasse
Eine Klasse C Objekt ist eine Instanz der Klasse D weil es die Klasse D erweitert . Führen Sie die folgende Anweisung aus, um herauszufinden, ob es sich um eine Instanz der Klasse C handelt ist auch eine Instanz der Klasse D .
new C() instanceof D
Ein Wert von true überprüft eine Instanz der Klasse C ist auch eine Instanz der Klasse D , wie in Abbildung 8 gezeigt.
Abbildung 8: Prüfen, ob eine Instanz der Klasse C auch eine Instanz der Klasse D ist
Da eine Instanz der Klasse C ist auch eine Instanz der Klasse D , kann es in D gecastet werden wie folgt:
D d=(D)(new C());
Anschließend greifen Sie auf das Feld name zu für Objekt d vom Typ D .
d.name;
Und rufen Sie die Methode hello() auf für Objekt d vom Typ D .
d.hello();
Der ausgegebene Feldwert stammt von der Klasse D weil d ist ein Objekt vom Typ D , wie in Abbildung 9 gezeigt. Die Methode hello() aufgerufen wird von der Klasse C .
Abbildung 9: Umwandeln eines Objekts vom Typ C in D
Schnittstellen verwenden
In diesem Abschnitt führen wir einige Snippets für Schnittstellen in JShell aus. Eine vorhandene Klasse könnte modifiziert werden, um eine Schnittstelle zu implementieren. Erstellen Sie die Klasse C .
[1]-> class C{}
| created class C
Erstellen Sie eine Schnittstelle I die eine Methode hello() definiert .
[2]-> interface I {
String hello();
}
| created interface I
Klasse C neu deklarieren um die Schnittstelle I zu implementieren . Klasse C stellt die Implementierung für die Methode hello() bereit .
[3]-> class C implements I{
public String hello(){
return "Hello JShell";
}
}
| replaced class C
Erstellen Sie eine Instanz der Klasse C .
[4]-> new C() | $1 ==> [email protected]
Rufen Sie mithilfe der Klasseninstanzvariablen die Methode hello() auf und die Methodenausgabe wird angezeigt.
[5]-> $1.hello() | $2 ==> "Hello JShell" [6]->
Denn Methoden in einem Interface sind implizit öffentlich während Methoden in einer Klasse keine Methode sind, Implementierung in Klasse C muss mit public deklariert werden Zugriffsmodifikator. Falls nicht als public deklariert , wird eine Fehlermeldung ausgegeben, weil kein public angegeben wird Der Zugriffsmodifikator verwendet standardmäßig einen schwächeren Zugriffsmodifikator, der bei der Implementierung einer Schnittstelle nicht zulässig ist.
[3]-> class C implements I{
String hello(){
return "Hello JShell";
}
}
| Error:
| hello() in C cannot implement hello() in I
| attempting to assign weaker access privileges; was public
| String hello(){
| ^--------------...
Eine Standardimplementierung für eine Methode verwenden
Ab Java 8 kann eine Schnittstellenmethode eine Standardimplementierung für eine Methode bereitstellen, indem das Schlüsselwort default verwendet wird . Deklarieren Sie eine Schnittstelle, die eine Standardimplementierung für die Methode hello() bereitstellt unter Verwendung der Standardeinstellung Schlüsselwort.
[1]-> interface I {
default String hello(){
return "Hello JShell";
}
}
| created interface I
Deklarieren Sie eine Klasse C das die Schnittstelle I implementiert .
[2]-> class C implements I{
}
| created class C
Erstellen Sie eine Instanz der Klasse C und rufen Sie die Methode hello() auf . Die Methode aus der Standardimplementierung im Interface I bekommt Ausgabe.
[3]-> new C().hello(); | $1 ==> "Hello JShell"
Eine Schnittstellenmethode als statisch deklarieren
Seit Java 8 können Interface-Methoden statisch deklariert werden . Erstellen Sie eine Schnittstelle I das deklariert ein statisches Methode.
[1]-> interface I {
static String hello(){
return "Hello JShell";
}
}
| created interface I
Rufen Sie die statische Methode über die Schnittstelle I auf .
[2]-> I.hello() | $1 ==> "Hello JShell"
Eine Klasse kann nicht als final deklariert werden und, falls die final Modifikator verwendet wird, wird er ignoriert.
[5]-> [1]-> final class C{}
| Warning:
| Modifier 'final' not permitted in top-level declarations,
| ignored
| final class C{}
| ^---^
| created class C
Arrays verwenden
In diesem Abschnitt führen wir einige Codeschnipsel für Arrays aus. Das Deklarieren, Instanziieren und Zugreifen auf Arrays ist nicht anders als in einer Java-Quellcodedatei-basierten Anwendung. Deklarieren Sie als Beispiel ein Array vom Typ String[] . Array wird auf null initialisiert .
[1]-> String[] strArray; | strArray ==> null
Ordnen Sie dem Array Speicher zu. Die einmal festgelegte Array-Größe kann nicht geändert werden. Array-Elemente werden auf null initialisiert .
[2]-> strArray =new String[3];
| strArray ==> String[3] { null, null, null }
Initialisieren Sie die Array-Elemente mit den Array-Indizes.
[3]-> strArray[0]="A"; strArray[1]="B"; strArray[2]="C"; | $4 ==> "A" | $5 ==> "B" | $6 ==> "C"
Gibt die Array-Länge und das Element an Index 1 aus.
[6]-> strArray.length; strArray[1]; | $9 ==> 3 | $10 ==> "B"
Die Array-Länge wird als 3 ausgegeben. Element am Index 1 ist „B“. Ein Array kann initialisiert werden, wenn es wie folgt deklariert wird.
[1]-> String[] strArray={"A","B","C"};
| strArray ==> String[3] { "A", "B", "C" }
Ausgabe der Array-Länge.
[2]-> strArray.length; | $1 ==> 3
Geben Sie das Element bei Index 0 aus.
[3]-> strArray[0]; | $4 ==> "A" [4]->
Ein mehrdimensionales Array kann genau wie in einer Java-Anwendung deklariert werden. Erstellen Sie ein dreidimensionales Array vom Typ String[][][] und das Array initialisieren.
[1]-> String[][][] strArray={{{"A","B","C"},{"AA","AB","AC"}},
{{"B","C","A"},{"BB","BC","BA"}},{{"C","A","B"},
{"CC","CA","CB"}}};
| strArray ==> String[3][][] { String[2][] { String[3]
| { "A", "B", "C" }, String[3] { "AA", ...
Ausgabe der Array-Länge.
[2]-> strArray.length; | $1 ==> 3
Gibt die Länge des Arrays bei Index 0 aus.
[3]-> strArray[0].length; | $4 ==> 2
Gibt die Länge des Arrays bei Index 1 innerhalb des Arrays bei Index 0 aus.
[4]-> strArray[0][1].length; | $6 ==> 3
Geben Sie das Array bei Index 0 aus.
[5]-> strArray[0]
| $10 ==> String[2][] { String[3] { "A", "B", "C" },
| String[3] { "AA", "AB", "AC" } }
Geben Sie das Array bei Index 1 innerhalb des Arrays bei Index 0 aus.
strArray[0][1]
| $11 ==> String[3] { "AA", "AB", "AC" }
Geben Sie das Element bei Index 0 im Array bei Index 1 im Array bei Index 0 aus.
strArray[0][1][0] | $12 ==> "AA" [8]->
Ungeprüfte Ausnahmen verwenden
JShell löst zur Laufzeit ungeprüfte Ausnahmen aus. Als Beispiel, wenn eine Variable vom Typ String die auf ihren Standardwert null initialisiert wurde zugegriffen wird. java.lang.NullPointerException wird geworfen.
[1]-> String str; | str ==> null [2]-> str.length(); | java.lang.NullPointerException thrown: | at (#2:1) [3]->
Als weiteres Beispiel, wenn auf einen Array-Index außerhalb der Größe eines Arrays zugegriffen wird, java.lang.ArrayIndexOutOfBoundsException wird geworfen.
[4]->
String[] str={"A","B","C"};
| str ==> String[3] { "A", "B", "C" }
[5]-> str[3];
| java.lang.ArrayIndexOutOfBoundsException thrown: 3
| at (
Wenn eine Methode aufgerufen wird, die die Division durch Null definiert, java.lang.ArithmeticException wird geworfen.
[1]-> int average(int i,int j){
return (i+j)/0;
}
| created method average(int,int)
[2]-> average(2,4)
| java.lang.ArithmeticException thrown: / by zero
| at average (#1:2)
| at (#2:1)
[3]->
Schlussfolgerung
In diesen ersten vier Artikeln haben wir das Ausführen von Codeausschnitten für Variablen, Anweisungen, Methoden, Klassen, Schnittstellen und Arrays besprochen. JShell ist darauf ausgelegt, nur Codeausschnitte auszuführen, und daher unterscheiden sich einige der Funktionen von der Ausführung einer vollständigen Java-Anwendung aus einer Quellcodedatei. In zwei weiteren Artikeln werden wir einige andere Funktionen von JShell untersuchen.
