Noms en Java

Vous voulez qu'une ligne d'écriture affiche le mot qu'un nom garde. Sur la page précédente, le mot était entre guillemets sur la ligne d'écriture elle-même, donc changer l'écran voulait dire modifier cette ligne. Sur cette page vous donnez au mot un nom, plant, et la ligne d'écriture utilise ce nom. Les guillemets passent sur la ligne qui garde le mot. System.out.println(plant) n'a pas de guillemets, et l'écran affiche encore leaf. Vous n'installez pas Java une seconde fois. Vous n'ajoutez pas une note, et vous n'apprenez pas une deuxième façon de finir une ligne. Vous savez déjà que println écrit les lettres et finit la ligne. Le travail nouveau est le nom qui garde ces lettres.

Un nom garde les lettres

Ouvrez Mint.java. Le nom du fichier reste Mint.java, parce que public class Mint est encore le nom du fichier. Cette page ne renomme pas le fichier et ne change pas la ligne public class Mint. Dans main, au-dessus de la ligne d'écriture, ajoutez une ligne qui crée un nom et y garde un mot : String plant = "leaf";. String dit que ce nom garde des lettres. plant est le nom, et il commence par un p minuscule. Le signe = garde le mot. Les guillemets contiennent leaf, tout en minuscules, le même mot que la page précédente a mis sur la ligne d'écriture. Le point-virgule finit cette ligne. Ensuite changez la ligne d'écriture pour qu'elle n'ait plus de guillemets. Elle devient System.out.println(plant);. Le nom plant est nu. Pas de guillemet avant le p, pas de guillemet après le t. Enregistrez le fichier.

Le fichier que vous gardez

Enregistrez ceci sous le nom Mint.java. C'est le fichier que cette page garde. Le nom plant garde le mot leaf. La ligne d'écriture utilise ce nom et ne contient pas de guillemets.

Lisez depuis le haut et décidez ce que l'écran peut afficher. public class Mint nomme le fichier. Elle n'écrit pas l'écran. public static void main(String[] args) est l'endroit où Java commence. Aucun de ces mots n'est une lettre pour l'écran. Le mot String de la ligne main n'est pas le String de la ligne suivante. La ligne main est le départ. La ligne suivante est celle qui crée le nom. String plant = "leaf"; garde les lettres l, e, a et f dans le nom plant. Cette ligne n'écrit pas ces lettres sur l'écran. Garder n'est pas écrire. L'écran reste vide jusqu'à la fin de cette ligne. La ligne d'après, System.out.println(plant);, est la ligne d'écriture. Java lit le nom plant, écrit les lettres que ce nom garde, et finit la ligne. L'écran affiche leaf. Une ligne. Sans guillemets. Les lettres du nom lui-même, plant, ne sont pas sur l'écran. System n'est pas sur l'écran. Le point-virgule n'est pas sur l'écran.

Lancez-le de la même façon. Dans le dossier qui contient ce Mint.java, tapez javac Mint.java. Quand le fichier est correct, cette commande n'écrit aucune ligne. Un nom dans le fichier ne fait pas écrire une ligne à javac, et ne le fait pas échouer. Ensuite tapez java Mint. Ne tapez pas .java après java. L'écran affiche leaf. Si l'écran affiche plant, la ligne d'écriture a des guillemets autour de plant. Le fichier que vous gardez n'en a pas. Si l'écran affiche encore mint, le mot gardé est encore mint, ou la ligne d'écriture est encore System.out.println("mint");. Regardez les lettres entre les guillemets de la ligne String, et voyez si la ligne d'écriture utilise le nom nu. Vous ne réinstallez pas Java parce que l'écran affiche le mauvais mot.

Changez le mot, laissez la ligne d'écriture

