JShell aborde des aspects avancés de l’utilisations de cet outil. On y traitera les sujets de l’import et le référencement de bibliothèques (et de modules) externes à la JRE ainsi que celui de la personnalisation de l’outil. Ce tutoriel fait partie d’une serie de quatre articles qui permettront de se familiariser, suffisament, avec JShell afin de pouvoir l’utiliser efficacement et augmenter la productivité avec le langage de programmation Java:

1. Tutoriel JShell: Installation et concepts
2. Tutoriel JShell: Utilisation
3. Tutoriel JShell: Scripts et scripts de démarrage
4. Cet article: Tutoriel JShell: Personnalisation et Import de librairies externes

1. Import de packages supplémentaires

Lancer JShell sans aucun script de démarrage, sans même DEFAULT. Ceci est possible grâce à la commande:

jshell --no-startup

Ensuite exécuter les deux instructions Java suivantes, l’une après l’autre:

String nomfichier = "fichiertest.txt"
Files.write(Paths.get(nomfichier), "Le contenu du fichier de test\n".getBytes());

La première instruction s’exécute sans erreur. La raison est que la classe String est dans le package java.lang qui n’a pas besoin d’être importé explicitement. En revanche, la deuxième instruction échoue car les classes Files et Paths sont dans le package java.nio.file. Comme dans les programmes Java, pour utiliser ce package dans JShell, on doit d’abord l’importer. Exécuter maintenant:

import java.nio.file.*
Files.write(Paths.get(nomfichier), "Le contenu du fichier de test\n".getBytes());

Astuce: La deuxième commande peut être rappelée avec la touche flèche haut du clavier comme dans le shell système. Maintenant, cette commande s’exécute et crée le fichier fichiertest.txt avec le contenu demandé. Pour vérifier, quitter JShell et retrouvez ce fichier dans le dossier courant.

2. Import de packages et bibliothèques externes

De la même manière que pour les packages Java, on peut référencer les packages d’une bibliothèque externe. Pour pousser cette logique à son extrême, on va créer une « bibliothèque » Java personnelle. Pour simplifier, cette« bibliothèque » sera composée d’une seule classe mais packagée dans un fichier JAR comme il se doit. A l’aide d’un éditeur de texte, créer le fichier Multiplication.java dont le contenu est:

package net.meddeb.mult;
public class Multiplication {
  public void table(int i) {
    for (int j=1; j<=9; j++) {
      System.out.printf("%d x %d = %d\n", i, j, i*j);
    }
  }
}

C’est l’unique classe qui compose la « bibliothèque » de notre exemple. Elle ne contient qu’une methode unique qui affiche la table de multiplication de l’entier passé en paramètre. On va compiler et packager dans le fichier multip.jar cette classe. Ensuite on va l’installer dans un dossier lib/, sous dossier de notre dossier de travail. Pour faire tout cela, exécuter dans l’ordre:

javac Multiplication.java
mkdir -p net/meddeb/mult/
mv Multiplication.class net/meddeb/mult/
jar -c -f multip.jar -M net/
mkdir lib/
mv multip.jar lib/

Pour pouvoir utiliser cette « bibliothèque » personnelle avec JShell, on doit le lancer avec la commande:

jshell --class-path lib/multip.jar

Pour tester l’utilisation de la classe Multiplication, exécuter dans l’ordre:

import net.meddeb.mult.*
Multiplication m = new Multiplication()
m.table(8)

Le paramètre de lancement –class-path permet d’indiquer un ou plusieurs packages externes (à la JRE). Ce paramètre peut également être positionné dans l’environnement JShell grâce à la commande /env. Ceci est particulièrement intéréssant pour inclure ce paramètre dans un script de démarrage par exemple ou même dans un script tout court. Un exemple: créer le fichier de script mult5.jsh dont le contenu est le suivant:

/env -class-path lib/multip.jar
import net.meddeb.mult.*;
Multiplication m = new Multiplication();
m.table(5);
/exit

Ensuite exécutez le avec la commande simple:

jshell mult5.jsh

De la même manière on peut importer des modules, au sens du nouveau concept introduit par Java 9 du terme module. Ceci peut être fait grâce aux paramètres –module-path et –add-modules.

3. Personnalisation de l’environnement JShell

Cette personnalisation consiste en la modification à souhait du mode de retour d’information ou feedback. Il existe trois paramètres à modifier pour le retour d’information: le prompt ou le message d’attente, la troncature et le format. Un mode natif de JShell ne peut pas être supprimé mais on peut le copier, modifier cette copie et l’activer à la place du mode natif. Ensuite le mode natif peut être réactivé à tout moment.

