JShell är ett kommandoradsverktyg för att köra kodavsnitt i en skalmiljö utan att behöva kompilera och köra en komplett applikation. JShell är en ny funktion i Java 9. JShell kan användas för att testa och felsöka kodavsnitt när man utvecklar en applikation. JShell-indata bör vara i form av ett komplett kodavsnitt. Vi introducerade JShell med två artiklar, "Using JShell in Java 9 in NetBeans 9.0, Part 1," och "Using JShell in Java 9 in NetBeans 9.0, Part 2", där vi diskuterade att köra importen uttalande, deklarera och använda variabler, jämföra String s och löpande uttalanden. I den här fortsättningsartikeln ska vi köra utdrag för Java-metoder. Den här artikeln har följande avsnitt:
- Ställa in miljön
- Använda metoder
- Ändra en metoddefinition
- Metodöverbelastning
- Göra en vidarebefordran till en metod
- Anteckningsmetoder
- Modifierare är inte tillåtna i metoddeklarationer på toppnivå
- Slutsats
Ställa in miljön
Ladda ner och installera NetBeans, som diskuterats i en tidigare artikel. Starta JShell genom att välja Verktyg>Öppna Java Platform Shell , som visas i figur 1.
Figur 1: Verktyg>Öppna Java Platform Shell
Använda metoder
En metod deklareras i JShell precis som det är i en Java-applikation, med några skillnader, som också diskuteras i det här avsnittet. Som ett exempel, deklarera en metod triple(int) som tar en int argument och returnerar en int värde.
int triple(int i) {
return i*3;
}
Kör kodavsnittet i JShell och en metod skapas.
[10]-> int triple(int i) {
return i*3;
}
| created method triple(int)
Anropa metoden trippel med en int värde som arg.
triple(1)
Argumentvärdet tredubblas och returneras.
[11]-> triple(1) | $13 ==> 3 [12]->
Metoden har en returtyp och parametrar men ingen åtkomstmodifierare som public , privat , eller skyddad . Det beror på att en metoddeklaration på toppnivå, som alla deklarationer på toppnivå, är implicit offentlig. Alla åtkomstmodifierare i en metoddeklaration på toppnivå ignoreras. Alla följande metoddeklarationer är likvärdiga med föregående metoddeklaration.
[1]-> private int triple(int i){
return 3*i;
}
| created method triple(int)
[2]-> protected int triple(int i){
return 3*1;
}
| replaced method triple(int)
[3]-> public int triple(int i){
return 3*i;
}
| replaced method triple(int)
[4]->
JShell visar kompileringsfel, om några. Som ett exempel, gör returtypen för metod trippel som String och ett felmeddelande visas.
[10]-> String triple(int i) {
return i*3;
}
| Error:
| incompatible types: int cannot be converted to java.lang.String
| return i*3;
| ^-^
Ändra en metoddefinition
Ett utdatameddelande som inte skulle genereras av en Java-applikation och listat två gånger redan i det här avsnittet är "ersatt metod...". Meddelandet indikerar att en metoddefinition har ändrats. Bestämmelsen om att ersätta/modifiera en metoddeklaration och andra deklarationer är för att underlätta testning.
För att modifiera eller ersätta en metod utan att definiera en ny metod får metodsignaturen, som ställs in av metodnamnet och metodparametrarna inklusive antalet parametrar och deras typ och ordning, inte ändras. Som ett exempel, förklara en metod hej med returtyp void och en sträng typ parameter.
[4]-> void hello(String s){
}
| created method hello(String)
Deklarera sedan samma metod hej med returtyp String , en sträng typparameter och en retursats. Den tidigare metoddeklarationen för hej ersätts.
[5]-> String hello(String s){
return "Hello " + s;
}
| replaced method hello(String)
[6]->
Anropa metoden hello(String) och den andra metoddefinitionen anropas för att mata ut ett "Hello John"-meddelande.
[6]-> hello("John")
| $5 ==> "Hello John"
[7]->
Metodargumenten sammanfogas i metodanrop, om det behövs, som i följande utdrag.
[7]-> hello("John"+" & "+"Johnny")
| $22 ==> "Hello John & Johnny"
[8]->
I det föregående exemplet på att modifiera en metod ersatte vi returtypen void med String . Retur behöver inte ändras för att ersätta en metod. Som ett exempel, definiera en metod hej enligt följande.
[15]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
Ändra sedan endast retur påstående. Metoden hello(String,String) ersätts.
[16]-> String hello(String str1, String str2){
return "Hello"+str1+str2;
}
| replaced method hello(String,String)
Som ett annat exempel på att köra ett metodkodavsnitt, definiera en metod hello(String str1, String str2) med returtyp String[] .
[17]->
String[] hello(String str1, String str2){
return new String[]{str1,str2};
}
| created method hello(String,String)
Anropa metoden med två argument för att returnera en array.
[18]-> hello("John","Michael")
| $39 ==> String[2] { "John", "Michael" }
Metodöverbelastning
En metod kan vara överbelastad precis som i en Java-applikation. Deklarera en metod hello(String s) .
[1]-> String hello(String s){
return "Hello " + s;
}
| created method hello(String)
Anropa metoden för att mata ut ett meddelande.
[2]-> hello("John")
| $1 ==> "Hello John"
Deklarera en annan metod hello(String,String) .
[3]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
Anropa metoden för att mata ut ett meddelande.
[5]-> hello("Hello"," John")
| $16 ==> "Hello John"
Göra en vidarebefordran till en metod
JShell stöder att vidarebefordra referenser till en metod. En framåtriktad referens åberopar en metod som ännu inte har definierats. Deklarera en metod main(String) som gör en referens till en metod hello(String) , som ännu inte har definierats. Metoden main(String) skapas men det kan inte anropas förrän metoden hello(String) är definierad.
[1]-> String main(String str){
return "Hello "+hello(str);
}
| created method main(String), however, it cannot be invoked until
| method hello(java.lang.String) is declared
Anropa metoden main(String) och ett meddelande matas ut, vilket indikerar att det inte kan anropas.
[2]-> main("Michael")
| attempted to call method main(String) which cannot be invoked
| until method hello(java.lang.String) is declared
Deklarera metoden hello(String) som refereras av main(String) .
[3]-> String hello(String name){
return name;
}
| created method hello(String)
Anropa sedan metoden main(String) igen och den anropas.
[4]-> main("Michael")
| $1 ==> "Hello Michael"
";" läggs till implicit om det inte läggs till i variabeldeklarationer på toppnivå och metoddeklarationer som läggs till en per rad. Men ";" är inte implicit i påståenden inom en metod. Som ett exempel, deklarera följande metod och ett fel visas.
[1]-> int average(int i,int j){
return (i+j)/2
}
| Error:
| ';' expected
Anteckningsmetoder
Metoder som definieras i en given JShell-session listas med /methods kommando. För att demonstrera, definiera några metoder.
[1]-> int triple(int i) {
return i*3;
}
| created method triple(int)
[2]-> String hello(String s){
return "Hello" + s;
}
| created method hello(String)
[3]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
[4]-> int average(int i,int j){
return (i+j)/0;
}
| created method average(int,int)
Kör /methods kommandot, och alla metoder som lagts till listas.
[5]-> /methods | printf (String,Object...)void | triple (int)int | hello (String)String | hello (String,String)String | average (int,int)int [5]->
Modifierare är inte tillåtna i metoddeklarationer på toppnivå
Medan modifierare offentliga , privat och skyddad i metoddeklarationer på toppnivå ignoreras och en metoddefinition skapas implicit med allmän tillgång, vissa andra modifierare ignoreras inte och är inte tillåtna i en metoddeklaration på toppnivå. Dessa modifierare är inte tillåtna på toppnivå eftersom de har betydelse inom ett visst sammanhang och inte lämpar sig i JShell-sammanhang, som är att testa kodavsnitt.
Modifieraren statisk har betydelse när den används med en metod inom ramen för en klass eller ett gränssnitt, men inte på toppnivå. Som ett exempel, kör följande metoddeklaration som inkluderar statisk .
[1]-> static String hello(String name){
return "Hello "+name;
}
| Warning:
| Modifier 'static' not permitted in top-level declarations,
| ignored
| static String hello(String name){
| ^----^
| created method hello(String)
Den statiska modifierare ignoreras, en varning matas ut, men en metod skapas. Metoden kan anropas.
[2]-> hello("John")
| $1 ==> "Hello John"
[3]->
På samma sätt är modifieraren final har ingen betydelse på toppnivån, vare sig i en metoddeklaration eller någon annan deklaration, eftersom JShell är designat för att köra kodavsnitt dynamiskt och deklarera en metod (eller variabel eller klass) final skulle göra kodavsnittet oföränderligt. Som ett exempel, lägg till final modifierare till en metod. finalen modifierare ignoreras, en varning genereras och metoddefinitionen skapas utan den slutliga .
[2]-> final int triple(int i){
return 3*i;
}
| Warning:
| Modifier 'final' not permitted in top-level declarations,
| ignored
| final int triple(int i){
| ^---^
| created method triple(int)
Anropa metoden och den matar ut ett resultat.
[3]-> triple(5) | $1 ==> 15 [4]->
Vissa andra modifierare är inte heller tillåtna på toppnivå, vare sig i en metod eller någon annan deklaration. Medan modifierare statiska och slutlig ignoreras och en metoddefinition skapas, modifierare abstrakt och native i en toppnivåmetod genererar ett fel och en metod skapas inte.
[1]-> abstract String hello(String s){
return "Hello "+s;
}
| Error:
| Modifier 'abstract' not permitted in top-level declarations
| abstract String hello(String s){
| ^------^
[1]->
[1]-> native String hello(String s){
return "Hello "+s;
}
| Error:
| Modifier 'native' not permitted in top-level declarations
| native String hello(String s){
| ^----^
Modifierare standard och synkroniserad i en metoddeklaration på toppnivå eller någon annan deklaration är inte heller tillåtna och genererar ett fel.
Slutsats
I den här artikeln diskuterade vi att köra kodavsnitt för Java-metoder i JShell. I en efterföljande artikel kommer vi att diskutera körande kodavsnitt för Java-klasser, gränssnitt och arrayer.