Aller au menu - Aller au contenu

[Plan du site] Vous êtes ici --- > Le Site du Zéro > Les tutoriels > Officiels > Programmation > Liste de toutes les notes

Programmation en Java

Auteur : cysboy
Créé : le 21/06/2006 15:02:22
Modifié : le 03/07/2008 21:59:14
Avancement : 40%
Imprimer tout le tutoriel
Bonjour à tous, amis Zéros ! :D

Bienvenue dans mon cours de programmation en Java. C'est un langage très utilisé, notamment par un grand nombre de programmeurs professionnels, ce qui en fait un langage incontournable actuellement.

Voici les caractéristiques de Java en quelques mots :


Comme vous le voyez, Java permet de réaliser une très grande quantité d'applications différentes ! Mais... comment apprendre un langage si vaste qui offre autant de possibilités ? o_O

Heureusement, ce cours est là pour tout vous apprendre de Java à partir de zéro :) .

Application Java Application Java Application Java
Exemples de programmes réalisés en Java


N.B. : je tiens à faire une dédicace spéciale à ptipilou, zCorrecteur émérite, sans qui ce tuto n'aurait pas vu le jour !
Un grand merci pour ton travail et ton soutien ! :)
Ce cours est composé des parties suivantes :

Partie 1 : Bien commencer en Java

Bon, vous ne connaissez rien à Java ? Eh bien c'est par ici que ça se passe ! Java est normalement un langage fait pour développer des applications graphiques, mais pour arriver à cela, nous devons tout de même passer par la programmation Java en mode console.

Donc, dans cette première partie, nous allons voir les bases du langage, ainsi que leur fidèle compagnon Eclipse.

Parlons d'Eclipse

Pour ceux qui l'avaient deviné, Eclipse est le petit logiciel qui va nous permettre de développer nos applications, ou nos applets, et aussi celui qui va compiler tout ça.
Eh oui ! Java est un langage compilé. Je ne l'avais pas dit, je crois... :-°

Donc, notre logiciel va permettre de traduire nos futurs programmes Java en langage compilé. Mais celui-ci ne peut pas être compris par l'ordinateur. Ce code compilé s'appelle du Byte Code. Il n'est compréhensible que par un environnement Java, vulgairement appelé JRE (Java Runtime Environment) disponible sur le site de Sun MicroSystems.

Préambule

Avant toute chose, quelques mots sur le projet Eclipse.

Eclipse IDE est un environnement de développement libre permettant potentiellement de créer des projets de développement mettant en œuvre n'importe quel langage de programmation (C++, PHP...). Eclipse IDE est principalement écrit en Java.

La spécificité d'Eclipse IDE vient du fait de son architecture est totalement développée autour de la notion de plug-in. Cela signifie que toutes les fonctionnalités de celui-ci sont développées en tant que plug-in. Pour faire court, si vous voulez ajouter des fonctionnalités à Éclipse, vous devez :


Lorsque vous téléchargez un nouveau plug-in pour Éclipse, celui-ci se présente souvent comme un dossier contenant généralement deux sous-dossiers. Un dossier « plugins » et un dossier « features ». Ces dossiers existent aussi dans le répertoire d'Éclipse. Il vous faut donc copier le contenu des dossiers de votre plug-in dans le dossier correspondant dans Éclipse (plugins dans plugins, et features dans features).


C'est pour toutes ces raisons que j'ai choisi Eclipse comme outil de développement ; de plus, vous verrez qu'il est relativement simple d'utilisation.

Maintenant que ces quelques mots ont été dits, je vous invite donc à passer à l'étape suivante.

Téléchargement

Avant de vous lancer dans le téléchargement d'Éclipse, vous devez avant tout vous assurer d'avoir un environnement Java, ou JRE sur votre machine.

Un JRE (ou Java Runtime Environment) va vous servir à lire les programmes qui ont été codés en Java. Comme je vous l'ai dit plus tôt, Eclipse est codé en Java : donc, pour utiliser Eclipse, il vous faut un JRE.


Rendez-vous donc sur la page de téléchargement des JRE sur le site de SUN Microsystem (fondateur du langage).
Choisissez le suivant (dernière version stable) :

Image utilisateur


Une fois cliquez sur "Download", vous arrivez sur cette page :

Image utilisateur


Sélectionnez votre système d'exploitation (ici, j'ai mis Windows) et n'oubliez pas de cocher la case : "I agree to the Java SE Development Kit 6 License Agreement".
Afin d'accepter la licence !

Vous voilà arrivé à la dernière ligne droite :

Image utilisateur


Cliquez sur le lien du haut pour une installation en ligne, ou celui du bas pour une installation hors ligne ! ^^

Euh... ça veut dire quoi, JSE ?

Alors on va faire simple. Je vous ai dit plus tôt que Java permet de développer différents types d' applications. Eh bien il faut des outils différents pour les différents types d'applications.



Voilà, fin de l'aparté...

Vous pouvez maintenant télécharger et installer votre JRE. Ceci fait, je vous invite donc à télécharger Éclipse IDE sur cette page.
Accédez à la page de téléchargement puis choisissez "Éclipse IDE for java developers", en choisissant la version d'Eclipse correspondant à votre OS.

Image utilisateur


Sélectionnez maintenant le miroir que vous souhaitez utiliser pour obtenir Éclipse. Voilà, vous n'avez plus qu'à attendre la fin du téléchargement. :D

Installation

Maintenant que vous avez un JRE et que vous avez téléchargé Éclipse, nous allons voir comment nous servir de celui-ci.

Vous devez maintenant avoir une archive contenant Éclipse. Décompressez-la où vous voulez, puis, entrez dans ce dossier. Si comme moi vous êtes sous Windows, vous devriez avoir ceci :

Image utilisateur


Ne travaillant pas sous Mac OS ni sous Linux, je ne peux malheureusement pas vous proposer de screenshot pour ces OS, mais je pense que ça doit fortement y ressembler... ^^
La suite sera donc pour Windows, mais cela ne doit pas être très différent sur les autres OS.