3.1. Personnalisation du message d’attente (prompt)

Dans l’environnement JShell exécuter:

/set prompt

La réponse à cette commande est:

|  /set prompt normal "\njshell> " "   ...> "
|  /set prompt silent "-> " ">> "
|  /set prompt concise "jshell> " "   ...> "
|  /set prompt verbose "\njshell> " "   ...> "

Il s’agit de la liste des formats du message d’attente pour les quatres modes de retour d’information prédéfinis: normal, silent, concise et verbose.  Pour commencer la personnalisation, on va copier le mode normal pour créeer le mode personnalisé modetuto. Pour cela exécuter:

/set mode modetuto normal -command

Maintenant, on peut modifier le message de prompt de ce mode pour le personnaliser. Deux paramètres sont à modifier: le message d’attente normal et celui à utiliser dans le cas de saisie de plusieurs lignes de suite, comme dans le cas de céation de méthode. Exécuter:

/set prompt modetuto "\n[Tutoriel JShell:] "  "[...............:] "

Pour tester le nouveau prompt, il faut l’activer:

/set feedback modetuto

JShell passe immédiatement au nouveau mode qui est identique au mode normal sauf en ce qui concerne le message de prompt car on l’a modifié.

3.2. Personnalisation de la troncature

Le paramètre de troncature permet de personnaliser l’affichage des valeurs trop larges (généralement des chaines de caractères) en tronquant cet affichage. Exécuter:

/set truncation modetuto

Le retour de cette commande indique les valeurs actuelles de ce paramètre qui sont hérités du mode normal. Ces valeurs veulent dire:

1. Toute valeur à afficher dont la taille est supérieure ou égale à 80 caractères sera tronquée.
2. Une exception est faites pour l’affichage des expressions qui ne sera tronquée qu’à partir de 1000 caractères.

Pour tester ce comportement, exécuter:

String b = String.join("", Collections.nCopies(7, "abcdefghij"));
String b = String.join("", Collections.nCopies(8, "abcdefghij"));
System.out.println(String.join("", Collections.nCopies(8, "abcdefghij")));

abcdefghij, sont les 10 premiers caractères de l’alphabet. La première instruction permet de dupliquer cet ensemble de caractères 7 fois, ce qui donne 70 caractères. Le résultat de cette instruction n’est pas tronqué. En revanche celui de la deuxième instruction qui donne 80 caractères est tronqué. La troisième instruction affiche le résultat d’une expression, la limite est donc repoussée à 1000, c’est pour cela que le résultat de cet affichage n’est pas tronqué. Modifions maintenant ce paramètre:

/set truncation modetuto 30
String b = String.join("", Collections.nCopies(3, "abcdefghij"));

La deuxième instruction permet de vérifier que la troncature est bien effectuée à partir de 30 caractères.

3.3. Personnalisation du format

Exécuter dans l’environnement JShell:

/set format modetuto

La réponse montre la richesse et la compléxité de ce paramètre. Ceci provient du fait qu’il concerne l’affichage des messages de retour des commandes dans différentes circonstances. Faute de pouvoir aborder les détails de ce paramétrage, on va se contenter d’un un exemple. Pour le détail il faudra consulter l’aide de ce paramètre qui peut être affiché avec:

/help format

Pour l’exemple, exécuter:

import java.net.*

Cette commande ne retourne aucun message d’information, même pas pour dire que tout s’est bien passé. On peut remedier à cela en personnalisant le paramètre format de notre modetuto:

/set format modetuto display "{pre}added import {name}{post}" import-added
/set format modetuto display "{pre}re-added import {name}{post}" import-modified,replaced

Après cela, exécuter une deuxième fois la commande d’import. Grâce à cette personnalisation, on a désormais un message de retour claire.

4. Persistence de la personnalisation de l’environnement JShell

Si on quitte JShell après avoir personnalisé l’environnement tel que cela a été vu dans le paragraphe précédent, la personnalisation sera perdue. Pour faire perdurer ce paramétrage il faudra exécuter:

/set mode modetuto -retain

Avec cette commande, même si on quitte JShell, le paramétrage modetuto n’est pas perdu mais ne sera pas activé par défaut au démarrage. Pour le rendre actif de manière permanente, il faudra exécuter:

/set feedback modetuto -retain

]]>