L'intérêt du nom est que la ligne d'écriture peut rester pendant que le mot gardé change. Sous la première ligne d'écriture, gardez un nouveau mot dans le même nom, puis écrivez le nom une seconde fois. La nouvelle ligne de garde est plant = "stem";. Elle ne commence pas par String. plant existe déjà, donc cette ligne remplace seulement les lettres que le nom garde. stem prend la place de leaf, tout en minuscules. La ligne d'écriture suivante est encore System.out.println(plant);. Elle a la même forme que la première ligne d'écriture. L'écran a maintenant deux lignes, parce que chaque println finit sa ligne. La première ligne est leaf, à partir des lettres que le nom gardait à ce moment. La deuxième ligne est stem, à partir des lettres que le nom garde après plant = "stem";.

C'est le deuxième fichier. Ce n'est pas le fichier que vous gardez. Le fichier que vous gardez a une ligne de garde et une ligne d'écriture, et son écran est leaf. Enregistrez ce deuxième fichier sous le nom Mint.java quand vous voulez voir le mot changer, puis remettez ensuite la seule ligne de garde et la seule ligne d'écriture.

Dans le même dossier, tapez javac Mint.java. Le fichier est correct, donc javac n'écrit aucune ligne. La deuxième ligne de garde peut omettre String, et cette omission ne fait pas échouer javac. Ensuite tapez java Mint. L'écran affiche leaf, et la ligne suivante de l'écran est stem. Deux lignes. leaf est en haut parce que le premier System.out.println(plant); s'exécute pendant que plant garde encore leaf. stem est en dessous parce que le deuxième System.out.println(plant); s'exécute après plant = "stem";. Le nom plant n'est sur aucune des deux lignes de l'écran. Si les deux lignes de l'écran disent leaf, la deuxième ligne de garde manque ou dit encore "leaf". Si les deux disent stem, la première ligne de garde dit déjà "stem", ou la première ligne d'écriture est sous le changement. L'écran suit l'ordre des lignes du fichier. Quand une ligne plus bas garde un nouveau mot, l'ancien mot ne reste pas, et l'écran ne saute pas à stem avant que cette ligne de garde ait été exécutée.

N'écrivez pas String une deuxième fois pour le même nom. String plant = "stem";, sous une ligne qui a déjà créé plant, est une autre erreur. Cette ligne essaie de créer plant encore une fois. javac écrit une erreur et ne reste pas silencieux. Vous n'avez pas besoin du texte exact de cette erreur. Le fait utile est que javac a écrit une ligne, donc vous ne tapez pas encore java Mint. La réparation est d'effacer le deuxième String et de laisser plant = "stem";. Le nom est créé une fois. Les lignes suivantes changent seulement les lettres qu'il garde. Dans le fichier que vous gardez, il n'y a pas de deuxième ligne de garde. Après avoir vu leaf puis stem, remettez ce fichier : un String plant = "leaf"; et un System.out.println(plant);.

Des guillemets autour du nom écrivent le nom

La ligne d'écriture du fichier que vous gardez est System.out.println(plant); sans guillemets. Si vous mettez des guillemets autour du nom, la ligne devient System.out.println("plant");. Ces guillemets font la même chose que les guillemets de la page précédente. Ils marquent des lettres pour l'écran. Les lettres au milieu sont p, l, a, n et t. Java ne cherche pas le nom, parce qu'un mot entre guillemets n'est pas un nom. Le nom plant peut continuer à garder leaf sur la ligne au-dessus, et l'écran affiche plant quand même. Le mot gardé, leaf, n'est pas écrit, parce que la ligne d'écriture n'a jamais utilisé le nom. Elle a utilisé un mot entre guillemets qui s'écrit comme le nom.

C'est le troisième fichier. Ce n'est pas le fichier que vous gardez. Enregistrez-le seulement jusqu'à voir la seule ligne plant, puis enlevez les guillemets de la ligne d'écriture.