Ensuite, si vous le souhaitez, vous pouvez créer un raccourci de l'exécutable "eclipse.exe" pour pouvoir y accéder plus facilement. Ceci fait, lancez Eclipse.

Peu de temps après, vous devriez avoir une fenêtre comme celle-ci :

Image utilisateur


Ici, Eclipse vous demande dans quel dossier vous souhaitez enregistrer vos projets. Libre à vous de choisir celui-ci. J'ai coché la checkbox pour qu'Éclipse se souvienne de ma décision. Mais lorsque vous créerez des projets, rien ne vous empêche de spécifier un autre dossier que celui de votre "workspace".

Une fois cette étape effectuée, vous arrivez sur la page d'accueil d'Éclipse. Je n'ai jamais trop regardé ce que celle-ci propose ; donc, si vous avez envie de jeter un coup d'?il, allez-y. :p

Présentation rapide de l'interface

Je vais maintenant vous faire faire un tour rapide de l'interface que vous propose Eclipse, en gros, des éléments dont nous allons nous servir dans ce tutoriel.

Je ne connais malheureusement pas toutes les fonctionnalités d'Eclipse... :-°
Par conséquent, je peux très bien omettre certains points qui peuvent être importants pour d'autres développeurs. Merci de me tenir au courant le cas échéant.

Avant de commencer, regardez bien les raccourcis clavier présents dans les menus... Ils sont très utiles et peuvent vous faire gagner beaucoup de temps !

On est obligés ?

Bien sûr que non, mais croyez-moi, quand on y a goûté, on ne peut plus s'en passer...

Allez, trêve de bavardages, on est partis. ;)

Menu "File"

Image utilisateur


C'est ici que nous pourrons créer de nouveaux projets Java, enregistrer ceux-ci, les exporter le cas échéant...
Ici, les raccourcis à retenir sont :


* classe : on y reviendra.



Menu "Edit"

Image utilisateur


Dans ce menu, nous pourrons utiliser les commandes "copier", "coller"...
Ici, les raccourcis à retenir sont :




Menu "Window"

Image utilisateur


Dans celui-ci, nous pourrons configurer Eclipse selon nos besoins.


La barre de navigation

Image utilisateur


Nous avons dans l'ordre :


Je vous demande maintenant de créer un nouveau projet Java. Vous devriez arriver à cette fenêtre sans trop de difficultés :

Image utilisateur


Renseignez le nom de votre projet comme je l'ai fait plus haut (encadré 1). Vous pouvez aussi voir où sera enregistré ce projet (encadré 2).
Un peu plus compliqué maintenant, vous avez donc un environnement Java sur votre machine, mais dans le cas où vous en auriez plusieurs, vous pouvez aussi spécifier à Eclipse quel JRE utiliser pour ce projet.

En fait, vous pourrez changer ceci à tout moment dans Eclipse en allant dans Window / Préférences, en dépliant l'arbre "Java" dans la fenêtre et en choisissant "Installed JRE".
Par contre, n'utilisez ça que si vous êtes sûrs de vous ! :-°


Vous devriez avoir un nouveau projet dans la fenêtre de gauche, comme ceci :

Image utilisateur


Pour boucler la boucle, ajoutons dès maintenant une nouvelle classe dans ce projet. Je suis sûr que vous allez y arriver sans moi... :D
Vous êtes donc devant cette fenêtre :

Image utilisateur


Dans l'encadré 1, nous pouvons voir où seront enregistrés nos fichiers Java.
Dans l'encadré 2, nommez votre classe Java, moi j'ai sdz1.
Dans l'encadré 3, Eclipse vous demande si cette classe a un truc particulier. Eh bien oui ! Cochez
"public static void main(String[] args)", puis cliquez sur "finish" (nous allons revenir sur ce dernier point dans la partie suivante).

Une fois ces opérations terminées, vous êtes devant ceci :

Image utilisateur


Alors avant de commencer à coder, nous allons un peu explorer notre espace de travail.

Dans l'encadré vert (à gauche), vous trouverez le dossier de votre projet ainsi que son contenu. Ici, vous pourrez gérer votre projet comme bon vous semble (ajout, suppression...).

Dans l'encadré bleu (au centre), je pense que vous avez deviné... C'est ici que nous allons écrire nos codes sources.

Dans l'encadré rose (en bas), c'est là que vous verrez apparaître le contenu de vos programmes ainsi que les erreurs éventuelles ! :D

Et enfin pour finir, dans l'encadré violet (à droite), dès lors que nous aurons appris à coder nos propres fonctions ainsi que des objets, c'est ici que la liste des méthodes et des variables sera affiché.

Maintenant que vous avez Eclipse bien en main, nous allons faire un tour rapide des autres IDE de développement pour Java.

D'autres outils à la hauteur

Surtout gardez en mémoire qu'un IDE est un outil de développement.
Comment ça, je ne vous l'avais pas dit... :-°

Ce qu'il faut garder en tête, c'est qu'un IDE, comme n'importe quel outil, est :

Ce que j'entends par là, c'est que comme un menuisier, vous utiliserez des outils pour travailler et comme lui, vous choisirez celui qui vous convient le mieux. Partez du principe que les IDE ont grosso-modo les mêmes fonctionnalités, compiler en byte code, exécuter, debugger...

Les IDE de la liste suivante sont tout aussi adaptés qu'Eclipse pour développer en Java. A vous de vous faire un avis. Testez, comparez et choisissez.

1. JBuilder


Image utilisateur


Celui-ci est idéal pour le développement à grande échelle, pour les projets d'entreprise, etc.
Il intègre tout un tas de technologies comme XML, jsp/servlet, concept d'ingénierie, outils UML...

C'est simple : je crois même qu'il fait du café... :p
Tout ceci fait de lui un outil puissant, mais très lourd pour les configurations moyennes.