JShell aborde des aspects avancés de l’utilisations de cet outil. On y traitera les sujets de la création de scripts Java avec JShell et celui des scripts de démarrage. Ce tutoriel fait partie d’une serie de quatre articles qui permettront de se familiariser, suffisament, avec JShell afin de pouvoir l’utiliser efficacement et augmenter la productivité avec le langage de programmation Java:

1. Tutoriel JShell: Installation et concepts
2. Tutoriel JShell: Utilisation
3. Cet article: Tutoriel JShell: Scripts et scripts de démarrage
4. Tutoriel JShell: Personnalisation et Import de librairies externes

1. Scripts JShell

Lancer JShell et exécuter les trois instructions Java suivantes, l’une après l’autre dans l’ordre indiqué:

char c = 'D'
int rang = (int)c - 64
System.out.printf("D est la lettre de rang %d dans l'alphabet\n", rang)

Comme attendu, à chaque fois JShell répond immédiatement pour donner le résultat de l’instruction. Maintenant on peut visualiser l’ensemble de ces instructions par:

/list

On obtient une liste numérotée de l’historique des instructions exécutées depuis le début de la session (remarquer l’ajout automatique des points-virgules à la fin des lignes):

   1 : char c = 'D';
   2 : int rang = (int)c - 64;
   3 : System.out.printf("D est la lettre de rang %d dans l'alphabet\n", rang);

Il est possible de sauvegarder cette suite d’instructions Java dans un fichier pour constituer un script JShell:

/save premierscript.jsh

Pour vérifier le succés de l’opération, quitter Jshell (commande /exit) et visualiser le contenu du fichier de script fraîchement créé:

cat premierscript.jsh

Bien entendu on aurait pu, également, créer ce script directement avec un éditeur de texte. Maintenant qu’on a ce fichier de script on peut l’exécuter à partir du Shell système par:

jshell premierscript.jsh

Cette commande donne le résultat:

D est la lettre de rang 4 dans l'alphabet
|  Welcome to JShell -- Version 10.0.2
|  For an introduction type: /help intro
jshell>_

La première ligne de la réponse montre bien que le script a été exécuté. Le problème est qu’on se trouve à la fin dans l’environnement de l’outil. Ce comportement n’est souvent pas souhaitable. Pour remedier à cet inconvénient, on doit modifier le contenu du script. Quitter JShell, éditer le fichier premierscript.jsh pour y ajouter à la fin la commande JShell: /exit. Avec cette nouvelle version du script, on retournera au Shell système à la fin de l’exécution. Deux enseignements sont à retenir de cette manipulation:

1. On doit ajouter la commande /exit à la fin d’un script si on souhaite se retrouver dans le Shell système à la fin de son exécutionn, ce qui est souvent le cas.
2. On peut combiner des instructions Java et des commandes JShell dans un script JShell.

2. Scripts de démarrage

Un script de démarrage JShell est un script tel qu’on vient de le voir dans le paragraphe précédent qui est exécuté automatiquement par l’environnement de l’outil dans les deux cas suivant:

1. Au démarrage de l’environnement en utilisant le paramètre –startup <NomDuScript>
2. A l’exécution de l’une des commandes: /env, /reset et /reload

Ce comportement est utile pour paramétrer à souhait JShell. Il existe trois scripts de démarrage prédéfinis qui peuvent assurer un paramétrage minimal:

1. DEFAULT : exécuté par défaut, même si on ne l’invoque pas. C’est à dire même si on n’utilise pas le paramètre –startup pour lancer JShell.
2. PRINTING : Assure un paramétrage qui facilite l’affichage des données
3. JAVASE : Permet d’utiliser toutes les librairies de Java SE

Pour s’en rendre compte, exécuter:

jshell --startup PRINTING

Cette commande, lance JShell avec le script de démarrage prédéfini PRINTING (au lieu de DEFAULT donc). Exécuter ensuite:

printf("Le nombre %d est le double du chiffre %d", 10, 5)

Cette instruction n’est pas conforme à la syntaxe Java, pourtant elle s’exécute sans erreur. Pour illucider ce mystère, exécuter dans l’ordre:

/reset
/open PRINTING
/list

La première comande permet de remettre l’environnement à zéro. La seconde permet de charger le script PRINTING. La troisième liste le contenu de ce script. On se rend compte, grâce à ces commandes, que le script PRINTING définit une série de méthodes qui servent toutes à l’affichage de données dont la méthode utilisé printf(…). Ceci explique l’exécution sans erreur de cette instruction. Quitter JShell et relancer le sans aucun paramètre:

jshell
|  Welcome to JShell -- Version 10.0.2
|  For an introduction type: /help intro

