JShell es una característica nueva en Java 9 para facilitar la ejecución de fragmentos de código. Los fragmentos de código de JShell son exactamente lo mismo que el código fuente de Java en un archivo para una aplicación. Como se discutió en un artículo anterior, "Uso de JShell en Java 9 en NetBeans 9.0, Parte 3", JShell no permite varios modificadores, incluidos predeterminado, acceso, sincronizado, público, privado y protegido, que son compatibles con un archivo de código fuente. . JShell está diseñado principalmente para probar y depurar código Java y no para ejecutar aplicaciones completas. En este artículo de continuación, ejecutaremos fragmentos para clases, interfaces y arreglos. Hemos usado NetBeans 9 como en los artículos anteriores. También discutiremos las excepciones no verificadas. Este artículo tiene las siguientes secciones:
- Uso de clases
- Modificar una clase
- Listado de clases
- Uso de constructores de clases
- Ampliación de una clase
- Anulación de un método
- Uso de interfaces
- Uso de una implementación predeterminada para un método
- Declarar un método de interfaz como estático
- Uso de matrices
- Uso de excepciones no verificadas
- Conclusión
Uso de clases
En esta sección, discutiremos la ejecución de fragmentos de código para clases. Declarar una clase simple C de la siguiente manera.
[1]-> class C {
}
| created class C
Clase C se crea A diferencia de un método que se puede invocar directamente, primero se debe instanciar una clase de la siguiente manera.
[3]-> new C() | $1 ==> [email protected]
Una nueva instancia de la clase C, $1 se crea Al igual que con las declaraciones de métodos, las declaraciones de clases se pueden modificar volviendo a declarar la clase. Una clase puede implementar una interfaz usando implementos . Como ejemplo, declare una interfaz I .
[1]-> interface I{}
| created interface I
Crear clase C para implementar la interfaz I .
[3]-> class C implements I{}
| replaced class C
[4]->
Clase C , creado anteriormente, se reemplaza.
Una declaración de clase en JShell no tiene el concepto de una aplicación como lo tendría una clase Java declarada en un archivo. Una clase Java en un archivo con public static void main(String[] argv) El método es una aplicación Java. El principal de vacío estático público (String[] argv) El método se puede agregar en JShell, pero es solo otro fragmento de código. Crear una clase Hola que incluye el método 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]->
El principal(String[]) el método es un estático y se define para la clase en lugar de una instancia de una clase. Crear una Cadena[] matriz para suministrar a main(String[]) método.
String[] strArray={"Hello"," JShell"}; Invoca el principal(String[]) método con String[] como argumento
Hello.main(strArray)
Se genera un mensaje Hello JShell, como se muestra en la Figura 1.
Figura 1: Invocando método estático en una clase
Modificar una clase
Una clase puede modificarse según sea necesario modificando o eliminando cualquiera de sus declaraciones de métodos o agregando nuevos métodos. Volver a declarar la clase Hola sin el main(String[]) y la clase se reemplaza.
[4]-> class Hello{
}
| replaced class Hello
[5]->
Vuelva a agregar main(String[]) pero con un System.out.println ligeramente diferente declaración. Clase Hola vuelve a ser reemplazado.
[5]-> class Hello{
public static void main(String[] argv)
{System.out.println(argv[0]);}
}
| replaced class Hello
[5]->
Invocar el estático método main(String[]) con Hola.main(strArray) para una salida diferente, como se muestra en la Figura 2.
Figura 2: Invocando una Variación del método main
La provisión para reemplazar una clase es útil cuando se desarrolla una clase. Se puede agregar un método a la vez y probar la clase. Como ejemplo, agregue un segundo método hola(String) . De nuevo, clase Hola es reemplazado.
[9]-> class Hello{
void main(String[] argv){System.out.println(argv[0]);}
String hello(String name){return name;}
}
| replaced class Hello
El método hola(String) agregado, al ser un método de instancia, necesitaría una instancia de clase para invocar. Crea una instancia de clase.
[10]-> new Hello() | $2 ==> [email protected]
Invocar método hola(String) usando instancia de clase $2 .
[11]-> $2.hello("John")
| $6 ==> "John"
Listado de clases
Una clase Java es un tipo. Una interfaz también es un tipo. Todos los tipos definidos en la sesión de JShell se enumeran con /types dominio. Defina algunas clases e interfaces.
[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
Ejecute /types comando y se enumeran todas las clases e interfaces.
[6]-> /types | class C | class D | class B | interface I | interface J
Uso de constructores de clase
La clase sin argumentos se define implícitamente en una clase si no define ningún constructor con argumentos. Previamente habíamos instanciado una clase C que no declaró ningún constructor explícitamente con new C() . El constructor sin argumentos puede definirse explícitamente.
A continuación, cree una clase Hola que declara un constructor de clase. El constructor tiene un parámetro de tipo String . El constructor puede declararse con public modificador y es implícitamente public si no se establece en público .
[6]->
class Hello{
String name;
public Hello(String name){this.name=name;}
void hello(){System.out.println("Hello "+name);}
}
Crea una instancia de la clase Hola .
Hello hello=new Hello("John") Invoque el método de instancia hola() para generar un mensaje, como se muestra en la Figura 3.
Figura 3: Usar una clase con un constructor
Ampliación de una clase
Una clase puede extenderse con extensiones como en un archivo de código fuente de Java. Como ejemplo, cree la clase D que declara un nombre de variable de tipo tt>String, un constructor sin argumentos y un método hello(String) . El hola(String) el método genera un "Hola" mensaje usando el nombre argumento proporcionado.
class D{
String name="Michael";
public D(){}
void hello(String name){System.out.println("Hello "+name);}
}
Crear una clase C que extiende la clase C y declara el hola() método, que no anula la clase D es hola(String) el método y los parámetros son diferentes. El hola() El método invoca un nombre de campo, que se hereda de la clase D .
class C extends D{
void hello(){System.out.println("Hello "+name);}
}
Instanciar clase C e invoque hola() método.
new C().hello()
Aparece un mensaje de "Hola", como se muestra en la Figura 4. El nombre valor de campo establecido en la clase D se utiliza.
Figura 4: Extendiendo una Clase
Si invocamos el hola(String) método que clase C hereda de la clase D , obtendríamos un resultado diferente, como se muestra en la Figura 5.
Figura 5: Invocar un método heredado de una clase extendida
Anulación de un método
Una clase puede anular un método heredado de una clase extendida proporcionando su propia definición de método. Crear una clase D que declara un campo nombre y un método hola() .
class D{
String name="Michael";
void hello(){System.out.println("Hello "+name);}
}
Declarar una clase C que extiende la clase D y anula hola() método. Clase C también oculta el campo nombre .
class C extends D{
String name="John";
void hello(){System.out.println("Hello "+name);
}
Crea una instancia de la clase C e invoque el método hola() .
new C().hello()
El hola() método de la clase C se invoca porque anula el método de la clase D . El campo nombre en clase C oculta el campo nombre en clase D . La salida del mensaje se muestra en la Figura 6.
Figura 6: Anulando un método
Si la clase C no oculta el campo nombre de la clase D , el nombre campo en la clase D se utiliza, como se muestra en la Figura 7.
Figura 7: Accediendo al campo desde la clase extendida
Una clase C el objeto es una instancia de la clase D porque extiende la clase D . Ejecute la siguiente declaración para encontrar si una instancia de la clase C es también una instancia de la clase D .
new C() instanceof D
Un valor de verdadero verifica una instancia de la clase C es también una instancia de la clase D , como se muestra en la Figura 8.
Figura 8: Verificando si una Instancia de Clase C es también una instancia de clase D
Porque una instancia de la clase C es también una instancia de la clase D , puede convertirse en D de la siguiente manera:
D d=(D)(new C());
Posteriormente, acceda al campo nombre para el objeto d de tipo D .
d.name;
E invoque el método hola() para el objeto d de tipo D .
d.hello();
La salida del valor del campo es de la clase D porque d es un objeto de tipo D , como se muestra en la Figura 9. El método hello() invocado es de la clase C .
Figura 9: Convertir un Objeto de tipo C a D
Uso de interfaces
En esta sección, ejecutaremos algunos fragmentos para interfaces en JShell. Una clase existente podría modificarse para implementar una interfaz. Crear clase C .
[1]-> class C{}
| created class C
Crear una interfaz I que define un método hola() .
[2]-> interface I {
String hello();
}
| created interface I
Volver a declarar la clase C para implementar la interfaz I . Clase C proporciona implementación para el método hello() .
[3]-> class C implements I{
public String hello(){
return "Hello JShell";
}
}
| replaced class C
Crea una instancia de la clase C .
[4]-> new C() | $1 ==> [email protected]
Usando la variable de instancia de clase, invoque el método hello() y se muestra la salida del método.
[5]-> $1.hello() | $2 ==> "Hello JShell" [6]->
Porque los métodos en una interfaz son implícitamente públicos mientras que los métodos en una clase no son un método, la implementación en la clase C debe declararse con el público modificador de acceso Si no se declara público , se emite un mensaje de error porque no se especifica un público modificador de acceso predeterminado a un modificador de acceso más débil, que no está permitido cuando se implementa una interfaz.
[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(){
| ^--------------...
Uso de una implementación predeterminada para un método
A partir de Java 8, un método de interfaz puede proporcionar una implementación predeterminada para un método utilizando la palabra clave default . Declare una interfaz que proporcione una implementación predeterminada para el método hello() usando el predeterminado palabra clave.
[1]-> interface I {
default String hello(){
return "Hello JShell";
}
}
| created interface I
Declarar una clase C que implementa la interfaz I .
[2]-> class C implements I{
}
| created class C
Crea una instancia de la clase C e invoque el método hola() . El método de la implementación predeterminada en la interfaz I obtiene salida.
[3]-> new C().hello(); | $1 ==> "Hello JShell"
Declarar un método de interfaz como estático
Desde Java 8, los métodos de interfaz pueden declararse static . Crear una interfaz I que declara un estático método.
[1]-> interface I {
static String hello(){
return "Hello JShell";
}
}
| created interface I
Invoque el método estático usando la interfaz I .
[2]-> I.hello() | $1 ==> "Hello JShell"
Una clase no puede ser declarada final y, si la final se usa el modificador, se ignora.
[5]-> [1]-> final class C{}
| Warning:
| Modifier 'final' not permitted in top-level declarations,
| ignored
| final class C{}
| ^---^
| created class C
Uso de matrices
En esta sección, ejecutaremos algunos fragmentos de código para matrices. Declarar, crear instancias y acceder a matrices no es diferente a una aplicación basada en archivos de código fuente de Java. Como ejemplo, declare una matriz de tipo String[] . La matriz se inicializa en null .
[1]-> String[] strArray; | strArray ==> null
Asigne memoria a la matriz. El tamaño de la matriz, una vez establecido, no se puede modificar. Los elementos de la matriz se inicializan a null .
[2]-> strArray =new String[3];
| strArray ==> String[3] { null, null, null }
Inicialice los elementos de la matriz usando los índices de la matriz.
[3]-> strArray[0]="A"; strArray[1]="B"; strArray[2]="C"; | $4 ==> "A" | $5 ==> "B" | $6 ==> "C"
Muestra la longitud de la matriz y el elemento en el índice 1.
[6]-> strArray.length; strArray[1]; | $9 ==> 3 | $10 ==> "B"
La longitud de la matriz se emite como 3. El elemento en el índice 1 es "B". Una matriz se puede inicializar cuando se declara de la siguiente manera.
[1]-> String[] strArray={"A","B","C"};
| strArray ==> String[3] { "A", "B", "C" }
Muestra la longitud de la matriz.
[2]-> strArray.length; | $1 ==> 3
Muestra el elemento en el índice 0.
[3]-> strArray[0]; | $4 ==> "A" [4]->
Una matriz multidimensional puede declararse como en una aplicación Java. Cree una matriz tridimensional de tipo String[][][] e inicialice la matriz.
[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", ...
Muestra la longitud de la matriz.
[2]-> strArray.length; | $1 ==> 3
Muestra la longitud de la matriz en el índice 0.
[3]-> strArray[0].length; | $4 ==> 2
Muestra la longitud de la matriz en el índice 1 dentro de la matriz en el índice 0.
[4]-> strArray[0][1].length; | $6 ==> 3
Muestra la matriz en el índice 0.
[5]-> strArray[0]
| $10 ==> String[2][] { String[3] { "A", "B", "C" },
| String[3] { "AA", "AB", "AC" } }
Muestra la matriz en el índice 1 dentro de la matriz en el índice 0.
strArray[0][1]
| $11 ==> String[3] { "AA", "AB", "AC" }
Muestra el elemento en el índice 0 en la matriz en el índice 1 dentro de la matriz en el índice 0.
strArray[0][1][0] | $12 ==> "AA" [8]->
Uso de excepciones no verificadas
JShell arroja excepciones no verificadas en tiempo de ejecución. Como ejemplo, si una variable de tipo String que se ha inicializado a su valor predeterminado null se accede. java.lang.NullPointerException es arrojado.
[1]-> String str; | str ==> null [2]-> str.length(); | java.lang.NullPointerException thrown: | at (#2:1) [3]->
Como otro ejemplo, si se accede a un índice de matriz fuera del tamaño de una matriz, java.lang.ArrayIndexOutOfBoundsException es arrojado.
[4]->
String[] str={"A","B","C"};
| str ==> String[3] { "A", "B", "C" }
[5]-> str[3];
| java.lang.ArrayIndexOutOfBoundsException thrown: 3
| at (
Si se invoca un método que define la división por cero, java.lang.ArithmeticException es arrojado.
[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]->
Conclusión
En estos primeros cuatro artículos, analizamos la ejecución de fragmentos de código para variables, instrucciones, métodos, clases, interfaces y matrices. JShell está diseñado para ejecutar solo fragmentos de código y, como tal, algunas de las funciones son diferentes que cuando se ejecuta una aplicación Java completa desde un archivo de código fuente. En dos artículos más, exploraremos algunas otras características de JShell.