En gros, vous serez peut-être amenés à l'utiliser, mais en entreprise...

Bon : pour les curieux de nature, vous pouvez faire un tour ici.
Ne cherchez pas de version gratuite, JBuilder est payant. Mais je crois que vous pouvez avoir une version d'évaluation... A vérifier... :-°










2. NetBeans



Image utilisateur


NetBeans est l'IDE créé par Sun Microsystems, il contient donc toutes les fonctionnalités d'un bon IDE :


De plus, il semblerait qu'on puisse customiser l'environnement de celui-ci.

Si vous voulez vous faire une opinion, ce que je vous conseille vivement, vous pouvez le télécharger ici.





Il existe bien d'autres IDE pour développer en Java, mais ceux-ci (Eclipse compris) représentent la majorité des IDE utilisés. En voici d'autres, pour information :


Qu... Quoi ? On peut faire des programmes Java avec le Bloc-notes de Windows ?

Tout à fait... ^^
En fait, lorsque vous créerez un programme Java dans votre IDE préféré et que vous l'exécuterez, celui-ci va pré-compiler votre code Java en byte code pour qu'ensuite votre JVM (Java Virtual Machine, cf chapitre suivant) l'interprète et l'exécute.

Mais toutes ces étapes peuvent être faites à la main, en ligne de commande, mais nous n'en parlerons pas maintenant.

Bon, je crois qu'il est temps pour un petit QCM... :pirate:
Voilà ! Une partie pénible de terminée !
Par contre, Eclipse regorge de fonctionnalités. Je n'en ai pas parlé pour le moment car je pense que vous comprendrez mieux le moment venu, avec un exemple concret d'utilisation.

J'espère que vous avez encore de l'énergie, car, dans le chapitre suivant, nous aborderons quelque chose de bien plus passionnant... :D
Bon ! Tenez-vous prêts pour faire vos premiers codes Java ! ! :pirate:

Votre premier programme

Dans ce chapitre, nous allons faire nos premiers programmes en Java.
Mais tout d'abord, quelques explications sur le fonctionnement du JRE s'imposent.
Alors... go !

Mieux connaitre son environnement Java

Bon : cette partie s'annonce riche en informations et pour certains, elle sera même "pompeuse"... Mais afin de bien coder en Java, il vaut mieux comprendre comment tout cela fonctionne.

Dans le JRE, que je vous ai fait télécharger dans la partie précédente, se trouve le coeur même de Java. Celui-ci s'appelle la JVM (pour Java Virtual Machine) que j'appellerai dorénavant machine virtuelle. Celle-ci a pour rôle, comme je vous l'ai dit dans le chapitre précédent, d'exécuter les programmes Java sur votre machine, c'est ce qui fait que les programmes Java sont dit "portables".

Qu'est-ce tu entends par là ?

J'allais y venir... :p

Comme je vous l'ai à maintes fois répété, les programmes Java sont, avant d'être utilisés par la machine virtuelle, pré-compilés en byte code (par votre IDE ou encore à la main). Ce byte code n'est compréhensible que par une JVM, et c'est celle-ci qui va faire le lien entre ce code et votre machine.

Vous aviez sûrement remarqué que sur la page de téléchargement du JRE, plusieurs liens étaient disponibles :

Ceci car la machine virtuelle Java se présente différemment selon qu'on se trouve sous Mac, sous Linux ou encore sous Windows. Par contre le byte code, lui, reste le même quelque soit l'environnement où a été développé et pré-compilé votre programme Java.

Conséquence directe :
quel que soit l'OS sous lequel a été codé un programme Java, n'importe quelle machine pourra l'exécuter si elle dispose d'une JVM !


Tu n'arrêtes pas de nous rabâcher byte code par-ci... byte code par-là...
Mais c'est quoi, au juste ?

Eh bien un byte code - et je dis bien UN byte code - n'est autre qu'un code intermédiaire entre votre code Java et le code machine.
Ce code particulier se trouve dans les fichiers pré-compilés de vos programmes ; en Java, un fichier source a l'extension .java et un fichier pré-compilé a l'extension .class ; c'est dans ce dernier que vous pourrez voir du byte code.

Par contre, vos fichiers .java sont de bêtes fichiers texte, seule l'extension est changée... Vous pouvez donc les ouvrir, les créer ou encore les mettre à jour avec... le Bloc-notes de Windows par exemple... ;)

Pour en revenir à notre byte code, je vous invite à regarder un fichier .class à la fin de cette partie (vous en aurez au moins un), mais je vous préviens, c'est illisible ! ! ^^

Inutile de vous dire que votre machine est incapable d'interpréter du byte code !

Alors pourquoi je vous ai dit UN byte code ? Tout simplement parce que la machine virtuelle de Java se moque que le byte code soit à la base du Java ou autre chose.
Son rôle est d'interpréter ce code et de le faire fonctionner. Donc, si un jour vous arrivez à faire du byte code avec comme fichier source un .cpp (pour C++), ça devrait (et j'insiste sur le devrait) fonctionner.

Vous pouvez avoir un aperçu de ce qui devrait fonctionner sur cette page.

Ce qu'il faut retenir :


Je pense qu' après cette partie purement théorique, vous avez hâte de commencer à taper des lignes de code... Mais avant, il me reste quelques choses à vous dire ! :p

Avant de commencer

Avant de commencer, vous devez savoir que tous les programmes Java sont composés d'au moins une classe.
Cette classe doit contenir (applet mise à part) une méthode main. Celle-ci est la méthode principale du programme, c'est elle que la JVM va chercher afin de lancer votre programme. Pour faire court, c'est le point de départ du programme.
Vous voyez donc son importance ! :)
Et pour qu'on se comprenne bien, une méthode est une suite d'instructions à exécuter. Une méthode contient :

Vous verrez, un peu plus tard, qu'un programme n'est qu'une multitude de classes qui s'utilisent l'une l'autre.
Mais pour le moment, nous n'allons travailler qu'avec une seule classe.