jshell>_

Exécuter maintenant:

printf("Le nombre %d est le double du chiffre %d", 10, 5)

On obtient le message d’erreur:

|  Error:
|  cannot find symbol
|    symbol:   method printf(java.lang.String,int,int)
|  printf("Le nombre %d est le double du chiffre %d", 10, 5)
|  ^----^

Ce qui est tout à fait normal puisque cette fois c’est DEFAULT qui s’est exécuté au démarrage et il ne contient pas la définition de cette méthode. Vérifions:

/reset
/open DEFAULT
/list

Le script DEFAULT se contente d’importer un nombre limité de packages du JRE. On peut conclure que par défaut on ne peut utiliser que ces packages (en plus de java.lang.* qui est utilisable sans besoin de l’importer) dans l’environnement JShell.

3. Scripts de démarrage personnalisés

De même qu’avec les scripts prédéfinis, on peut utiliser un script personnalisé pour le démarrage de JShell. Généralement, le script de démarrage sert à configurer l’environnement pour mieux l’utiliser: import de packages, référencement de modules, définitions de méthodes.. Lancer JShell sans aucun paramètre. Dans ces conditions, c’est le script de démarrage par défaut qui sera utilisé. Ensuite, exécuter l’instruction Java suivante, qui permet de déterminer si un site web répond correctement en renvoyant le statut HTTP d’une requête GET:

HttpClient.newHttpClient().send(HttpRequest.newBuilder().uri(new URI("http://www.meddeb.net")).build(), HttpResponse.BodyHandler.asString()).statusCode()

L’exécution de l’instruction échoue. La raison de cet echec est l’utilisation de classes Java qui font partie d’un module et de packages non visibles dans l’environnement JShell. De plus, aucun des 3 scripts prédéfinis ne permet d’importer les pré-requis nécessaires à cette exécution. A l’aide d’un éditeur de texte crééer un ficher de script personnalisé http.jsh, dont le contenu est:

/env --add-modules jdk.incubator.httpclient
import jdk.incubator.http.*
import java.net.*

Lancer JShell avec ce script de démarrage personnalisé:

jshell --startup http.jsc

Maintenant JShell est configuré convenablement pour exécuter la commande précédente qui a échoué. Relancer cette commande. Si le site fonctionne normalement au moment de l’exécution, la réponse sera égale à 200, le code qui correspond à un statut « Tout va bien ».]]>

JShell est une démonstration par la pratique de l’utilisation (et l’utilité) de cet outil. Comme c’est souvent le cas dans ce site personnel, c’est une succession d’exercices pratiques à effectuer et se rendre compte du résultat par soit même. Il s’agit ici de l’utilisation courante de l’outil dans ses deux volets: les commandes JShell et l’exéction d’instructions Java. Cet tutoriel fait partie d’une serie de quatres articles qui permettront de se familiariser, suffisament, avec JShell afin de pouvoir l’utiliser efficacement et augmenter la productivité avec Java:

1. Tutoriel JShell: Installation et concepts
2. Cet article: Tutoriel JShell: Utilisation
3. Tutoriel JShell: Scripts et scripts de démarrage
4. Tutoriel JShell: Personnalisation et Import de librairies externes

1. Les variables dans JShell

Quand on exécute une instruction Java qui retourne une valeur, JShell crée automatiquement une variable pour y stocker cette valeur. Exécuter dans l’environnement JShell:

10 + 15

L’affichage de retour indique qu’une variable qui s’appelle $1 contient le résultat de cette opération simple:

$1 ==> 25

On peut obtenir plus d’information à ce sujet grâce à la commande JShell:

/vars

Cette commande affiche la liste des variables en indiquant leurs types. On peut également améliorer le retour d’information immédiat. Exécuter:

/set feedback verbose

Si on exécute, après cela, l’opération d’addition modifiée:

10.2 + 15.3

Maintenant le retour immédiat est plus explicite. JShell nous informe tout de suite qu’il a créé une variable $2 de type double et affiche son contenu. Remarquer que les variables créées implicitement portent un nom qui commence par le caractère $ suivi par un indice qui s’incrémente à chaque nouvelle création. On remarque également que le type de la variable créée s’adapte au type du résultat de l’instruction exécutée. Les variables peuvent être également indiquées explicitement avec un nom plus significatif. Dans ce cas le type doit être également indiqué:

double rayon = $2

Vérifier avec la commande /vars que le contenu de la variable rayon est bien égale à celui de la variable $2. Le résultat d’une instruction peut également être affecté à une variable explicite:

