JShell es una herramienta de línea de comandos para ejecutar fragmentos de código en un entorno de shell sin tener que compilar y ejecutar una aplicación completa. JShell es una característica nueva en Java 9. JShell podría usarse para probar y depurar fragmentos de código al desarrollar una aplicación. La entrada de JShell debe tener la forma de un fragmento de código completo. Presentamos JShell con dos artículos, "Uso de JShell en Java 9 en NetBeans 9.0, Parte 1" y "Uso de JShell en Java 9 en NetBeans 9.0, Parte 2", en los que analizamos la ejecución de import instrucción, declarar y usar variables, comparar String s y sentencias en ejecución. En este artículo de continuación, ejecutaremos fragmentos para métodos Java. Este artículo tiene las siguientes secciones:
- Configuración del entorno
- Uso de métodos
- Modificación de una definición de método
- Sobrecarga de métodos
- Hacer una referencia directa a un método
- Métodos de listado
- Modificadores no permitidos en declaraciones de métodos de nivel superior
- Conclusión
Configuración del entorno
Descargue e instale NetBeans, como se explicó en un artículo anterior. Inicie JShell seleccionando Herramientas>Abrir Java Platform Shell , como se muestra en la Figura 1.
Figura 1: Herramientas>Abrir Java Platform Shell
Uso de métodos
Un método se declara en JShell tal como lo es en una aplicación Java, con algunas diferencias, que también se analizan en esta sección. Como ejemplo, declare un método triple(int) eso toma un int argumento y devuelve un int valor.
int triple(int i) {
return i*3;
}
Ejecute el fragmento de código en JShell y se creará un método.
[10]-> int triple(int i) {
return i*3;
}
| created method triple(int)
Invoque el método triple con un int valor como argumento
triple(1)
El valor del argumento se triplica y se devuelve.
[11]-> triple(1) | $13 ==> 3 [12]->
El método tiene un tipo de devolución y parámetros, pero no tiene un modificador de acceso como public , privado , o protegido . Esto se debe a que la declaración de un método de nivel superior, como todas las declaraciones de nivel superior, es implícitamente pública. Se ignora cualquier modificador de acceso en una declaración de método de nivel superior. Todas las siguientes declaraciones de métodos son equivalentes a la declaración de métodos 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 muestra errores en tiempo de compilación, si los hay. Como ejemplo, haga que el tipo de retorno del método triple como Cadena y se muestra un mensaje de error.
[10]-> String triple(int i) {
return i*3;
}
| Error:
| incompatible types: int cannot be converted to java.lang.String
| return i*3;
| ^-^
Modificación de una definición de método
Un mensaje de salida que no sería generado por una aplicación Java y que ya aparece dos veces en esta sección es "método reemplazado...". El mensaje indica que se ha modificado una definición de método. La disposición para reemplazar/modificar una declaración de método y otras declaraciones es para facilitar las pruebas.
Para modificar o reemplazar un método sin definir un nuevo método, no se debe modificar la firma del método, que se establece mediante el nombre del método y los parámetros del método, incluido el número de parámetros y su tipo y orden. Como ejemplo, declare un método hola con tipo de retorno void y una Cadena tipo de parámetro.
[4]-> void hello(String s){
}
| created method hello(String)
A continuación, declare el mismo método hola con tipo de retorno String , una Cadena parámetro de tipo y una declaración de retorno. La declaración del método anterior para hola es reemplazado.
[5]-> String hello(String s){
return "Hello " + s;
}
| replaced method hello(String)
[6]->
Invoca el método hola(String) y la definición del segundo método se invoca para generar un mensaje "Hola John".
[6]-> hello("John")
| $5 ==> "Hello John"
[7]->
Los argumentos del método se concatenan en la invocación del método, si es necesario, como en el siguiente fragmento.
[7]-> hello("John"+" & "+"Johnny")
| $22 ==> "Hello John & Johnny"
[8]->
En el ejemplo anterior de modificación de un método, reemplazamos el tipo de retorno void con Cadena . Return no tiene que modificarse para reemplazar un método. Como ejemplo, defina un método hola de la siguiente manera.
[15]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
A continuación, modifique solo el retorno declaración. El método hola(String,String) es reemplazado.
[16]-> String hello(String str1, String str2){
return "Hello"+str1+str2;
}
| replaced method hello(String,String)
Como otro ejemplo de ejecución de un fragmento de código de método, defina un método hello(String str1, String str2) con tipo de retorno String[] .
[17]->
String[] hello(String str1, String str2){
return new String[]{str1,str2};
}
| created method hello(String,String)
Invoque el método con dos argumentos para devolver una matriz.
[18]-> hello("John","Michael")
| $39 ==> String[2] { "John", "Michael" }
Sobrecarga de métodos
Un método puede estar sobrecargado como en una aplicación Java. Declarar un método hola(String s) .
[1]-> String hello(String s){
return "Hello " + s;
}
| created method hello(String)
Invoque el método para generar un mensaje.
[2]-> hello("John")
| $1 ==> "Hello John"
Declare un método diferente hola(String,String) .
[3]-> String hello(String str1, String str2){
return str1+str2;
}
| created method hello(String,String)
Invoque el método para generar un mensaje.
[5]-> hello("Hello"," John")
| $16 ==> "Hello John"
Hacer una referencia directa a un método
JShell admite hacer referencias directas a un método. Una referencia hacia adelante invoca un método que aún no ha sido definido. Declarar un método main(String) que hace referencia a un método hola(String) , que aún no ha sido definido. El método main(String) se crea pero no se puede invocar hasta el método hello(String) está 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
Invocar método main(String) y se genera un mensaje que indica que no se puede invocar.
[2]-> main("Michael")
| attempted to call method main(String) which cannot be invoked
| until method hello(java.lang.String) is declared
Declare el método hola(String) al que hace referencia main(String) .
[3]-> String hello(String name){
return name;
}
| created method hello(String)
Posteriormente, invoque el método main(String) de nuevo y se invoca.
[4]-> main("Michael")
| $1 ==> "Hello Michael"
Él ";" se agrega implícitamente si no se agrega en declaraciones de variables de nivel superior y declaraciones de métodos que se agregan una por línea. Pero el ";" no está implícito en declaraciones dentro de un método. Como ejemplo, declare el siguiente método y se generará un error.
[1]-> int average(int i,int j){
return (i+j)/2
}
| Error:
| ';' expected
Métodos de listado
Los métodos definidos en una sesión de JShell determinada se enumeran con /methods dominio. Para demostrarlo, defina algunos 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)
Ejecute los /métodos comando, y todos los métodos agregados se enumeran.
[5]-> /methods | printf (String,Object...)void | triple (int)int | hello (String)String | hello (String,String)String | average (int,int)int [5]->
Modificadores no permitidos en declaraciones de métodos de nivel superior
Mientras que los modificadores public , privado y protegido en las declaraciones de métodos de nivel superior se ignoran y se crea implícitamente una definición de método con acceso público, otros modificadores no se ignoran y no están permitidos en una declaración de método de nivel superior. Estos modificadores no están permitidos en el nivel superior porque tienen importancia dentro de un determinado contexto y no son adecuados en el contexto de JShell, que es para probar fragmentos de código.
El modificador estático tiene importancia cuando se usa con un método en el contexto de una clase o una interfaz, pero no en el nivel superior. Como ejemplo, ejecute la siguiente declaración de método que incluye 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)
La estática se ignora el modificador, se emite una advertencia, pero se crea un método. El método puede ser invocado.
[2]-> hello("John")
| $1 ==> "Hello John"
[3]->
Del mismo modo, el modificador final no tiene importancia en el nivel superior, ya sea en una declaración de método o cualquier otra declaración, porque JShell está diseñado para ejecutar fragmentos de código de forma dinámica y declarar un método (o variable, o clase) final haría que el fragmento no se pudiera modificar. Como ejemplo, agregue el final modificador de un método. El final se ignora el modificador, se genera una Advertencia y se crea la definición del método sin el 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 el método y generará un resultado.
[3]-> triple(5) | $1 ==> 15 [4]->
Algunos otros modificadores tampoco están permitidos en el nivel superior, ya sea en un método o en cualquier otra declaración. Mientras que los modificadores static y final se ignoran y se crea una definición de método, los modificadores abstract y nativo en un método de nivel superior genera un error y no se crea un método.
[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 predeterminado y sincronizado en una declaración de método de nivel superior o cualquier otra declaración tampoco están permitidas y generan un error.
Conclusión
En este artículo, analizamos la ejecución de fragmentos de código para métodos Java en JShell. En un artículo posterior, analizaremos la ejecución de fragmentos de código para clases, interfaces y matrices de Java.