Dans la partie précédente, je vous avais demandé de créer un projet Java ; ouvrez-le si ce n'est pas déjà fait. Donc pour rappel, voici ce que vous aviez sous votre nez :

Image utilisateur


Vous voyez la fameuse classe dont je vous parlais ? Ici, elle s'appelle sdz1.
Vous pouvez voir que le mot class est précédé du mot public, nous verrons la signification de celui-ci lorsque nous programmerons des objets.

Pour le moment, ce que vous devez retenir c'est que votre classe est définie par un mot clé, class, qu'elle a un nom ; ici, sdz1 et que le contenu de celle-ci est délimité par des accolades, {}.

Comme je vous l'ai dit plus haut, notre unique classe contient la méthode main. La syntaxe de cette méthode est toujours la même :
Code : Java
1
2
3
public static void main(String[] args){
// Contenu de votre classe
}

Ce sera entre les accolades de la méthode main que nous écrirons nos codes sources.
Excuse-nous, mais... Pourquoi tu as écrit "//Contenu de votre classe" et non "Contenu de votre classe" ?

Bonne question ! :D
Je vous ai dit plus haut que votre programme Java, avant de pouvoir être exécuté, doit être pré-compilé en byte code. Eh bien la possibilité de forcer le compilateur à ignorer certaines instructions existe ! :o
On appelle ça des commentaires et il existe deux syntaxes :

Code : Java
1
2
3
4
5
6
public static void main(String[] args){
//Un commentaire
//un autre
//Encore un autre
Ceci n'est pas un commentaire ! ! ! !
}




Code : Java
1
2
3
4
5
6
7
8
9
public static void main(String[] args){
 
/*
Un commentaire
Un autre
Encore un autre
*/
Ceci n'est pas un commentaire ! ! 
}


D'accord ! Mais ça sert à quoi ?

C'est simple : au début, vous ne ferez que de très petits programmes.
Mais dès que vous aurez pris de la bouteille, la taille de ceux-ci, ainsi que le nombre de classes qui les composera, augmentera.
Vous serez contents de trouver quelques lignes de commentaires au début de votre classe pour vous dire à quoi elle sert, ou encore des commentaires dans une méthode qui fait des choses compliquées afin de savoir ou vous en êtes dans vos traitements... ^^

Il existe en fait une troisième syntaxe, mais celle-ci à un but particulier. Elle permettra de générer une documentation de votre programme ! Une Javadoc (Java Documentation).
Je n'en parlerai que très peu, et pas dans ce chapitre. Nous verrons cela lorsque nous programmerons des objets mais, pour les curieux, je vous conseille le très bon tutoriel de dworkin.

Je profite de cet aparté sur les commentaires pour vous donner une astuce bien pratique !
Il vous arrivera forcément à un moment donné de vouloir mettre une partie de code en commentaire. Dans ce cas, il y a 99,99999999 % de chance que vous choisissiez les commentaires multilignes.
L'inconvénient, c'est que lorsque vous voudrez remettre votre morceau de code en activité, il vous faudra retirer les /* */. Mais si 5 minutes plus tard, vous voulez remettre la même portion de code en commentaire >_< .

Regardez ce morceau de code (il ne fait rien du tout, c'est un exemple) :
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public static void main(String[] args){
 
 String str = "toto";
 int entier = 0;
 
 if(entier != 0){
 
/*
  for(int i = 0; i < 20; i++){
    System.out.println("oui ! ! ! ! !");
  }
//*/
 
 }
}


Vous pouvez voir que j'ai utilisé les commentaires multilignes ! Mais avec une variante... :-°
La ligne qui ferme les commentaires est précédée... de //. Mais c'est ce qui met une ligne en commentaires...
C'est idiot de mettre ça là... Ils sont en commentaire !

Je le sais bien, et c'est là qu'est l'astuce. Pour le moment, les deux // sont en commentaires comme les lignes qui se trouvent entre /* et */.
Mais que se passe-t-il si j'ajoute un / devant ma première instruction de commentaire ?
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public static void main(String[] args){
 
 String str = "toto";
 int entier = 0;
 
 if(entier != 0){
 
//*
  for(int i = 0; i < 20; i++){
    System.out.println("oui ! ! ! ! !");
  }
//*/
 
 }
}


Eh bien là, ce sont mes commentaires multilignes qui sont devenus des commentaires, et mes lignes sont de nouveau actives dans mon code ! :waw:

Explique-nous ça !

C'est très simple. Le fait d'ajouter un / devant /* met l'étoile en commentaire... Dans ce cas, il ne s'agit plus d'un commentaire multilignes, mais uniligne ! Et là je crois que vous avez deviné l'utilité de cette ligne //*/... Sur celle-ci, c'est l'instruction de commentaire multiligne fermante qui est en commentaire ! ;)
Donc, plus besoin d'ajouter de commentaire, d'en effacer, de les remettre, de les ré-effacer...
Vous encadrez la portion de code que vous souhaitez enlever de /* .... //*/ et lorsque vous la voulez à nouveau, vous ajoutez un / devant l'instruction ouvrante des commentaires ! Et si vous voulez remettre la même portion de code en commentaire, enlevez le / ajouté devant /* !

A partir de maintenant et jusqu'à ce que nous programmions des interfaces graphiques, nous allons faire ce qu'on appelle des programmes procéduraux. Cela signifie que le programme se déroulera de façon procédurale.

Euh... késako ?

En fait, un programme procédural est un programme qui s'effectue de haut en bas, une ligne après l'autre.
Bien sûr, il y a des instructions qui permettent de répéter des morceaux de code, mais le programme en lui même se terminera une fois arrivé à la fin du code.
Ceci vient en opposition à la programmation événementielle (ou graphique) qui elle, est basée sur des événements (clic de souris, choix dans un menu...).

Je pense que j'ai fait le tour de ce que je voulais vous dire... :-°
Bon : pour votre premier programme, je pense que le traditionnel "Hello World ! ! " est de mise... :p
Donc, allons-y !