double surface = Math.pow(rayon,2) * Math.PI

Ce qui calcule la surface d’un cercle en élevant son rayon au carré et en multipliant le résultat par π .

2. Vérifier le comportement de Java avec JShell

Une des applications importantes de JShell est de pouvoir vérifier rapidement les résultats retournés par des instructions Java. Exécuter les trois instructions suivantes l’une après l’autre:

Math.round(23.4999999)
Math.round(23.5000001)
Math.round(23.5000000)

Ce test montre que la methode Math.round(double) retourne bien la valeur arrondie à l’entier le plus proche du décimal passé en paramètre (les deux premières exécutions). Il montre surtout que si la valeur est à mi-chemin entre deux valeurs entières, c’est l’entier supérieur qui est retourné. Maintenant, on se propose de tester un comportement, souvent mal compris, des instances de classes. Mais d’abord partons d’un environnement propre. Exécuter:

/vars
/list

La session JShell accumule, au fur et à mesure qu’on l’utilise, une liste de variables et d’instructions (snippets) qui ont été créées et exécutées. On peut remettre l’environnement à zéro, notamment pour commencer de nouveaux tests. Pour cela exécuter:

/reset

Après une éventuelle vérification, exécuter les instructions dans l’ordre:

Date d1 = new Date()
Date d2 = d1
Date d3 = (Date)d1.clone()
/vars

La dernière commande permet d’afficher les 3 variables d1, d2 et d3 avec leur valeur qui est la même. Maintenant, modifions la valeur de d1 pour mettre l’heure à minuit:

d1.setHours(0)
/vars

L’explication du résultat, qui est tout à fait normal, est que la variable qui contient une instance de classe n’est en réalité qu’une référence d’un emplacement mémoire qui contient, lui, les données de cette instance. Il faut comprendre le contenu de ces variables comme une adresse de mémoire et non l’instance elle-même. Ceci dit, les trois instructions font ce qui suit:

1. Créé une instance de la classe Date et affecte la référence à cette instance (adresse mémoire de l’instance) à la variable d1.
2. Affecte la valeur de d1 à d2. C’est la référence à l’instance qui est affectée. Donc d1 et d2 pointent sur la même instance.
3. La méthode clone() créé une nouvelle instance dont les données sont identiques à l’instance clonée. d3 contient donc la référence d’une autre instance de la classe Date.

3. Tester le code d’une méthode

A titre d’exemple, on se propose de développer une méthode qui calcule la clé d’un numéro de sécurité sociale en France. Bien qu’assez triviale, cette méthode nécessite plusieurs instructions qui s’enchaînent. Pour saisir l’ensemble du code, suivre le contenu qui correspond à une ligne de code par l’appui sur la touche [ENTREE], comme dans tout IDE. Commençon par la première ligne:

long cle(String numero) {

Après la touche [ENTREE], JShell répond par:

...>

Et attend la suite des lignes. Continuer la saisie, ligne par ligne:

...> String n = numero.replaceAll("2A", "18");
...> n = n.replaceAll("2B", "19");
...> long ln = Long.parseLong(n);
...> long resultat = 97 - (ln % 97);
...> return resultat;
...> }

A la saisie de la dernière ligne qui constitue, syntaxiquement, la fin de la méthode, JShell termine la saisie et affiche un message qui nous informe (sous reserve qu’il n’y a pas d’erreur de saisie) que la méthode a été créée. On peut le vérifier par la commande:

/methods

On peut également l’exécuter:

cle("2690299341732")

Bien entendu vous pouvez utiliser votre propre numéro de sécurité sociale (les 13 chiffres) pour calculer et vérifier la clé. Ceux qui sont nées en Corse remarqueront qu’il y a un bug dans ce code qu’il faudra, donc, corriger. Pour le faire on doit éditer la méthode. C’est la commande edit qui permet cela. D’abord parametrons un éditeur de texte disponible sur le système utilisé. Pour ma part j’utilise vi:

/set edit vi

Puis

/edit cle

L’éditeur paramétré s’ouvre avec le texte du code de la méthode et on peut alors le modifier. Remplacer le nombre 18 dans la 2eme ligne par 19 et le nombre 19 dans la 3eme ligne par 18. Ensuite enregistrer la modification et quitter.]]>

