JShell é uma ferramenta de linha de comando para executar trechos de código em um ambiente shell sem ter que compilar e executar um aplicativo completo. JShell é um novo recurso do Java 9. O JShell pode ser usado para testar e depurar trechos de código ao desenvolver um aplicativo. A entrada do JShell deve estar na forma de um trecho de código completo. Apresentamos o JShell com dois artigos, "Usando JShell no Java 9 no NetBeans 9.0, Parte 1" e "Usando o JShell no Java 9 no NetBeans 9.0, Parte 2", nos quais discutimos a execução da import declaração, declarando e usando variáveis, comparando String s e instruções em execução. Neste artigo de continuação, executaremos snippets para métodos Java. Este artigo tem as seguintes seções:
- Definindo o ambiente
- Uso de métodos
- Modificando uma definição de método
- Método de sobrecarga
- Fazendo uma referência direta a um método
- Métodos de listagem
- Modificadores não permitidos em declarações de método de nível superior
- Conclusão
Definindo o ambiente
Baixe e instale o NetBeans, conforme discutido em um artigo anterior. Inicie o JShell selecionando Ferramentas>Abrir Java Platform Shell , como mostrado na Figura 1.
Figura 1: Ferramentas>Abrir Shell da Plataforma Java
Uso de métodos
Um método é declarado no JShell da mesma forma que em um aplicativo Java, com algumas diferenças, que também são discutidas nesta seção. Como exemplo, declare um método triple(int) que recebe um int argumento e retorna um int valor.
int triple(int i) {
return i*3;
}
Execute o trecho de código no JShell e um método será criado.
[10]-> int triple(int i) {
return i*3;
}
| created method triple(int)
Invoque o método triplo com um int valor como arg.
triple(1)
O valor do argumento é triplicado e retornado.
[11]-> triple(1) | $13 ==> 3 [12]->
O método tem um tipo de retorno e parâmetros, mas nenhum modificador de acesso, como public , privado , ou protegido . É porque uma declaração de método de nível superior, como todas as declarações de nível superior, é implicitamente pública. Qualquer modificador de acesso em uma declaração de método de nível superior é ignorado. Todas as declarações de método a seguir são equivalentes à declaração de método anterior.
[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 exibe erros em tempo de compilação, se houver. Como exemplo, torne o tipo de retorno do método triplo como String e uma mensagem de erro é exibida.
[10]-> String triple(int i) {
return i*3;
}
| Error:
| incompatible types: int cannot be converted to java.lang.String
| return i*3;
| ^-^
Modificando uma definição de método
Uma mensagem de saída que não seria gerada por um aplicativo Java e listada duas vezes nesta seção é “método substituído…”. A mensagem indica que uma definição de método foi modificada. A provisão para substituir/modificar uma declaração de método e outras declarações é para facilitar o teste.
Para modificar ou substituir um método sem definir um novo método, a assinatura do método, que é definida pelo nome do método e pelos parâmetros do método, incluindo o número de parâmetros e seu tipo e ordem, não deve ser modificada. Como exemplo, declare um método hello com tipo de retorno void e uma String parâmetro de tipo.
[4]-> void hello(String s){
}
| created method hello(String)
Em seguida, declare o mesmo método hello com tipo de retorno String , uma String parâmetro de tipo e uma instrução de retorno. A declaração do método anterior para hello é substituído.
[5]-> String hello(String s){
return "Hello " + s;
}
| replaced method hello(String)
[6]->
Invoque o método hello(String) e a segunda definição de método é invocada para gerar uma mensagem “Hello John”.
[6]-> hello("John")
| $5 ==> "Hello John"
[7]->
Os argumentos do método são concatenados na invocação do método, se necessário, como no trecho a seguir.
[7]-> hello("John"+" & "+"Johnny")
| $22 ==> "Hello John & Johnny"
[8]->
No exemplo anterior de modificação de um método, substituímos o tipo de retorno void com String . Return não precisa ser modificado para substituir um método. Como exemplo, defina um método hello do seguinte modo.
[15]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
Em seguida, modifique apenas o retorno demonstração. O método hello(String,String) é substituído.
[16]-> String hello(String str1, String str2){
return "Hello"+str1+str2;
}
| replaced method hello(String,String)
Como outro exemplo de execução de um trecho de código de método, defina um método hello(String str1, String str2) com tipo de retorno String[] .
[17]->
String[] hello(String str1, String str2){
return new String[]{str1,str2};
}
| created method hello(String,String)
Invoque o método com dois argumentos para retornar uma matriz.
[18]-> hello("John","Michael")
| $39 ==> String[2] { "John", "Michael" }
Método de sobrecarga
Um método pode ser sobrecarregado como em um aplicativo Java. Declare um método hello(String s) .
[1]-> String hello(String s){
return "Hello " + s;
}
| created method hello(String)
Invoque o método para gerar uma mensagem.
[2]-> hello("John")
| $1 ==> "Hello John"
Declare um método diferente hello(String,String) .
[3]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
Invoque o método para gerar uma mensagem.
[5]-> hello("Hello"," John")
| $16 ==> "Hello John"
Fazendo uma referência direta a um método
O JShell suporta fazer referências diretas a um método. Uma referência avançada invoca um método que ainda não foi definido. Declare um método main(String) que faz referência a um método hello(String) , que ainda não foi definido. O método main(String) é criado, mas não pode ser invocado até que o método hello(String) é definido.
[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
Invoca o método main(String) e uma mensagem obtém saída, indicando que não pode ser invocada.
[2]-> main("Michael")
| attempted to call method main(String) which cannot be invoked
| until method hello(java.lang.String) is declared
Declare o método hello(String) que é referenciado por main(String) .
[3]-> String hello(String name){
return name;
}
| created method hello(String)
Em seguida, invoque o método main(String) novamente e é invocado.
[4]-> main("Michael")
| $1 ==> "Hello Michael"
O ";" é adicionado implicitamente se não for adicionado em declarações de variáveis de nível superior e declarações de métodos que são adicionadas uma por linha. Mas o ";" não está implícito em instruções dentro de um método. Como exemplo, declare o método a seguir e um erro será gerado.
[1]-> int average(int i,int j){
return (i+j)/2
}
| Error:
| ';' expected
Métodos de listagem
Os métodos definidos em uma determinada sessão do JShell são listados com o /methods comando. Para demonstrar, defina alguns métodos.
[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)
Execute os /métodos comando e todos os métodos adicionados são listados.
[5]-> /methods | printf (String,Object...)void | triple (int)int | hello (String)String | hello (String,String)String | average (int,int)int [5]->
Modificadores não permitidos em declarações de método de nível superior
Enquanto os modificadores public , privado , e protegido em declarações de método de nível superior são ignoradas e uma definição de método é criada implicitamente com acesso público, alguns outros modificadores não são ignorados e não são permitidos em uma declaração de método de nível superior. Esses modificadores não são permitidos no nível superior porque têm significado dentro de um determinado contexto e não são adequados no contexto do JShell, que é testar trechos de código.
O modificador estático tem significado quando usado com um método no contexto de uma classe ou interface, mas não no nível superior. Como exemplo, execute a seguinte declaração de método que inclui static .
[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)
A estática modificador é ignorado, um aviso é gerado, mas um método é criado. O método pode ser invocado.
[2]-> hello("John")
| $1 ==> "Hello John"
[3]->
Da mesma forma, o modificador final não tem significância no nível superior, seja em uma declaração de método ou em qualquer outra declaração, porque o JShell foi projetado para executar trechos de código dinamicamente e declarar um método (ou variável ou classe) final tornaria o snippet não modificável. Como exemplo, adicione o final modificador de um método. A final modificador é ignorado, um aviso é gerado e a definição do método é criada sem o final .
[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)
Invoque o método e ele gera um resultado.
[3]-> triple(5) | $1 ==> 15 [4]->
Alguns outros modificadores também não são permitidos no nível superior, seja em um método ou em qualquer outra declaração. Enquanto os modificadores static e final são ignorados e uma definição de método é criada, modificadores abstract e nativo em um método de nível superior geram um erro e um método não é criado.
[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){
| ^----^
Modificadores padrão e sincronizado em uma declaração de método de nível superior ou qualquer outra declaração também não são permitidas e geram um erro.
Conclusão
Neste artigo, discutimos a execução de trechos de código para métodos Java no JShell. Em um artigo subsequente, discutiremos a execução de trechos de código para classes, interfaces e arrays Java.