Votre premier programme

Nous entrons enfin dans le vif du sujet !
Mais ne vous attendez pas à faire un vrai programme tout de suite... ^^

Maintenant, vous pouvez taper les lignes suivantes entre les accolades de votre méthode main :
Code : Java
1
System.out.print("Hello World !");


N'oubliez surtout pas le ; à la fin de la ligne !
Toutes les instructions en Java sont suivies d'un point virgule.


Une fois que vous avez saisi cette ligne de code dans votre méthode main, vous devez lancer le programme.
Si vous vous souvenez bien de la présentation du chapitre précédent, vous avez dû cliquer sur la flèche blanche dans un rond vert :

Image utilisateur


Si vous regardez dans votre console, fenêtre en bas sous Eclipse, vous devez avoir :

Image utilisateur

Expliquons un peu cette ligne de code.
Littéralement, elle signifie "la méthode print() va écrire Hello World ! en utilisant l'objet out de la classe System".

Si vous mettez plusieurs System.out.print, voici ce qui ce passe.
Prenons ce code :
Code : Java
1
2
3
System.out.print("Hello World ! !");
  System.out.print("My name is");
  System.out.print("Cysboy");


Lorsque vous l'exécutez, vous devriez avoir une chaîne de caractères qui se suivent, sans saut à la ligne. En gros, vous devez avoir ceci dans votre console :
Hello World ! !My name isCysboy

Je me doute que vous souhaiteriez faire un retour à la ligne pour que votre texte soit plus lisible... :) Pour réussir cela, vous avez plusieurs solutions.


Donc, si nous reprenons notre précédent code et que nous appliquons ceci, voilà ce que ça donnerait :
(notre code modifié) :
Code : Java
1
2
3
System.out.print("Hello World ! ! \n");
  System.out.println("My name is");
  System.out.println("\nCysboy");


Le résultat :
Hello World ! !
My name is

Cysboy

Vous pouvez voir que :


J'en profite au passage pour vous donner deux autres caractères d'échappement :


Vous avez sûrement remarqué que la chaîne de caractères que l'on affiche est entourée de " <chaine> ".
En Java, les double quotes sont des délimiteurs de chaînes de caractères ! Si vous voulez afficher un double quote avec la sortie standard, vous devrez "l'échapper" avec un \, ce qui donnerait
System.out.println("coucou mon \"choux\" ! ");


Maintenant que vous savez faire un "Hello World", je vous propose de voir la compilation de vos programmes en ligne de commande.

Cette sous-partie n'est ici que pour les plus curieux d'entre vous.
Vous pouvez passer outre cette sous-partie si vous le voulez, et aller directement au QCM mais, partez du principe que ça pourrait vous servir un jour...

Compilation en ligne de commande (Windows)

Donc bienvenue aux plus curieux ! :D
Avant de vous apprendre à compiler et à exécuter un programme en ligne de commandes, il va vous falloir le JDK de SUN (Java SE Development Kit). C'est dans celui-ci que nous aurons de quoi compiler nos programmes. Le nécessaire à l'exécution des programmes est aussi dans le JRE... Mais vous l'aurez en plus dans le JDK.

Je vous invite donc à retourner sur le site de SUN et à télécharger celui-ci. Une fois cette opération effectuée, il est conseillé de mettre à jour votre variable d'environnement %PATH%.

Euh... Quoi ?

Votre variable d'environnement. C'est grâce à celle-ci que Windows arrive à trouver des exécutables sans lui spécifier le chemin d'accès complet. Vous, enfin Windows, en a plusieurs, mais nous nous intéresserons qu'à une seule. ;)
En gros, cette variable contient le chemin d'accès à certains programmes.

