JShell est une nouvelle fonctionnalité de Java 9 pour faciliter l'exécution d'extraits de code. Les extraits de code JShell sont exactement les mêmes que le code source Java dans un fichier pour une application. Comme indiqué dans un article précédent, "Utilisation de JShell dans Java 9 dans NetBeans 9.0, Partie 3", JShell n'autorise pas plusieurs modificateurs - y compris par défaut, accès, synchronisé, public, privé et protégé - qui sont pris en charge dans un fichier de code source . JShell est conçu principalement pour tester et déboguer du code Java et non pour exécuter des applications complètes. Dans cet article de continuation, nous exécuterons des extraits pour les classes, les interfaces et les tableaux. Nous avons utilisé NetBeans 9 comme dans les articles précédents. Nous aborderons également les exceptions non contrôlées. Cet article comporte les sections suivantes :
- Utiliser des cours
- Modifier une classe
- Classes de liste
- Utiliser des constructeurs de classe
- Étendre une classe
- Surcharger une méthode
- Utiliser des interfaces
- Utiliser une implémentation par défaut pour une méthode
- Déclarer une méthode d'interface comme étant statique
- Utiliser des tableaux
- Utilisation d'exceptions non contrôlées
- Conclusion
Utiliser les cours
Dans cette section, nous aborderons l'exécution d'extraits de code pour les classes. Déclarer une classe simple C comme suit.
[1]-> class C {
}
| created class C
Classe C se crée. Contrairement à une méthode qui peut être invoquée directement, une classe doit d'abord être instanciée comme suit.
[3]-> new C() | $1 ==> [email protected]
Une nouvelle instance de la classe C, $1 se crée. Comme pour les déclarations de méthode, les déclarations de classe sont modifiables en redéclarant la classe. Une classe peut implémenter une interface en utilisant implementes . Par exemple, déclarez une interface I .
[1]-> interface I{}
| created interface I
Créer la classe C pour implémenter l'interface I .
[3]-> class C implements I{}
| replaced class C
[4]->
Classe C , créé précédemment, est remplacé.
Une déclaration de classe dans JShell n'a pas le concept d'application comme le ferait une classe Java déclarée dans un fichier. Une classe Java dans un fichier avec le public static void main(String[] argv) méthode est une application Java. Le public static void main(String[] argv) La méthode peut être ajoutée dans JShell mais n'est qu'un autre extrait de code. Créer une classe Bonjour qui inclut la méthode 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]->
Le principal(String[]) la méthode est un statique méthode et est défini pour la classe plutôt qu'une instance d'une classe. Créer une chaîne[] tableau à fournir au main(String[]) méthode.
String[] strArray={"Hello"," JShell"}; Appelez le main(String[]) méthode avec la String[] comme argument.
Hello.main(strArray)
Un message Hello JShell obtient une sortie, comme illustré à la figure 1.
Figure 1 : Invoquer une méthode statique dans une classe
Modifier une classe
Une classe peut être modifiée selon les besoins en modifiant ou en supprimant l'une de ses déclarations de méthode ou en ajoutant de nouvelles méthodes. Re-déclarer la classe Hello sans le main(String[]) méthode et la classe est remplacée.
[4]-> class Hello{
}
| replaced class Hello
[5]->
Rajoutez le main(String[]) méthode mais avec un System.out.println légèrement différent déclaration. Classe Bonjour est à nouveau remplacé.
[5]-> class Hello{
public static void main(String[] argv)
{System.out.println(argv[0]);}
}
| replaced class Hello
[5]->
Appelez le statique méthode main(String[]) avec Hello.main(strArray) pour une sortie différente, comme illustré à la figure 2.
Figure 2 : Invoquer une variante de la méthode main
La disposition pour remplacer une classe est utile lors du développement d'une classe. Une méthode peut être ajoutée à la fois et testée en classe. Par exemple, ajoutez une deuxième méthode hello(String) . Encore une fois, la classe Bonjour est remplacé.
[9]-> class Hello{
void main(String[] argv){System.out.println(argv[0]);}
String hello(String name){return name;}
}
| replaced class Hello
La méthode hello(String) ajouté, étant une méthode d'instance, aurait besoin d'une instance de classe à invoquer. Créez une instance de classe.
[10]-> new Hello() | $2 ==> [email protected]
Invoquer la méthode hello(String) en utilisant l'instance de classe $2 .
[11]-> $2.hello("John")
| $6 ==> "John"
Liste des classes
Une classe Java est un type. Une interface est aussi un type. Tous les types définis dans la session JShell sont répertoriés avec /types commande. Définissez quelques classes et 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
Exécutez le /types commande et toutes les classes et interfaces sont listées.
[6]-> /types | class C | class D | class B | interface I | interface J
Utiliser des constructeurs de classe
La classe sans argument est implicitement définie dans une classe si elle ne définit aucun constructeur avec des arguments. Nous avions précédemment instancié une classe C qui n'a déclaré aucun constructeur explicitement avec new C() . Le constructeur sans argument peut être défini explicitement.
Ensuite, créez une classe Hello qui déclare un constructeur de classe. Le constructeur a un paramètre de type String . Le constructeur peut être déclaré avec le public modificateur et est implicitement public s'il n'est pas défini sur public .
[6]->
class Hello{
String name;
public Hello(String name){this.name=name;}
void hello(){System.out.println("Hello "+name);}
}
Créer une instance de la classe Hello .
Hello hello=new Hello("John") Invoquez la méthode d'instance hello() pour générer un message, comme illustré à la figure 3.
Figure 3 : Utiliser une classe avec un constructeur
Étendre une classe
Une classe peut être étendue avec des extensions comme dans un fichier de code source Java. Par exemple, créez la classe D qui déclare un nom de variable de type tt>String, un constructeur sans argument et une méthode hello(String) . Le bonjour(String) la méthode renvoie un "Hello" message en utilisant le nom arg fourni.
class D{
String name="Michael";
public D(){}
void hello(String name){System.out.println("Hello "+name);}
}
Créer une classe C qui étend la classe C et déclare le hello() méthode, qui ne remplace pas la classe D c'est bonjour(String) la méthode et les paramètres sont différents. Le bonjour() la méthode invoque un nom de champ, qui est hérité de la classe D .
class C extends D{
void hello(){System.out.println("Hello "+name);}
}
Instancier la classe C et invoquez hello() méthode.
new C().hello()
Un message "Hello" est généré, comme illustré à la figure 4. Le nom valeur de champ définie dans la classe D est utilisé.
Figure 4 : Prolonger un cours
Si nous invoquons le hello(String) méthode qui classe C hérite de la classe D , nous obtiendrions une sortie différente, comme le montre la figure 5.
Figure 5 : Invoquer une méthode héritée d'une classe étendue
Surcharger une méthode
Une classe peut remplacer une méthode héritée d'une classe étendue en fournissant sa propre définition de méthode. Créer une classe D qui déclare un champ nom et une méthode hello() .
class D{
String name="Michael";
void hello(){System.out.println("Hello "+name);}
}
Déclarer une classe C qui étend la classe D et remplace le hello() méthode. Classe C masque également le champ nom .
class C extends D{
String name="John";
void hello(){System.out.println("Hello "+name);
}
Créer une instance de la classe C et invoquez la méthode hello() .
new C().hello()
Le bonjour() méthode de la classe C est invoqué car il remplace la méthode de la classe D . Le champ nom en classe C masque le champ nom en classe D . La sortie du message est illustrée à la figure 6.
Figure 6 : Surcharger une méthode
Si classe C ne masque pas le champ nom de la classe D , le nom champ dans la classe D est utilisé, comme le montre la figure 7.
Figure 7 : Accéder au champ depuis la classe étendue
Une classe C l'objet est une instance de la classe D car il étend la classe D . Exécutez l'instruction suivante pour déterminer si une instance de la classe C est aussi une instance de la classe D .
new C() instanceof D
Une valeur de true vérifie une instance de la classe C est aussi une instance de la classe D , comme illustré à la figure 8.
Figure 8 : Vérifier si une instance de classe C est également une instance de classe D
Parce qu'une instance de classe C est aussi une instance de la classe D , il peut être converti en D comme suit :
D d=(D)(new C());
Ensuite, accédez au champ nom pour l'objet d de type D .
d.name;
Et, invoquez la méthode hello() pour l'objet d de type D .
d.hello();
La sortie de la valeur du champ provient de la classe D parce que d est un objet de type D , comme le montre la figure 9. La méthode hello() invoqué provient de la classe C .
Figure 9 : Conversion d'un objet de type C en D
Utilisation des interfaces
Dans cette section, nous exécuterons quelques extraits pour les interfaces dans JShell. Une classe existante peut être modifiée pour implémenter une interface. Créer la classe C .
[1]-> class C{}
| created class C
Créer une interface I qui définit une méthode hello() .
[2]-> interface I {
String hello();
}
| created interface I
Re-déclarer la classe C pour implémenter l'interface I . Classe C fournit l'implémentation de la méthode hello() .
[3]-> class C implements I{
public String hello(){
return "Hello JShell";
}
}
| replaced class C
Créer une instance de la classe C .
[4]-> new C() | $1 ==> [email protected]
À l'aide de la variable d'instance de classe, appelez la méthode hello() et la sortie de la méthode s'affiche.
[5]-> $1.hello() | $2 ==> "Hello JShell" [6]->
Parce que les méthodes d'une interface sont implicitement publiques alors que les méthodes d'une classe ne sont pas une méthode, implémentation dans la classe C doit être déclaré auprès du public modificateur d'accès. Si non déclaré public , un message d'erreur est généré car vous ne spécifiez pas de public le modificateur d'accès est par défaut un modificateur d'accès plus faible, ce qui n'est pas autorisé lors de l'implémentation d'une interface.
[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(){
| ^--------------...
Utiliser une implémentation par défaut pour une méthode
Depuis Java 8, une méthode d'interface peut fournir une implémentation par défaut pour une méthode en utilisant le mot-clé default . Déclarez une interface qui fournit une implémentation par défaut pour la méthode hello() en utilisant la par défaut mot-clé.
[1]-> interface I {
default String hello(){
return "Hello JShell";
}
}
| created interface I
Déclarer une classe C qui implémente l'interface I .
[2]-> class C implements I{
}
| created class C
Créer une instance de la classe C et invoquez la méthode hello() . La méthode de l'implémentation par défaut dans l'interface I obtient la sortie.
[3]-> new C().hello(); | $1 ==> "Hello JShell"
Déclarer une méthode d'interface comme étant statique
Depuis Java 8, les méthodes Interface peuvent être déclarées static . Créer une interface I qui déclare un statique méthode.
[1]-> interface I {
static String hello(){
return "Hello JShell";
}
}
| created interface I
Appelez la méthode statique en utilisant l'interface I .
[2]-> I.hello() | $1 ==> "Hello JShell"
Une classe ne peut pas être déclarée finale et, si la finale modificateur est utilisé, il est ignoré.
[5]-> [1]-> final class C{}
| Warning:
| Modifier 'final' not permitted in top-level declarations,
| ignored
| final class C{}
| ^---^
| created class C
Utiliser des tableaux
Dans cette section, nous exécuterons quelques extraits de code pour les tableaux. La déclaration, l'instanciation et l'accès aux tableaux ne sont pas différents de ceux d'une application basée sur un fichier de code source Java. Par exemple, déclarez un tableau de type String[] . Le tableau est initialisé à null .
[1]-> String[] strArray; | strArray ==> null
Allouez de la mémoire à la baie. La taille du tableau, une fois définie, ne peut pas être modifiée. Les éléments du tableau sont initialisés à null .
[2]-> strArray =new String[3];
| strArray ==> String[3] { null, null, null }
Initialisez les éléments du tableau à l'aide des indices du tableau.
[3]-> strArray[0]="A"; strArray[1]="B"; strArray[2]="C"; | $4 ==> "A" | $5 ==> "B" | $6 ==> "C"
Sortez la longueur du tableau et l'élément à l'index 1.
[6]-> strArray.length; strArray[1]; | $9 ==> 3 | $10 ==> "B"
La longueur du tableau est sortie sous la forme 3. L'élément à l'index 1 est "B". Un tableau peut être initialisé lorsqu'il est déclaré comme suit.
[1]-> String[] strArray={"A","B","C"};
| strArray ==> String[3] { "A", "B", "C" }
Afficher la longueur du tableau.
[2]-> strArray.length; | $1 ==> 3
Sortir l'élément à l'index 0.
[3]-> strArray[0]; | $4 ==> "A" [4]->
Un tableau multidimensionnel peut être déclaré comme dans une application Java. Créez un tableau tridimensionnel de type String[][][] et initialiser le tableau.
[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", ...
Afficher la longueur du tableau.
[2]-> strArray.length; | $1 ==> 3
Afficher la longueur du tableau à l'index 0.
[3]-> strArray[0].length; | $4 ==> 2
Afficher la longueur du tableau à l'index 1 dans le tableau à l'index 0.
[4]-> strArray[0][1].length; | $6 ==> 3
Sort le tableau à l'index 0.
[5]-> strArray[0]
| $10 ==> String[2][] { String[3] { "A", "B", "C" },
| String[3] { "AA", "AB", "AC" } }
Affiche le tableau à l'index 1 dans le tableau à l'index 0.
strArray[0][1]
| $11 ==> String[3] { "AA", "AB", "AC" }
Affiche l'élément à l'index 0 dans le tableau à l'index 1 dans le tableau à l'index 0.
strArray[0][1][0] | $12 ==> "AA" [8]->
Utiliser des exceptions non contrôlées
JShell lève des exceptions non vérifiées lors de l'exécution. Par exemple, si une variable de type String qui a été initialisé à sa valeur par défaut null est accessible. java.lang.NullPointerException est lancé.
[1]-> String str; | str ==> null [2]-> str.length(); | java.lang.NullPointerException thrown: | at (#2:1) [3]->
Comme autre exemple, si un index de tableau en dehors de la taille d'un tableau est accédé, java.lang.ArrayIndexOutOfBoundsException est lancé.
[4]->
String[] str={"A","B","C"};
| str ==> String[3] { "A", "B", "C" }
[5]-> str[3];
| java.lang.ArrayIndexOutOfBoundsException thrown: 3
| at (
Si une méthode qui définit la division par zéro est invoquée, java.lang.ArithmeticException est lancé.
[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]->
Conclusion
Dans ces quatre premiers articles, nous avons discuté de l'exécution d'extraits de code pour les variables, les instructions, les méthodes, les classes, les interfaces et les tableaux. JShell est conçu pour exécuter uniquement des extraits de code et, à ce titre, certaines des fonctionnalités sont différentes de celles de l'exécution d'une application Java complète à partir d'un fichier de code source. Dans deux autres articles, nous explorerons d'autres fonctionnalités de JShell.
