JShell is een opdrachtregelprogramma om codefragmenten in een shell-omgeving uit te voeren zonder een complete applicatie te compileren en uit te voeren. JShell is een nieuwe functie in Java 9. JShell kan worden gebruikt om codefragmenten te testen en te debuggen bij het ontwikkelen van een applicatie. JShell-invoer moet de vorm hebben van een volledig codefragment. We hebben JShell geïntroduceerd met twee artikelen, "JShell gebruiken in Java 9 in NetBeans 9.0, Part 1" en "JShell gebruiken in Java 9 in NetBeans 9.0, Part 2", waarin we het uitvoeren van de import bespraken. statement, declareren en gebruiken van variabelen, vergelijken van String s en lopende instructies. In dit vervolgartikel zullen we fragmenten uitvoeren voor Java-methoden. Dit artikel heeft de volgende secties:
- De omgeving instellen
- Methoden gebruiken
- Een methodedefinitie wijzigen
- Overbelasting van methode
- Een voorwaartse verwijzing naar een methode maken
- Vermeldingsmethoden
- Modificaties niet toegestaan in methodeverklaringen op het hoogste niveau
- Conclusie
De omgeving instellen
Download en installeer NetBeans, zoals besproken in een eerder artikel. Start JShell door Tools>Open Java Platform Shell . te selecteren , zoals weergegeven in afbeelding 1.
Figuur 1: Tools>Java Platform Shell openen
Methoden gebruiken
Een methode wordt in JShell net zo gedeclareerd als in een Java-toepassing, met een paar verschillen, die ook in deze sectie worden besproken. Declareer bijvoorbeeld een methode triple(int) dat duurt een int argument en retourneert een int waarde.
int triple(int i) {
return i*3;
}
Voer het codefragment uit in JShell en er wordt een methode gemaakt.
[10]-> int triple(int i) {
return i*3;
}
| created method triple(int)
Roep de methode triple op met een int waarde als argument.
triple(1)
De argumentwaarde wordt verdrievoudigd en geretourneerd.
[11]-> triple(1) | $13 ==> 3 [12]->
De methode heeft een retourtype en parameters, maar geen toegangsmodifier zoals public , privé , of beschermd . De reden hiervoor is dat een methodedeclaratie op het hoogste niveau, zoals alle verklaringen op het hoogste niveau, impliciet openbaar is. Elke toegangsmodifier in een methodedeclaratie op het hoogste niveau wordt genegeerd. Alle volgende methodedeclaraties zijn gelijk aan de voorgaande methodedeclaraties.
[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 geeft eventuele fouten tijdens het compileren weer. Maak als voorbeeld het retourtype van de methode drievoudig als String en er wordt een foutmelding weergegeven.
[10]-> String triple(int i) {
return i*3;
}
| Error:
| incompatible types: int cannot be converted to java.lang.String
| return i*3;
| ^-^
Een methodedefinitie wijzigen
Een uitvoerbericht dat niet zou worden gegenereerd door een Java-toepassing en al twee keer in deze sectie wordt vermeld, is "vervangen methode ...". Het bericht geeft aan dat een methodedefinitie is gewijzigd. De bepaling om een methodeverklaring en andere verklaringen te vervangen/wijzigen is bedoeld om het testen te vergemakkelijken.
Om een methode te wijzigen of te vervangen zonder een nieuwe methode te definiëren, mag de methodehandtekening, die wordt ingesteld door de methodenaam en methodeparameters inclusief het aantal parameters en hun type en volgorde, niet worden gewijzigd. Declareer bijvoorbeeld een methode hallo met retourtype void en een String type parameter.
[4]-> void hello(String s){
}
| created method hello(String)
Verklaar vervolgens dezelfde methode hallo met retourtype String , een String type parameter en een return-statement. De vorige methodedeclaratie voor hallo wordt vervangen.
[5]-> String hello(String s){
return "Hello " + s;
}
| replaced method hello(String)
[6]->
Roep de methode hallo(String) op en de tweede methodedefinitie wordt aangeroepen om een “Hallo Jan”-bericht uit te sturen.
[6]-> hello("John")
| $5 ==> "Hello John"
[7]->
De methodeargumenten worden, indien nodig, aaneengeschakeld in methodeaanroep, zoals in het volgende fragment.
[7]-> hello("John"+" & "+"Johnny")
| $22 ==> "Hello John & Johnny"
[8]->
In het voorgaande voorbeeld van het wijzigen van een methode hebben we het retourtype void . vervangen met String . Return hoeft niet te worden gewijzigd om een methode te vervangen. Definieer bijvoorbeeld een methode hallo als volgt.
[15]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
Wijzig vervolgens alleen de retour uitspraak. De methode hallo(String,String) wordt vervangen.
[16]-> String hello(String str1, String str2){
return "Hello"+str1+str2;
}
| replaced method hello(String,String)
Als een ander voorbeeld van het uitvoeren van een codefragment van een methode, definieert u een methode hello(String str1, String str2) met retourtype String[] .
[17]->
String[] hello(String str1, String str2){
return new String[]{str1,str2};
}
| created method hello(String,String)
Roep de methode aan met twee argumenten om een array te retourneren.
[18]-> hello("John","Michael")
| $39 ==> String[2] { "John", "Michael" }
Overbelasting methode
Een methode kan net als in een Java-toepassing overbelast zijn. Declareer een methode hallo(String s) .
[1]-> String hello(String s){
return "Hello " + s;
}
| created method hello(String)
Roep de methode op om een bericht uit te voeren.
[2]-> hello("John")
| $1 ==> "Hello John"
Declareer een andere methode hallo(String,String) .
[3]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
Roep de methode op om een bericht uit te voeren.
[5]-> hello("Hello"," John")
| $16 ==> "Hello John"
Een voorwaartse verwijzing naar een methode maken
JShell ondersteunt het maken van voorwaartse verwijzingen naar een methode. Een doorverwijzing roept een methode op die nog niet is gedefinieerd. Declareer een methode main(String) die verwijst naar een methode hello(String) , die nog niet is gedefinieerd. De methode main(String) wordt wel gemaakt, maar kan pas worden aangeroepen als de methode hello(String) is gedefinieerd.
[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
Aanroepen van methode main(String) en er wordt een bericht weergegeven dat aangeeft dat het niet kan worden aangeroepen.
[2]-> main("Michael")
| attempted to call method main(String) which cannot be invoked
| until method hello(java.lang.String) is declared
Declareer de methode hallo(String) waarnaar wordt verwezen door main(String) .
[3]-> String hello(String name){
return name;
}
| created method hello(String)
Roep vervolgens de methode main(String) . op opnieuw en het wordt aangeroepen.
[4]-> main("Michael")
| $1 ==> "Hello Michael"
De ";" wordt impliciet toegevoegd indien niet toegevoegd in variabele declaraties op het hoogste niveau en methodedeclaraties die één per regel worden toegevoegd. Maar de ";" is niet impliciet in uitspraken binnen een methode. Declareer bijvoorbeeld de volgende methode en er wordt een fout weergegeven.
[1]-> int average(int i,int j){
return (i+j)/2
}
| Error:
| ';' expected
Lijstmethoden
Methoden die in een bepaalde JShell-sessie zijn gedefinieerd, worden weergegeven met de /methods opdracht. Definieer een paar methoden om te demonstreren.
[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)
Voer de /methods . uit commando, en alle toegevoegde methoden worden weergegeven.
[5]-> /methods | printf (String,Object...)void | triple (int)int | hello (String)String | hello (String,String)String | average (int,int)int [5]->
Modificaties niet toegestaan in methodeverklaringen op het hoogste niveau
Terwijl modifiers openbaar , privé , en beschermd in methodedeclaraties op het hoogste niveau worden declaraties genegeerd en wordt impliciet een methodedefinitie gemaakt met openbare toegang, worden bepaalde andere modifiers niet genegeerd en zijn ze niet toegestaan in een methodedeclaratie op het hoogste niveau. Deze modifiers zijn niet toegestaan op het hoogste niveau omdat ze betekenis hebben binnen een bepaalde context en niet geschikt zijn in de context van JShell, namelijk het testen van codefragmenten.
De modifier statisch heeft betekenis bij gebruik met een methode in de context van een klasse of een interface, maar niet op het hoogste niveau. Voer als voorbeeld de volgende methodedeclaratie uit die statisch . bevat .
[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)
De statische modifier wordt genegeerd, er wordt een waarschuwing uitgevoerd, maar er wordt wel een methode gemaakt. De methode kan worden aangeroepen.
[2]-> hello("John")
| $1 ==> "Hello John"
[3]->
Evenzo, de modifier finale heeft geen betekenis op het hoogste niveau, of het nu een methodedeclaratie is of een andere declaratie, omdat JShell is ontworpen om codefragmenten dynamisch uit te voeren en een methode (of variabele of klasse) final te declareren zou het fragment onwijzigbaar maken. Voeg als voorbeeld de finale . toe modifier voor een methode. De finale modifier wordt genegeerd, er wordt een waarschuwing gegenereerd en de methodedefinitie wordt gemaakt zonder de finale .
[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)
Roep de methode aan en het geeft een resultaat.
[3]-> triple(5) | $1 ==> 15 [4]->
Sommige andere modifiers zijn ook niet toegestaan op het hoogste niveau, zowel in een methode als in een andere declaratie. Overwegende dat modifiers statisch en finale worden genegeerd en er wordt een methodedefinitie gemaakt, modifiers abstract en native in een methode op het hoogste niveau een fout genereren en er wordt geen methode gemaakt.
[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){
| ^----^
Modifiers standaard en gesynchroniseerd in een methodeverklaring op het hoogste niveau of een andere declaratie zijn ook niet toegestaan en genereren een fout.
Conclusie
In dit artikel hebben we het uitvoeren van codefragmenten voor Java-methoden in JShell besproken. In een volgend artikel zullen we het uitvoeren van codefragmenten voor Java-klassen, interfaces en arrays bespreken.