Par exemple, si vous spécifiez le chemin d'accès d'un programme X dans votre variable d'environnement et que, comme par un malheureux hasard, vous n'avez plus aucun raccourci vers X, c'est simple : vous l'avez définitivement perdu dans les méandres de votre PC.
Eh bien vous pourrez le lancer en faisant "démarrer > Exécuter" et en tapant la commande "X.exe" (en partant du principe que le nom de l'exécutable est X.exe).

D'accord, mais comment on fait ? Et pourquoi on doit faire ça pour le JDK ?

J'y arrive... :)
Une fois votre JDK installé, ouvrez le répertoire bin de celui-ci, mais également celui-ci de votre JRE. Nous allons nous attarder sur deux fichiers.

Dans le répertoire bin de votre JRE, vous devez avoir un fichier appelé java.exe. Fichier que vous retrouvez aussi dans le répertoire bin de votre JDK. C'est grâce à ce fichier que votre ordinateur peut lancer vos programmes par le biais de la JVM.

Lorsque vous lancez une application sous Eclipse, ce fichier est lancé de façon implicite ! ^^

Le deuxième ne se trouve que dans le répertoire bin de votre JDK, il s'agit de javac.exe (java compiler). C'est celui-ci qui va pré-compiler vos programmes Java en byte code.

Alors pourquoi le faire pour le JDK ?
Eh bien, compiler-exécuter en ligne de commande revient à utiliser ces deux fichiers en leur précisant où se trouvent les fichiers à traiter. Cela veut dire que si on ne met pas à jour la variable d'environnement de Windows, nous devons :

Avec notre variable d'environnement mise à jour, nous n'aurons plus qu'à :


Comme un exemple vaut mieux que de grands discours, mettons notre variable d'environnement à jour...

Allez dans le "panneau de configuration" de votre PC, de là, cliquez sur l'icône "Système" ; choisissez l'onglet "avancé" et vous devriez avoir un bouton, en bas, intitulé "Variables d'environnement" ; cliquez dessus.
Une nouvelle fenêtre s'ouvre. Dans la partie inférieure intitulée "Variables système" chercher la variable Path. Une fois sélectionnée, cliquez sur Modifier.
Encore une fois, une fenêtre, plus petite celle-là, s'ouvre devant vous. Elle contient le nom de la variable et sa valeur.

Ne changez pas son nom et n'effacez pas le contenu de valeur !
Nous allons juste ajouter un chemin d'accès.

Pour ce faire, allez jusqu'au bout de la valeur de la variable, ajoutez-y un point-virgule (;) s'il n'y en a pas, et ajoutez maintenant le chemin d'accès au répertoire bin de votre JDK, en terminant celui-ci par un point-virgule !.
Chez moi, ça donne ceci : "C:\Sun\SDK\jdk\bin".

Alors, ma variable d'environnement contenait avant ajout :

%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;

Et maintenant :

%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;C:\Sun\SDK\jdk\bin;

Validez les changements, et c'est tout ! ;)
Vous êtes maintenant prêts à compiler en ligne de commande.

Pour bien faire, allez dans le répertoire de votre premier programme et effacez le .class.
Ensuite, faites "démarrer > Exécuter" (ou encore touche Windows + r), et tapez "cmd".

Pour rappel, dans l'invite de commande, on se déplace de dossier en dossier grâce à l'instruction cd.
cd <nom du dossier enfant> : pour aller dans un dossier contenu dans celui dans lequel nous sommes.
cd .. : pour remonter d'un dossier dans la hiérarchie.


Par exemple : lorsque j'ouvre la console, je me trouve dans le dossier C:\toto\titi et mon application se trouve dans le dossier C:\sdz, je fais donc :

Code : Bash
1
2
3
cd ..
cd ..
cd sdz

Lors de la première instruction, je me retrouve dans le dossier C:\toto.
Lors de la deuxième instruction, je me retrouve à la racine de mon disque.
Lors de la troisième instruction, je me retrouve dans le dossier C:\sdz.
Nous sommes maintenant dans le dossier contenant notre fichier Java ! :p

Mais nous pouvons condenser ceci en :
Code : Bash
1
cd ../../sdz


Maintenant, vous pouvez créer votre fichier .class en utilisant la commande javac <nomDeFichier.java>.
Si, dans mon dossier, j'ai un fichier test.java, je le compile en faisant :
javac test.java
Et si vous n'avez aucun message d'erreur, vous pouvez vérifier que le fichier test.class est présent en utilisant l'instruction dir qui liste le contenu d'un répertoire.

Cette étape réussie, vous pouvez lancer votre programme Java en faisant java <nomFichierClassSansExtension>
Ce qui nous donne :
java test
Et normalement, vous avez le résultat de votre programme Java qui s'affiche sous vos yeux ébahis ! :D

Attention : il ne faut pas mettre l'extension du fichier pour le lancer, mais la mettre pour le compiler.


Donc voilà : vous avez compilé et exécuté un programme Java en ligne de commande... Vous en aurez peut être besoin un jour... En tout cas, j'espère que vous êtes d'attaque pour un petit QCM... :pirate:
J'espère que maintenant vous arrivez mieux à cerner comment fonctionne Java, et à écrire ce que vous voulez à l'écran.
À présent, nous allons voir comment stocker des données en mémoire afin de les afficher, de les calculer...

En avant pour les variables et les opérateurs.

Les variables et les opérateurs

Nous y voilà. Encore un chapitre barbant... Mais celui-là aussi est nécessaire, et je dirais même vital !
En Java, comme dans beaucoup de langages de programmation, avant d'utiliser une variable, nous devons d'abord définir ce qu'elle va contenir. :waw:

T'es bien gentil, mais c'est quoi, une variable ?


Oups ! Désolé ! Je parle, je parle et j'oublie l'essentiel... Une variable, c'est ce qui va nous permettre de stocker des informations de toute sorte (chiffres, résultats de calcul, des tableaux, des renseignements fournis par l'utilisateur...). Bref, vous ne pourrez pas faire de programme sans variables. Et comme je viens de vous le dire, et j'insiste là dessus, il faut à tout prix définir ce que nos variables vont contenir avant de les utiliser.

Une déclaration de variable se fait comme suit :

<Type de la variable> <Nom de la variable> ;

Cette opération se termine toujours par un ";" (comme toutes les instructions de ce langage) ;
ensuite, on l'initialise en rentrant une valeur.


Bon. Assez de bla-bla, on y va. (Décidément, moi, les rimes en ce moment... :p )

Les différents types de variables

Tout d'abord, je vous conseille vivement de lire le chapitre qu'a écrit M@teo21 sur les variables dans son tutoriel sur le C. Je pense que vous y verrez plus clair.

Bon. En Java, nous avons deux type de variables :

Ce qu'on appelle des types simples, ou types primitifs, en Java ce sont tout bonnement des nombres entiers, des nombres réels, des booléens ou encore des caractères. Mais vous allez voir qu'il y a plusieurs façons de déclarer certains de ces types.

Commençons par les variables de type numérique


- Le type byte (1 octet) peut contenir les entiers entre -128 et +127.
Ex. :
Code : Java
1
2
byte temperature;
temperature = 64;

- Le type short (2 octets) contient les entiers compris entre -32768 et +32767.
Ex. :
Code : Java
1
2
short vitesseMax;
vitesseMax = 32000;

- Le type int (4 octet) va de -2*10e9 à 2*10e8 (2 et 9 zéros derrière... ce qui fait déjà un joli nombre).
Ex. :
Code : Java
1
2
int temperatureSoleil;
temperatureSoleil = 15600000;

C'est en degrés Kelvin...
- Le type long(8 octets) de -9*10e18 à 9*10e18 (encore plus gros...).
Ex. :
Code : Java
1
2
long anneeLumiere;
anneeLumiere = 9460700000000000;

- Le type float (4 octets) correspond à des nombres avec virgule flottante.
Ex. :
Code : Java
1
2
float pi;
pi = 3.141592653;

ou encore
Code : Java
1
2
float nombre;
nombre = 2.0;

