JShell är en ny funktion i Java 9 för att underlätta körning av kodavsnitt. JShell-kodavsnitt är exakt samma som Java-källkod i en fil för ett program. Som diskuterats i en tidigare artikel, "Using JShell in Java 9 in NetBeans 9.0, Part 3", tillåter inte JShell flera modifierare – inklusive standard, åtkomst, synkroniserad, offentlig, privat och skyddad – som stöds i en källkodsfil . JShell är främst designat för att testa och felsöka Java-kod och inte för att köra kompletta applikationer. I den här fortsättningsartikeln ska vi köra utdrag för klasser, gränssnitt och arrayer. Vi har använt NetBeans 9 som i de tidigare artiklarna. Vi ska också diskutera okontrollerade undantag. Den här artikeln har följande avsnitt:
- Använda klasser
- Ändra en klass
- Anteckningsklasser
- Använda klasskonstruktörer
- Förlänga en klass
- Åsidosätt en metod
- Använda gränssnitt
- Använda en standardimplementering för en metod
- Deklarera en gränssnittsmetod som statisk
- Använda matriser
- Använda omarkerade undantag
- Slutsats
Använda klasser
I det här avsnittet kommer vi att diskutera körande kodavsnitt för klasser. Deklarera en enkel klass C enligt följande.
[1]-> class C {
}
| created class C
Klass C skapas. Till skillnad från en metod som kan anropas direkt, måste en klass först instansieras enligt följande.
[3]-> new C() | $1 ==> [email protected]
En ny instans av klass C, $1 skapas. Som med metoddeklarationer kan klassdeklarationer modifieras genom att omdeklarera klassen. En klass kan implementera ett gränssnitt med implementer . Som ett exempel, deklarera ett gränssnitt I .
[1]-> interface I{}
| created interface I
Skapa klass C för att implementera gränssnittet I .
[3]-> class C implements I{}
| replaced class C
[4]->
Klass C , skapad tidigare, ersätts.
En klassdeklaration i JShell har inte konceptet av en applikation som en Java-klass som deklareras i en fil skulle ha. En Java-klass i en fil med public static void main(String[] argv) metoden är en Java-applikation. Den offentliga statiska void main(String[] argv) metod kan läggas till i JShell men är bara ett annat kodavsnitt. Skapa en klass Hej som inkluderar metoden 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]->
main(String[]) metod är en statisk metod och definieras för klassen snarare än en instans av en klass. Skapa en sträng[] array för att leverera till main(String[]) metod.
String[] strArray={"Hello"," JShell"}; Anropa main(String[]) metoden med String[] som ett argument.
Hello.main(strArray)
Ett Hello JShell-meddelande matas ut, som visas i figur 1.
Figur 1: Anropar statisk metod i en klass
Ändra en klass
En klass kan modifieras efter behov genom att modifiera eller ta bort någon av dess metoddeklarationer eller lägga till nya metoder. Återförklara klassen Hej utan main(String[]) metod och klassen ersätts.
[4]-> class Hello{
}
| replaced class Hello
[5]->
Lägg till main(String[]) igen metod men med en något annorlunda System.out.println påstående. Klass Hej återigen ersätts.
[5]-> class Hello{
public static void main(String[] argv)
{System.out.println(argv[0]);}
}
| replaced class Hello
[5]->
Anropa den statiska metod main(String[]) med Hello.main(strArray) för en annan utgång, som visas i figur 2.
Figur 2: Anropa en variant av metod huvud
Bestämmelsen att ersätta en klass är användbar när man utvecklar en klass. En metod kan läggas till i taget och klasstestas. Som ett exempel, lägg till en andra metod hello(String) . Återigen, klass Hej ersätts.
[9]-> class Hello{
void main(String[] argv){System.out.println(argv[0]);}
String hello(String name){return name;}
}
| replaced class Hello
Metoden hello(String) Added, eftersom det är en instansmetod, skulle behöva en klassinstans att anropa. Skapa en klassinstans.
[10]-> new Hello() | $2 ==> [email protected]
Anropa metoden hello(String) använder klassinstansen $2 .
[11]-> $2.hello("John")
| $6 ==> "John"
Anteckningsklasser
En Java-klass är en typ. Ett gränssnitt är också en typ. Alla typer som definieras i JShell-sessionen listas med /types kommando. Definiera några klasser och gränssnitt.
[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
Kör /types kommandot och alla klasser och gränssnitt listas.
[6]-> /types | class C | class D | class B | interface I | interface J
Använda klasskonstruktörer
Klassen no-arg är implicit definierad i en klass om den inte definierar några konstruktorer med args. Vi hade tidigare instansierat en klass C som inte deklarerade några konstruktörer explicit med new C() . No-arg-konstruktorn kan definieras explicit.
Skapa sedan en klass Hej som deklarerar en klasskonstruktör. Konstruktorn har en parameter av typen String . Konstruktören kan deklareras med allmänheten modifierare och är implicit offentlig om den inte är inställd på offentlig .
[6]->
class Hello{
String name;
public Hello(String name){this.name=name;}
void hello(){System.out.println("Hello "+name);}
}
Skapa en instans av klassen Hej .
Hello hello=new Hello("John") Anropa instansmetoden hello() för att mata ut ett meddelande, som visas i figur 3.
Figur 3: Använda en klass med en konstruktör
Förlänga en klass
En klass kan utökas med extensions precis som i en Java-källkodsfil. Som ett exempel, skapa klass D som deklarerar ett variabelnamn av typen tt>String, en no-arg-konstruktor och en metod hello(String) . hej(sträng) metod matar ut ett "Hej" meddelande med namnet arg tillhandahålls.
class D{
String name="Michael";
public D(){}
void hello(String name){System.out.println("Hello "+name);}
}
Skapa en klass C som utökar klass C och förklarar hello() metod, som inte åsidosätter klassen D 's hej(String) metod och parametrar är olika. hello() metoden anropar ett fältnamn, som ärvs från klassen D .
class C extends D{
void hello(){System.out.println("Hello "+name);}
}
Instantiera klass C och anropa hello() metod.
new C().hello()
Ett "Hej"-meddelande matas ut, som visas i figur 4. namnet fältvärde satt i klassen D används.
Figur 4: Förlänga en klass
Om vi anropade hello(String) metod som klass C ärver från klass D , skulle vi få en annan utdata, som visas i figur 5.
Figur 5: Anropa en ärvd metod från en utökad klass
Åsidosätt en metod
En klass kan åsidosätta en metod som ärvts från en utökad klass genom att tillhandahålla sin egen metoddefinition. Skapa en klass D som deklarerar ett fält namn och en metod hello() .
class D{
String name="Michael";
void hello(){System.out.println("Hello "+name);}
}
Deklarera en klass C som utökar klass D och åsidosätter hello() metod. Klass C döljer även fältet namn .
class C extends D{
String name="John";
void hello(){System.out.println("Hello "+name);
}
Skapa en instans av klassen C och anropa metoden hello() .
new C().hello()
hello() metod från klass C anropas eftersom den åsidosätter metoden från klassen D . Fältet namn i klass C döljer fältet namn i klass D . Meddelandeutgången visas i figur 6.
Figur 6: Åsidosätt en metod
Om klass C döljer inte fältet namn från klass D , namnet fält i klass D används, som visas i figur 7.
Figur 7: Åtkomst till fält från utökad klass
En klass C objekt är en instans av klassen D eftersom det utökar klass D . Kör följande sats för att hitta om en instans av klassen C är också en instans av klass D .
new C() instanceof D
Ett värde på true verifierar en instans av klass C är också en instans av klass D , som visas i figur 8.
Figur 8: Verifiera om en instans av klass C också är en instans av klass D
Eftersom en instans av klassen C är också en instans av klass D , kan den castas till D enligt följande:
D d=(D)(new C());
Åtkomstfältet namn för objekt d av typen D .
d.name;
Och anropa metoden hello() för objekt d av typen D .
d.hello();
Fältvärdets utdata är från klass D eftersom d är ett objekt av typen D , som visas i figur 9. Metoden hello() anropad är från klass C .
Figur 9: Casta ett objekt av typ C till D
Använda gränssnitt
I det här avsnittet ska vi köra några utdrag för gränssnitt i JShell. En befintlig klass kan modifieras för att implementera ett gränssnitt. Skapa klass C .
[1]-> class C{}
| created class C
Skapa ett gränssnitt I som definierar en metod hello() .
[2]-> interface I {
String hello();
}
| created interface I
Återdeklarera klass C för att implementera gränssnittet I . Klass C tillhandahåller implementering för metoden hello() .
[3]-> class C implements I{
public String hello(){
return "Hello JShell";
}
}
| replaced class C
Skapa en instans av klassen C .
[4]-> new C() | $1 ==> [email protected]
Använd klassens instansvariabel, anropa metoden hello() och metodutgången visas.
[5]-> $1.hello() | $2 ==> "Hello JShell" [6]->
Eftersom metoder i ett gränssnitt är implicit offentliga medan metoder i en klass inte är en metod, implementering i klass C måste deklareras för allmänheten åtkomstmodifierare. Om den inte är offentlig , skickas ett felmeddelande ut eftersom det inte anger en offentlig åtkomstmodifierare har som standard en svagare åtkomstmodifierare, vilket inte är tillåtet när ett gränssnitt implementeras.
[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(){
| ^--------------...
Använda en standardimplementering för en metod
Från och med Java 8 kan en gränssnittsmetod tillhandahålla en standardimplementering för en metod genom att använda nyckelordet default . Deklarera ett gränssnitt som tillhandahåller en standardimplementering för metoden hello() med standard nyckelord.
[1]-> interface I {
default String hello(){
return "Hello JShell";
}
}
| created interface I
Deklarera en klass C som implementerar gränssnittet I .
[2]-> class C implements I{
}
| created class C
Skapa en instans av klassen C och anropa metoden hello() . Metoden från standardimplementeringen i gränssnittet I får utdata.
[3]-> new C().hello(); | $1 ==> "Hello JShell"
Deklarera en gränssnittsmetod som statisk
Sedan Java 8 kan gränssnittsmetoder deklareras statiska . Skapa ett gränssnitt I som deklarerar en statisk metod.
[1]-> interface I {
static String hello(){
return "Hello JShell";
}
}
| created interface I
Anropa den statiska metoden genom att använda gränssnittet I .
[2]-> I.hello() | $1 ==> "Hello JShell"
En klass kan inte förklaras som final och, om den är final modifierare används, ignoreras den.
[5]-> [1]-> final class C{}
| Warning:
| Modifier 'final' not permitted in top-level declarations,
| ignored
| final class C{}
| ^---^
| created class C
Använda matriser
I det här avsnittet ska vi köra några kodavsnitt för arrayer. Att deklarera, instansiera och komma åt matriser är inte annorlunda än i ett Java-källkodsfilbaserat program. Som ett exempel, deklarera en array av typen String[] . Array initieras till null .
[1]-> String[] strArray; | strArray ==> null
Tilldela minne till arrayen. Matrisstorlek kan inte ändras när den väl har ställts in. Arrayelement initieras till null .
[2]-> strArray =new String[3];
| strArray ==> String[3] { null, null, null }
Initiera arrayelementen med hjälp av arrayindexen.
[3]-> strArray[0]="A"; strArray[1]="B"; strArray[2]="C"; | $4 ==> "A" | $5 ==> "B" | $6 ==> "C"
Mata ut arraylängden och elementet vid index 1.
[6]-> strArray.length; strArray[1]; | $9 ==> 3 | $10 ==> "B"
Arraylängden matas ut som 3. Element vid index 1 är "B". En array kan initieras när den deklareras enligt följande.
[1]-> String[] strArray={"A","B","C"};
| strArray ==> String[3] { "A", "B", "C" }
Mata ut arraylängden.
[2]-> strArray.length; | $1 ==> 3
Mata ut elementet vid index 0.
[3]-> strArray[0]; | $4 ==> "A" [4]->
En flerdimensionell array kan deklareras precis som i en Java-applikation. Skapa en tredimensionell array av typen String[][][][] och initiera arrayen.
[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", ...
Mata ut arraylängden.
[2]-> strArray.length; | $1 ==> 3
Mata ut längden på matrisen vid index 0.
[3]-> strArray[0].length; | $4 ==> 2
Mata ut längden på array vid index 1 inom array vid index 0.
[4]-> strArray[0][1].length; | $6 ==> 3
Mata ut matrisen vid index 0.
[5]-> strArray[0]
| $10 ==> String[2][] { String[3] { "A", "B", "C" },
| String[3] { "AA", "AB", "AC" } }
Mata ut matrisen vid index 1 inom matrisen vid index 0.
strArray[0][1]
| $11 ==> String[3] { "AA", "AB", "AC" }
Mata ut elementet vid index 0 i array vid index 1 inom array vid index 0.
strArray[0][1][0] | $12 ==> "AA" [8]->
Använda omarkerade undantag
JShell kastar omarkerade undantag vid körning. Som ett exempel, om en variabel av typen String som har initierats till dess standardvärde null nås. java.lang.NullPointerException kastas.
[1]-> String str; | str ==> null [2]-> str.length(); | java.lang.NullPointerException thrown: | at (#2:1) [3]->
Som ett annat exempel, om ett arrayindex utanför en arrays storlek nås, java.lang.ArrayIndexOutOfBoundsException kastas.
[4]->
String[] str={"A","B","C"};
| str ==> String[3] { "A", "B", "C" }
[5]-> str[3];
| java.lang.ArrayIndexOutOfBoundsException thrown: 3
| at (
Om en metod som definierar division med noll anropas, java.lang.ArithmeticException kastas.
[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]->
Slutsats
I dessa första fyra artiklar diskuterade vi köra kodavsnitt för variabler, satser, metoder, klasser, gränssnitt och arrayer. JShell är designat för att endast köra kodavsnitt och som sådana är vissa av funktionerna annorlunda än när man kör en komplett Java-applikation från en källkodsfil. I ytterligare två artiklar ska vi utforska några andra funktioner i JShell.