JShell est l’utilitaire Shell (ou REPL, pour Read Eval Print Loop) du langage de programmation Java. Un tel outil manquait cruellement à Java jusqu’à sa récente version 9 où il a été introduit. JShell permet d’augmenter considérablement la productivité du développement avec ce langage. Il permet, notament, d’ffectuer de manière très simple, rapide et intéractive des tests d’exécution d’instructions Java (snippets). Cet article a pour objectif de présenter la manière d’installer ainsi que les concepts d’utilisation de cet outil. Il fait partie d’une serie de quatre articles qui permettront de se familiariser, suffisament, avec JShell afin de pouvoir l’utiliser efficacement et augmenter la productivité avec Java:

1. Cet article: Tutoriel JShell: Installation et concepts
2. Tutoriel JShell: Utilisation
3. Tutoriel JShell: Scripts et scripts de démarrage
4. Tutoriel JShell: Personnalisation et Import de librairies externes

1. Installer JShell

JShell fait partie du JDK. Il a été introduit à la version 9 de Java et de ce fait il faudra installer au minimum la version 9 du JDK pour pouvoir y avoir accéder. Sur Ubuntu installer la variante headless d’OpnenJDK 9 ou plus.

sudo apt install openjdk-11-jdk-headless

Après cela JShell sera disponible. La vérification peut se faire par la commande:

jshell -version

Cette commande répond par l’affichage de la version de JShell. La version majeure retournée (premier nombre) doit être la même que celle du JDK installé.

2. Les bases de fonctionnement de JShell

JShell est utilisé, principalement, de manière interactive. Son interface est une console interactive en ligne de commande. Pour y accéder utiliser la commande:

jshell

Suite à cela on obtient le prompt suivant qui attend la saisie de commandes à la syntaxe JShell ou Java.

|  Welcome to JShell -- Version 10.0.1
|  For an introduction type: /help intro

jshell> _

A chaque commande introduite (saisie de la commande + [Entrée] du clavier), JShell répond immédiatement par l’affichage du résultat de la commande ou par un message d’erreur si la syntaxe est fausse ou qu’une erreur d’exécution s’est produite.

• Les commandes propres à JShell commencent toujours par le caractère slash: /
• Toute commande introduite qui ne commence pas par ce caractère doit être conforme à la syntaxe Java.

3. Les commandes JShell

Ces commandes qui commencent obligatoirement par le caractère slash servent à contrôler le fonctionnement de l’outil. Une commande particulière permet d’avoir une aide à propos de ces commandes:

/help

Affiche une liste exhaustive des commandes disponibles (relative à la version utilisée, bien entendu). On peut également afficher l’aide d’une commande en particulier quand on connait sa syntaxe:

/help exit

Affiche une aide sur la commande JShell exit. Grâce à cette commande, on sait maintenant qu’il faudra utiliser la commande /exit pour quitter la console JShell. De la même manière, déterminer la fonction de la commande history. Ensuite utiliser cette commande pour voir le résultat:

/history

Cette commande permet d’afficher l’hitorique de toutes les commandes exécutées depuis le début de la session JShell courante. Si tout va bien le résultat devrait être donc:

/help
/help exit
/history

4. Exécuter une instruction Java

Dans la console JShell exécuter la commande:

exit

La réponse est un message d’erreur. Pourtant, on l’a vu, exit est bel et bien une commande correcte de JShell. L’explication est dans l’absence du caractère slash au début. Cette absense fait en sorte que JShell considère qu’il s’agit d’une instruction Java. exit n’est pas une instruction Java valide, d’où l’erreur. Exécuter maintenant l’instruction (faire attention à la syntaxe, le mieux est de faire un copier/coller):

"Java JShell".substring(5,11)

La réponse doit être:

$1 ==> "JShell"

Cette réponse signifie que maintenant une variable appelée $1 contient la valeur chaine de caractère ‘JShell‘. Explication: A l’exécution de l’instruction Java qui retourne un résultat, JShell crée une variable qui s’appelle $x, x étant un nombre entier, et lui affecte le résultat de l’instruction. Ensuite il affiche le contenu de cette variable. Pour s’en rendre compte, exécuter maintenant:

System.out.println($1)

La méthode substring(iDebut, iFin) de la classe String, retourne une sous chaine de caractère qui commence à l’indice de cracatère iDebut et fini à l’indice iFin. D’où le résultat obtenu. Exécuter maintenant l’instruction modifiée:

"Java JShell".substring(5,12)

L’indice de caractère (de fin) maximum dans cette chaine étant 11 (car elle contient 11 caractères), cette instruction lève l’exception java.lang.StringIndexOutOfBoundsException exactement comme à son exécution dans un programme Java.]]>