Vous remarquerez que nous ne mettons pas de virgule mais un point ! Et vous remarquerez aussi que même si le nombre en question est rond, on met tout de même .0 derrière celui-ci !

- Le type double (8 octets) est identique à float, si ce n'est qu'il contient un nombre plus grand derrière la virgule.
Ex. :
Code : Java
1
2
double division;
division = 0.333333333333333333333333333333333333333333334;


Nous avons aussi des variables stockant du caractère


- Le type char contient UN caractère stocké entre de simples quotes ' ' comme ceci...
Ex. :
Code : Java
1
2
char caractere;
caractere = 'A';


Nous avons aussi le type booléen


- Le type boolean qui lui contient true (vrai) ou false (faux).
Ex. :
Code : Java
1
2
boolean question;
question = true;


Et aussi le type String


- Celle-ci correspond à de la chaîne de caractères.
Ici, il ne s'agit pas d'une variable mais d'un objet qui instancie une classe qui existe dans Java ; nous pouvons l'initialiser en utilisant l'opérateur unaire new() dont on se sert pour réserver un emplacement mémoire à un objet (mais nous reparlerons de tout ceci dans la partie deux, lorsque nous verrons les classes), ou alors lui affecter directement la chaîne de caractères.
Vous verrez que celle-ci s'utilise très facilement et se déclare comme ceci :
Ex. :
Code : Java
1
2
3
4
5
6
7
8
9
String phrase;
phrase = "Titi et gros minet";
//Deuxième méthode de déclaration de type String
String str = new String();
str = "Une autre chaîne de caractères";
//La troisième
String string = "Une autre chaîne";
//Et une quatrième pour la route
String chaine = new String("Et une de plus ! ");


Attention : String commence par une majuscule ! Et lors de l'initialisation, on utilise ici des doubles quotes " " .

En fait, String n'est pas un type de variable mais un objet.
Notre variable est "un objet", on dit aussi "une instance", ici, une instance de la classe String. Nous y reviendrons lorsque nous aborderons les objets. :D

On te croit sur parole, mais pourquoi String commence par une majuscule et pas les autres ?

C'est simple. Il s'agit d'une convention de nommage.
En fait, c'est une façon d'appeler nos classes, nos variables, etc. Il faut que vous essayez de respecter cette convention au maximum. Cette convention, la voici :


Je sais que la première classe que je vous ai demandé de créer ne respecte pas cette convention, mais je ne voulais pas vous dire ça à ce moment-là... Donc, à présent, je vous demanderai de ne pas oublier ces règles !
Sinon ! :colere2: Châtiment corporel. ^^
Voici quelques exemples de noms de classes et de variables :
Code : Java
1
2
3
4
5
6
7
8
public class Toto{}
 public class Nombre{}
 public class TotoEtTiti{}
 String chaine;
 String chaineDeCaracteres;
 int nombre;
 int nombrePlusGrand;
 //...


Donc, pour en revenir au pourquoi du comment, je vous ai dit que les variables de type String sont des objets. Les objets sont définis par une ossature (un squelette) qui est en fait une classe. Ici, nous utilisons un objet String qui est défini dans une classe qui s'appelle "String" ; c'est pourquoi String à une majucule et pas int, float... qui eux ne sont pas définis par une classe.

Pfiou ! Ça en fait des choses à retenir d'un coup ! Mais je ne vous cache pas que les deux premiers types de variables ne sont pas trop utilisés... ;)
Chose importante : veillez à bien respecter la casse (majuscules et minuscules) car une déclaration de CHAR à la place de char ou autre chose provoquera une erreur, tout comme une variable de type string à la place de String !

Alors faites bien attention lors de vos déclarations de variables... Sinon une petite astuce quand même, enfin deux plutôt ! On peut très bien compacter la phase de déclaration et d'initialisation en une seule phase ! Comme ceci : :magicien:
Code : Java
1
2
3
4
int entier = 32;
float pi = 3.1416;
char carac = 'z';
String mot = new String("Coucou");

Et lorsque nous avons plusieurs variables d'un même type, nous pouvons compacter tout ceci en une déclaration comme ceci :
Code : Java
1
int nbre1 = 2, nbre2 = 3, nbre3 = 0;

Ici, toutes les variables sont des entiers et toutes initialisées.
Bon, t'es bien mignon, mais on code quand, nous ?

Minute papillon ! On va y arriver ! :p
Mais avant, nous avons encore quelque chose de très important à voir pour pouvoir travailler sur et avec nos variables :
Les opérateurs arithmétiques

Les opérateurs arithmétiques

Ceci est notre avant dernière ligne droite avant de commencer à coder ! Et après, vous regretterez le temps où vous n'aviez pas à vous creuser la tête !! :diable:

Bon, allez ! Je vois bien que vous brûlez d'impatience, alors on va y aller tout de suite.

Les opérateurs arithmétiques



Ce sont ceux que l'on apprend à l'école primaire...

+ permet d'ajouter deux variables numériques (mais aussi de concaténer des chaînes de caractères ! Ne vous inquiétez pas, on aura l'occasion d'y revenir).

- permet de soustraire deux variables numériques.
* permet de multiplier deux variables numériques.
/ Permet de diviser deux variables numériques.(mais je crois que vous aviez deviné :p ).
% permet de renvoyer le reste de la division de deux variables de type numériques, cet opérateur s' appel le modulo.

Quelques exemples de calcul



Code : Java
1
2
3
4
5
6
7
8
9
int nbre1, nbre2, nbre3;//déclaration des variables</couleur>
nbre1 = nbre2 = nbre3 = 0;//initialisation</couleur>
 
nbre1 = 1 + 3;         // ici nbre1 vaut 4
nbre2 = 2 * 6;         // ici nbre2 vaut 12
nbre3 = nbre2 / nbre1;     //ici nbre3 vaut 3
nbre1 = 5 % 2;         //ici nbre1 vaut 1 car 5 = 2 * 2 + 1
nbre2 = 99 % 8;        //ici nbre2 vaut 3 car 99 = 8 * 12 + 3
nbre3 = 6 % 3;         //et là, nbre3 vaut 0 car la division n'a aucun reste