Tapez javac Mint.java. Le fichier est correct, donc javac n'écrit aucune ligne. Les guillemets autour de plant sont permis. Ils ne font pas échouer javac. Ils ne font pas non plus afficher le mot gardé à l'écran. Ensuite tapez java Mint. L'écran affiche plant. Une ligne. Sans guillemets. Pas leaf. Pas stem. Si vous vouliez leaf, la ligne d'écriture doit être le nom nu, System.out.println(plant);. Les guillemets vont sur la ligne de garde, autour de leaf, pas sur la ligne d'écriture autour du nom. Un espace à l'intérieur de ces guillemets de garde est aussi gardé. String plant = "leaf "; avec un espace après le f fait écrire à System.out.println(plant); leaf suivi d'un espace. Le fichier que vous gardez n'a pas cet espace. L'écran du fichier que vous gardez est leaf, quatre lettres, puis la ligne finit.

Le nom doit exister d'abord

Java lit le fichier depuis le haut. La ligne qui crée le nom doit être au-dessus de la ligne qui utilise le nom. Si vous placez System.out.println(plant); d'abord, puis que vous écrivez String plant = "leaf";, la ligne d'écriture utilise le nom plant avant que plant existe. javac écrit une erreur. Il ne reste pas silencieux. Il n'y a pas d'écran à lire, parce que vous ne tapez pas java Mint pendant que javac écrit une erreur. La réparation est de remettre la ligne String au-dessus de la ligne d'écriture. L'ordre du fichier est l'ordre dans lequel Java lit. Un nom n'est pas utilisé sur une ligne plus haute que la ligne qui le crée.

Ce quatrième fichier a l'ordre cassé. Ce n'est pas le fichier que vous gardez. Enregistrez-le seulement jusqu'à ce que javac écrive l'erreur, puis remettez la ligne String en haut.

Tapez javac Mint.java. javac écrit une erreur. Ne tapez pas java Mint. Vous n'avez pas besoin des mots exacts de l'erreur. Le fait utile est le même que sur la page précédente, quand les guillemets manquaient : javac a écrit une ligne, donc le fichier n'est pas correct. Placez String plant = "leaf"; au-dessus de System.out.println(plant);. Enregistrez. Tapez javac Mint.java encore une fois. Maintenant javac n'écrit aucune ligne. Ensuite java Mint affiche le mot leaf. Le nom leaf, sans une ligne String leaf nulle part, est encore une erreur, et c'est une erreur différente de celle-ci. System.out.println(leaf); demande un nom qui s'appelle leaf. Ce fichier ne crée pas ce nom. Le nom qu'il crée s'appelle plant, et le mot qu'il y garde est leaf. Le mot et le nom ne sont pas les mêmes lettres. Remettre des guillemets autour de leaf sur la ligne d'écriture, System.out.println("leaf");, rendrait aussi javac silencieux, mais cela vous ramènerait à la page précédente. Cette page laisse le nom nu sur la ligne d'écriture et laisse les guillemets sur la ligne de garde.

Vous pouvez maintenant garder un mot dans un nom et écrire ce mot sans placer le mot lui-même sur la ligne d'écriture. String plant = "leaf"; garde leaf. System.out.println(plant); écrit leaf et finit la ligne. Un plant = "stem"; plus bas change le mot gardé, et un println plus bas du même nom écrit stem. Des guillemets autour du nom écrivent à la place les lettres du nom. La ligne qui crée le nom doit être au-dessus du premier usage du nom. La page suivante lit un mot que vous tapez pendant que le programme s'exécute, et garde ce mot dans un nom, pour que l'écran puisse afficher des lettres qui n'étaient pas entre guillemets dans le fichier.

L'écran est le mot que le nom garde

Le fichier que vous gardez écrit leaf. Le nom sur la ligne d'écriture est plant, et plant n'est pas sur l'écran. Les guillemets sont sur la ligne de garde, autour de leaf. Un println est une ligne. Changer le mot gardé entre deux lignes println ne change que la deuxième ligne de l'écran.