Ici, nous voyons bien que nous pouvons affecter des opérations sur des nombres à nos variables mais aussi affecter des opérations sur des variables de même type !!

Je me doute bien que le modulo est assez difficile à assimiler. Voici une utilisation assez simple : Pour déterminer si un entier est pair, il suffit de voir si cet entier modulo 2 renvoie 0 ^^ .


Maintenant, quelque chose que les personnes qui n'ont jamais programmé ont du mal à assimiler. Je garde la même déclaration de variable que ci-dessus.

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
int nbre1, nbre2, nbre3;        //déclaration des variables
nbre1 = nbre2 = nbre3 = 0;                  //initialisation
 
nbre1 = nbre1 + 1;  //nbre1 = lui même donc 0 + 1 => nbre1 = 1
nbre1 = nbre1 + 1;  // nbre1 = 1 (cf ci-dessus) maintenant nbre1 = 1 + 1 = 2!!!
nbre2 = nbre1;         //nbre2 = nbre1 = 2
nbre2 = nbre2 * 2;  //nbre2 = 2 => nbre2 = 2 * 2 = 4
nbre3 = nbre2;         //nbre3 = nbre2 = 4
nbre3 = nbre3 / nbre3;    //nbre3 = 4 / 4 = 1
nbre1 = nbre3;        //nbre1 = nbre3 = 1
nbre1 = nbre1 - 1;// nbre1 = 1 - 1 = 0

Et là aussi, il existe une syntaxe qui raccourcit l'écriture de ce genre d'opération. Regardez bien :

Code : Java
1
2
3
4
nbre1 = nbre1 + 1;
nbre1 += 1;
nbre1++;
++nbre1;

Ces trois syntaxes correspondent exactement à la même opération. La troisième syntaxe sera certainement celle que vous utiliserez le plus... mais ne marche que pour augmenter la valeur de 1 ! Si vous devez augmenter la valeur d'une variable de 2, utilisez les deux syntaxes précédentes. On appelle cette syntaxe l'incrémentation. La dernière fait la même chose que la troisième, mais avec une subtilité en plus... Nous en reparlerons dans le chapitre sur les boucles.

Sinon, la syntaxe est identique pour la soustraction :

Code : Java
1
2
3
4
nbre1 = nbre1 - 1;
nbre1 -= 1;
nbre1--;
--nbre1;

Même commentaire que pour l'addition sauf qu'ici, la troisième syntaxe s'appelle la décrémentation.

Les raccourcis pour la multiplication marchent aussi ; regardez plutôt :
Code : Java
1
2
3
4
nbre1 = nbre1 * 2;
nbre1 *= 2;
nbre1 = nbre1 / 2;
nbre1 /= 2;


TRES IMPORTANT == On ne peut faire de traitement arithmétique que sur des variables de même type, sous peine de perdre de la précision lors du calcul. On ne s'amuse pas à diviser un int par un float ! Ou pire, par un char !! Et ceci est valable pour tous les opérateurs arithmétiques et pour tous les types de variables numériques. Essayer de garder une certaine rigueur pour vos calculs arithmétiques.


Voici les raisons de ma mise en garde.
Comme je vous l'ai dit plus haut, chaque type de variable a une contenance différente et, pour faire simple, nous allons comparer nos variables à différents récipients.
Une variable de type :

A partir de là, ce n'est plus que du bon sens. Vous devez facilement voir que vous pouvez mettre le contenu d'un dé à coudre dans un verre ou un baril. Mais par contre, si vous versez le contenu d'un baril dans un verre... Il y en a plein par terre ! :p
Cela s'appelle : une perte de précision !

Ainsi, si nous affectons le résultat d' une opération sur deux variables de type double dans une variable de type int, le résultat sera de type int et donc ne sera pas un réel mais un entier.

Pour afficher le contenu d'une variable dans la console, il vous suffit d'appeler l'instruction : System.out.println(maVariable);, ou encore System.out.print(maDeuxiemeVariable);.


Je suppose que vous voudriez aussi mettre du texte en même temps que vos variables... Eh bien sachez que l'opérateur + sert aussi comme opérateur de concaténation, c'est-à-dire qu'il permet de mixer du texte brut avec des variables.

Voici un exemple d'affichage avec une perte de précision :
Code : Java
1
2
3
double nbre1 = 10, nbre2 = 3;
 int resultat = (int)(nbre1 / nbre2);
 System.out.println("Le résultat est = " + resultat);

Sachez aussi que vous pouvez tout à fait mettre des calculs dans un affichage, comme ceci System.out.print("Résultat = " + nbre1/nbre2); (le plus joue ici le rôle d'opérateur de concaténation) ; ceci vous permet d'économiser une variable et donc de la mémoire. ^^

Mais pour le bien de ce chapitre, nous n'allons pas utiliser cette méthode...
Vous devez voir que le résultat fait 3, au lieu de 3.33333333333333... Et je pense que vous êtes intrigués par ça :
int resultat = (int)(nbre1 / nbre2);

Avant de vous expliquer, remplacez la ligne citée ci-dessus par celle-ci :
int resultat = nbre1 / nbre2;

Vous devez voir qu'Eclipse n'aime pas du tout !
Pour savoir pourquoi, nous allons voir ce qu'on appelle les conversions ou "cast".

Les conversions, ou "cast"

Comme expliqué plus haut, les variables de type double contiennent plus d'informations que les variables de type int.

Ici, il va falloir écouter comme il faut... heu, pardon ! Lire comme il faut !
Nous allons voir un truc super important en Java. Ne vous en déplaise, vous serez amenés à convertir des variables...


Conversion de type int vers un autre type numérique

D'un type int en type float :

Code : Java
1
2
int i = 123;
float j = (float)i;


D'un type int en double :

Code : Java