D'abord, je vais vous présenter les différents chapitre de mon tutoriels.

Que vais-je vous apprendre dans mon fameux cours ?

Alors, ici je vais faire le plan de mon cours pour créer des jeux en java ^^.

Partie I : Les structures de bases à maîtriser avant tout.

Chapitre 1 : Les bases du langages java
Je vais essayer de vous donner une vision globale de ce langage typiquement orienté objets pour que vous ayez déjà une petite idée du principe. Je vous rassure, ce n'est pas difficile, il faut juste bien comprendre le principe.

Je vais également vous enseigner les bases du langage qui sont essentielles à connaître pour pouvoir maîtriser la suite : les variables, la syntaxe, les opérations arithmétiques, le casting, etc...

Chapitre 2 : les structures de contrôles

Dans ce chapitre, nous allons voir comment faire des boucles, et des alternatives (avec les conditions) en java. Nous allons voir aussi la variable booléenne qui est très utile et qui simplifie la tâche lors des testes.

Chapitre 3 : les tableaux

Dans ce chapitre, nous allons voir qu'il y a moyen de stocker plusieurs valeur dans une seule variable à l'aide de variables indicées.
Ceci est comme un tableau de valeurs, ou chaque éléments peut être récupéré par le numéro de sa ligne, ou de sa ligne et de sa colonne s'il y a 2 indices.

Chapitre 4 : Les fonctions en java appelées méthodes

Dans ce chapitre nous allons voir comment on crée des méthodes en java, on verra aussi qu'il y a deux sortes de méthodes, celles qui sont propre à la classe et celles qui sont propres aux objets d'une classe, de même pour les variables.
Nous verrons aussi qu'il y a des méthodes avec et sans retour. (Comme en c++)

Partie II : Principes de la programmation orientée objet

Chapitre 5 : Le monde de la programmation orientée objet

Dans ce chapitre, nous allons voir les notions de bases de la programmation orientée objet. (les objets, les classes, les méthodes et constructeurs, la surcharge et l'encapsulation)

Chapitre 6 : Liens d'association et communication |e| objets

Ici on va voir comment on peut faire interagir les objets issus de différentes classes entre eux. On va donc appeler des méthodes sur des objets d'une autre classe que celle dans laquelle on est entrain de coder. On verra qu'il y a plusieurs manières de procéder.

Chapitre 7 : L'héritage et les interfaces

Nous verrons ici que l'on peut classer les classes suivant une hiérarchie. (objets plus généraux vers objets plus particulier)
C'est le principe de l'héritage.
Nous verrons aussi les classes abstraites.
Et aussi une nouveauté en Java : les interfaces car l'héritage multiple est interdit en Java.
Mais les interface pourront être implémentées et instanciée ce qui nous permettra de redéfinir des méthodes personnalisées ce qui sera très pratique lorsque nous verront les évènements.

Il y a un chapitre bonus (pas de mon cours) mais utile quand même, si vous devez sauvegarder des données de votre jeux, il faudra aussi pouvoir gérer certaines erreurs, et aussi pouvoir parfois récupérer des informations sur vos classes!

Partie III : Interfaces graphiques en 2D, évènements, ... , et réalisation de nos premier jeux en Java

Chapitre 8 : Les classes gérant les interfaces graphiques

Nous allons voir ici, comment créer une fenêtre windows en java, comment importer des images dans des fenêtres windows à partir de l'endroit où elles sont dans votre PC, comment faire des boutons et comment placé vos skins (textures) favoris sur vos composants. (On pourra faire cela facilement grâce à l'héritage!)
Il y aura des dégradé, des formes à faire avec la classe Graphics, etc.... (Un des chapitre les plus chouette!!)

Chapitre 9 : Les interfaces gérants les évènements (claver, souris, ...)

Nous allons voir ici, comment faire pour créer une action lors par exemple d'un clic avec la souris, appui s'une touche sur le clavier (ou combinaison de touches), ...
Par exemple faire avancer un personnage, ...
On pourra donc créer nos classes internes avec nos actions personnalisées en utilisant ce que l'on a vu sur les interfaces.

Chapitre 10 : La gestion du temps

On va voir ici comment gérer le temps, lors de l'exécution d'un programme.
Donner une base de temps à notre programme.
On verra comment java exécute les méthodes des différentes classes. (avec la classe Thread)
On apprendra à exécuter des parties de programmes en arrière plan (tâche parallèles) ce qui nous permettra de par exemple, incorporer un chronomètre sur notre jeux.

Chapitre 11 : La création de jeux simple en 2D

Nous allons ici nous intéresser à apprendre à réaliser des jeux simples. (démineur, puissance 4, solitaire, ...)
Nous pourrons ainsi enfin commencer à créer nos jeux!

Chapitre 12 : c'est plus joli avec du sons!

On verra comment gérer le son avec le langage Java.

Chapitre 13 : La réalisation de jeux plus complexes en 2D
On verra comment ici créeer des jeux du style que l'on a sur gameboy.
Ce chapitre sera assez long, il faudra aussi détecter les collisions.

[h3]Partie IV : La 3D et les jeux en réseaux [/h3]

Chapitre 14 : Utilisation de J3D : les primitives

Ici, nous verront comment on pourra créer des jeux en 3D grâce à J3D, ce que sont les primitives, et comment créer des objets avec.

Chapitre 15 : Les transformations et l'éclairage

On verra ici comment déplacer les objets dans l'univers.

Chapitre 16 : L'importation des modèles 3D
On va voir ici comment importer des animations dans notre monde 3D.

Chapitre 17 : Interaction des objets 3D avec le clavier, la souris
On va voir ici comment faire interragir avec le clavier les objets 3D. (Faire avancer un personnage, lui faire lancer un sors, etc..)

Chapitre 18 : Notre premier jeux avec j3D!
On verra ici comment créer un jeux en 3D, et la gestion des collisions.

Chapitre 19 : les jeux multi joueurs

On va voir ici comment créer des jeux en réseaux.

Chapitre 20 : Les jeux intégrés sur des pages webs
On verra ici comment faire fonctionner un jeux du style démineur sur une page web!

Ps : ce sommaire n'est pas encore complet, il existe des implémentation d'Irrlicht et d'Ogre pour Java, mais je vais pour l'instant, déjà commencer par ça car ça représente déjà beaucoup de boulot.

Quel est le but de ce langage ?

Le but de ce langage est de décomposer des problèmes complexes en plusieurs petits problèmes plus simples. Cela se fait grâce à la décomposition du problème en plusieurs classes d'objets.

La notion d'objet, les classes et leurs méthodes :

Un objet :
Ca peut être un peu n'importe quoi, la notion d'objet est très vaste!

Mais chaque objets doit être décrit au moyen d'informations à l'aide d'un langage, afin d'être connu. (le langage sera Java ici)
Ainsi on pourra créer des objets, et même les modifier!
La suppression se fera automatiquement par contre elle.

Parlons de l'informatique en elle même

Vous savez sans doute que l'informatique est un ensemble de techniques utilisées permettant le traitement automatique de l'information.

Elle décrit tout simplement un objet du monde réel à l'aide de 2 composantes, une qui donne la signification de l'objet, et une autre qui donne sa valeur.

Bien sur, on peut avoir plusieurs informations pour un même objet, ce qui constitue un enregistrement.

Exemple : on a un objet (c'est pas une insulte, c'est la base de la programmation orientée objet) étudiant.

Cet objet peut être décrit à l'aide d'informations :
Le nom de l'étudiant est Lagaffe. :D
Bah, le nom c'est la composante significative de l'objet étudiant qu'on appellera attribut.
Lagaffe est la valeur cet attribut.

On peut bien sur avoir plusieurs informations pour un même objet et ce sera souvent le cas.
Le prénom de l'étudiant est Gaston
La date de naissance de l'étudiant est 12/03/1980. etc...
Ceci constitue un enregistrement.
Un enregistrement regroupe donc toutes les informations décrivant un seul et même objet.

Puis on peut avoir aussi un deuxième objet étudiant.
Le nom de l'étudiant est Dupont.
etc ...
Celui-ci constitue un autre enregistrement.

Comme vous pouvez le constater, la valeur l'attribut nom sera différentes pour chaque étudiant!

Les valeurs des attributs des objets peuvent donc bien sûr varier (en effet, les objets étudiants auront pas tous le même nom), c'est pour cela qu'à la place d'attribut on leur donna le nom de variables. (La variable nom ici)

Bien sur il conviendra de choisir un symbole clair pour le nom de vos variables :
ex : la variable qui mémorisera le nom de l'étudiant, pourrait être symbolisée par etunom.



Pour modifier les valeurs des variables de ces objets, on utilisera ce que l'on appelle en java, des méthodes.

Les méthodes permettent de faire des opérations sur les objets. (modification de la valeur des variables de ces objets)

Classe d'objets avec ses méthodes

On peut aussi constater que les objets étudiant on tous quelque chose en commun. (bah oui, ils sont tous étudiants :D)

En général on regroupe en informatique tout les objets de même nature ou fonction dans un fichier.

Ce regroupement d'objets ayant une même nature ou fonction constitue donc ce que l'on connait tous, un fichier.

En java, on parlera de classes d'objets.

Constitution d'une classe :
Un nom d'abord!
Le nom de la classe ici serait par exemple Etudiant.
Et ensuite les variables propres à ces objets "etudiants"!
Et enfin, les méthodes qui ne pourront s'écrire que dans la classe de l'objet dont on veut modifier les valeurs de ses variables.

Donc, en représentation simplifiée cela donne :



On aura donc toujours pour chaque objet, un couple nom, attributs, valeur de ces attributs et sa classe avec ses méthodes permettant de le mettre à jour, le modifier.

Deux type de méthodes

Ces méthodes pourront soit renvoyer quelque chose ou alors ne rien renvoyer du tout, il y aura donc des méthodes avec retour, et des méthodes sans retour. (nous verrons cela plus loin)



Vous devez d'abord créer un projet, allez dans le menu, cliquer sur Project, puis sur New Project...
Vous pouvez dès lors ouvrir des projets, vous pouvez même ouvrir des projets créer avec un autre IDE en cliquant sur Open Non BlueJ...

Ensuite vous cliquer sur "new classe" (sur le panneau de gauche) et vous mettez le nom de votre classe dans le champ Class Name comme je le fait sur l'image et vous cliquez ensuite sur ok.



Vous voyez normalement apparaitre un rectangle orange avec le nom de votre classe.
Vous faites un clic droit dessus et vous cliquer sur open editor, comme je le fait ci dessous.

La vous avez une fenêtre qui apparait normalement, en fait, c'est la fenêtre ou vous éditerai tout le code de votre classe.
Vous voyez au dessus il y a des boutons. Si vous cliquer sur compile, il compile le code de votre classe.

Les autres boutons :

-Cut = couper, copy = copier, paste = coller.
Vous sélectionner donc votre texte à couper, copier avec la souris, logiquement il est souligné en jaune.
Ensuite, vous placer votre curseur à l'endroit ou vous voulez le coller et vous cliquer sur paste.
-Find = rechercher un mot.
-Find next c'est pour rechercher le mot suivant si il y a plusieurs fois le même mot qui apparait dans votre éditeur de classe.
Lorsque vous avez fait find et fermer la fenêtre de recherche, vous voyez que vous pouvez même remplacer les mots recherchés.

Très utile lorsque l'on veux modifier le nom d'une variable.
Vous voyez donc sur l'image ci dessous qu'il souligne en jaune le mot que je recherche.
Si je fais Find Next, il soulignera le mot Point plus loin en Jaune et ainsi de suite jusqu'à ce qu'il n'en trouves plus.
Si vous fermer la fenêtre et que vous cliquez sur find next, ça marche aussi.
L'image :

Vous voyez sur l'image ci dessous qu'il souligne en jaune le mot que je recherche.
Il y a moyen d'avoir Bleu J en français mais j'ai jamais retrouver comment on fait

La documentation.

Vous voyez tout à gauche que vous avez le choix entre Source Code et Documentation, si vous mettez Documentation, il vous affiche toute la doc concernant votre classe! (Ce qui est super)
C'est la même présentation que la javadoc.

Vous pouvez paramétrer l'éditeur pour cela il suffit d'aller dans le menu Tools, preferences ou de faire ctrl + virgule.
Si vous faîtes ctrl+D il vous affiche le débugger.
BlueJ possède aussi un terminal, aller dans le menu View, Terminal ou alors faîtes ctrl + T.
Je vous laisse découvrir les autres fonctionnalité de cet éditeur spécial à l'aise.

Le débugger de blue-J.

Il est assez pratique pour les débutants en Java, car il affiche toutes les valeurs des variables de votre classe, (suivant le bloc d'instructions ou vous vous trouver) de vos objets aussi, enfin soit, il est super moi je trouves.

Alors pour marquer le point ou vous voulez stopper l'exécution de votre programme, vous cliquez là ou il y a les numéro de ligne, un genre de petit stop apparait comme dans l'image ci dessous.



Alors on voit donc la ligne soulignée en jaune ou j'ai mit le stop. Ensuite à droite le débugger.
Vous voyez alors les Threads, pour le moment, on ne travaillera qu'avec un seul : le main.
Ensuite, on a en dessous les méthodes que l'on a appelées. (Call Sequence)
A gauche on a les variables statiques. (ici j'en ai pas)
Et en dessous les variables d'instances. (Donc celles déclarées au début de la classe)
Et en dessous enfin les variables locales. (celle qui n'apparaissent que dans le bloc ou vous êtes)
Ne vous en faîtes pas si vous comprenez pas tout, mon cours et là pour ça, là on voit que le débugger est pratique car on voit comment les valeurs de vos variables ou objets évoluent au fur et à mesure de l'exécution de votre programme.
Les boutons en dessous :
Step = étape suivante, passe à l'instruction suivante dans votre programme.
Step into = Si vous voulez rentrer dans un bloc d'instructions d'une méthode pour voir plus en détail ce qu'il s'y passe.
Continue : continue l'exécution jusque à la fin du programme.
Terminate : Arrête l'exécution du programme. (Lorsque vous avez trouver l'erreur, vous appuyer dessus, vous corriger et vous recompiler)

Voilà c'est tout, vous voyez quand même qu'il est assez pratique!

Créer une classe

Pour l'instant je vais me limiter à une seule classe pour tout vos programmes que vous devrez faire.

Vous effacer les choses déjà écrites dans la classe. (Ça sert à rien en faîtes, ça indique juste un exemple de code source)
Donc là vous avez déjà un exemple de code source en Java.

Pour que votre classe soit reconnue par le compilateur, il faut que vous tapiez ceci :


Il faut mettre des crochets pour lui mentionner le début et la fin de la classe.
Tout le code source de votre classe Etudiant sera donc mit entre les crochets!

Ensuite il faut lui déclarer quelles variables on va devoir utiliser, le type de celle-ci suivit de leur nom.

Alors pour cela il faut écrire le type suivit du nom de la variable ce qui nous donne :


On peut aussi faire ceci :




Ensuite il faut pouvoir créer un objet étudiant; pour cela on utilise le mot clé new.

Il faudra comme pour les variables déclarer le type de l'objet sauf si il est créer dans sa classe même.

Le type de l'objet c'est simplement le nom de sa classe.

Exemple :

Ceci créer en mémoire centrale, à partir de la déclaration de vos variables dans votre classe Etudiant, un emplacement réservé au contenu de vos variables pour cet objet qui pour l'instant n'a rien en mémoire car on a pas encore affecter de valeurs aux variables de l'objet etudiant1.

Pour donner une valeur à une variable, il faut d'abord préciser sur quel objet de la classe on veut changer la valeur de la variable, et de quelle variable il s'agit.

Le nom de l'objet et de la variable sont séparés par un point, et le égal servira à affecter une valeur à notre variable.

Exemple :

Donc on met Lagaffe dans la variable nom de l'objet etudiant1.
[attention]Toutes les chaînes de caracètères devront être mise entre guillemets![/attention]
Donc en résumant le code de base on aura ceci. (pour un objet créer dans sa classe même!)


Voilà je crois que je vous ai dis l'essentiel dans cette introduction, j'espère que vous voyez déjà à quoi ressemble la programmation orientée objet, mais nous n'allons pas commencez tout de suite par cela, car il y a d'autre choses à savoir avant, nous allons maintenant passer au point suivant et vous pourrez enfin faire votre premier programme en Java!

Exemples de petits programmes

Vous aller remarquer que la syntaxe en Java est fort semblable à celle des langages c/c++.

Toutes les instructions dans les blocs seront séparées d'un point virgule!
Tout les blocs d'instructions seront mit entre accolades {}.


Exemple de syntaxe :

Créer un projet (project => new project)
Créer une classe que vous appellerez SayHello (edit => new class) et écrivez le code suivant dedans.


Compiler le en cliquant sur le bouton compile en haut de votre classe!
Logiquement, il va afficher "Hello world!" dans votre console Blue J.


Explication de ce code de base. (celui dans la méthode main)

L'instruction System.out.println permet d'afficher du texte à l'écran et ensuite passe à la ligne.

Il en existe une autre qui permet de lire du texte à l'écran.

La classe System sert donc à gérer les entrées et sorties standard pour les programmes en console.

"out" est un objet de la classe System (de type flux de sortie) qui permet de gérer les soties consoles.
(On verra les flux plus loin)

println est une méthode de la classe System qui passe le texte à afficher à la sortie console puis passe à la ligne. (L'objet out est dans la classe System, et on invoque la méthode println sur celui ci!)

C'est une instruction importante à mémoriser. Il sera souvent utile pour des programmes complexes d'afficher les valeurs de vos variables en cas de bug.

Exécuter son code avec BlueJ

Il suffit de faire un clic droit sur votre classe et cliquer sur votre méthode main comme le montre l'image ci dessous.

Là normalement vous devez avoir la console de blue J qui s'affiche avec "Hello World!" à l'écran.

Si vous voulez effacer la console de blue-J faîte ctrl + k.


Maintenant voyons comment lui demander d'enregistrer du texte tapé à l'écran et le mettre dans une variable.
Faîtes une autre classe et donnez lui un nom.


Tout d'abord ne vous occupez pas du import et ce qui suit tout au début du code pour l'instant, mais il faut le mettre!
Vous voyez que l'on doit créer un objet de type Scanner, ici je l'ai appelé lectureClavier, celui-ci va lire le texte que l'on aura taper au clavier.
Vous voyez que entre les parenthèses du new j'ai mis, System.in, c'est normal.
in est l'objet de la classe System qui gère les flux d'entrée en console, il faut donc le mettre!
Ceci vous permet donc en même temps de bien voir la syntaxe en java.
Ça peut sembler superflu au début mais c'est normal.

La méthode main

Comme en C/C++, en java il y a la méthode (=fonction) main.
Cette méthode contient tout votre programme, et fait appel automatiquement à toutes les méthodes de vos classes, en cas de besoin. C'est juste que en java, le programme que l'on doit faire est subdivisé en classes, qui créent des objets. Les variables de ces objets sont modifiées à l'aide de méthodes, qui sont toutes constituées d'algorithme.
C'est donc une subdivision d'algorithme et de fonctions, le java, pour but de simplifier la lecture du code.
Et la méthode main et celle qui lance le programme, et gère l'appel successifs aux méthodes modifiants vos objets!

Syntaxe de la méthode main :

Et tout le corps de la méthode main sera mit entre les accolades!

Cette méthode particulière est obligatoire, car après quand vous aller regrouper toutes les classes de votre projet en un fichier exécutable, il faudra préciser à Blue-J, quelle est la classe qui contient la méthode main, et toute l'exécution de votre programme se fera à partir de cette méthode.

Les commentaires :
Ils ne sont pas prit en compte par le compilateur mais sont très utiles car ils permettent de vous y retrouver dans votre code si vous devez par exemple plus tard mettre à jour votre programme, s'il n'y a pas de commentaire, vous ne saurez plus à quoi correspond votre code, ni comment il fonctionne.

Il y en a de trois sortes :
Commentaires sur une ligne.

Tout ce qui suit le // est mit en commentaire sauf si on passe à la ligne suivante!
Commentaires long sur plusieurs lignes

Commentaire particulier lié à la Javadoc.

On verra plus tard comment les utiliser, lorsque l'on apprendra à générer de la javadoc en html avec des balises simples!

Donc je vais commenter mon code qui permet de lire du texte à l'écran.



Astuce très pratique!

Il vous arrivera souvent de mettre des lignes de code en commentaire lorsque vous devrez chercher une erreur qui empêche votre programme de compiler.
Comme ceci :



Ainsi là je met la première étoile et la dernière également en commentaire de ce fait le code n'est plus mit en commentaire et est donc recompilé, et ensuite s'il y a encore un bug il suffira de retiré le backslash que j'ai rajouté devant la première étoile, et ainsi de suite jusqu'à que ça marche; au lieu redevoir à chaque fois remettre tout le code en commentaire!

Sachez d'abord que chaque objet doit être déclaré par le nom de la classe à laquelle il appartient, on appellera ces variable là, des variables d'instances, vous verrez plus tard pourquoi.

Les objets sont des variables plus complexes que l'on crée nous même si vous voulez.

Il existe en java, 8 types primitifs de variables primitives qui ne sont pas des objets :


byte, short, int, long, float, double, char et boolean.

Liste des différents types de ces variables et leur capacité de stockage en mémoire.

byte = 1 octets. (des nombres entiers uniquement sur un octet) [-127 à + 128]
short = 2 octets. (des nombres entiers cours) [-32 768 à + 32 767]
int = 4 octets. (des nombres entiers normaux) [-2 147 483 648 à + 2 147 483 647]
long = 8 octets. (des nombres entiers de très petits à très grands)
char = 2 octets. (un caractère) 2^16 -1 caractères différents correspondant à 1 nombre : c'est le code UNICODE

Pour le type char, la lettre devra être mise entre apostrophes!
Comme ceci :






float = 4 octets dont 1 pour la position de la virgule et 1 pour l'ensemble des chiffres du nombre. (la mantisse)
Ce type équivaut donc à des nombres décimaux à virgule flottante à simple précision avec pas plus de 3 octets pour la mantisse!

double = 8 octets (des nombres décimaux à double précision) pas plus de 7 octets pour la mantisse. (offre des nombres dont les chiffres mit après la virgule peuvent être plus grand qu'un float)

L'intervalle pour les nombres décimaux est plus compliqué à expliquer, je vais pas le faire ainsi ça évitera des embrouilles.

boolean = 1 octet avec 2 valeur possibles (soit true ou false) type de variable particulier utiliser pour simplifié l'utilisation des testes avec les conditions que nous verrons bientôt.


Retenez juste que si vous n'avez pas assez de place pour stocker une valeur dans un type de variable, (par ex : int) prenez en un autre qui offre plus d'octets.(long)
Et pour les nombres décimaux, mon prof de java m'a toujours conseillé d'utiliser des doubles, donc faîtes de même.

La hiérarchie des types entiers allant du moins au plus précis donne :
byte => short => int => long => float => double.


---------------------------------------------------------------------------------------------------------------------

Déclaration des variables.

En java, les variables peuvent se déclarer n'importe ou dans le programme, dans n'importe quel bloc d'instructions. (aussi bien les variables d'instances (les objets) que les autres)



Les variables n'ont donc portée que dans le bloc d'instructions où elles sont déclarées.

Conventions pour le nom des variables :

-Toujours en minuscule.
-La première lettre ne peut pas être un chiffre.
-Pas d'espaces ni de tiret dans les noms de variables. (Réservé à la soustraction)
-On utilisera l'underscore '_' pour séparer les mots.
-Ou alors on peut faire comme ça : nomEtudiant.
-Pas de caractères accentués, d'apostrophes,de virgules, ...
-Le nom des variables ne peut pas être un mot clé du langage java du style class, int, double, if, ....
Pour les programmes plus complexes, la première lettre sera celle du type de la variable : int iAge;


Les noms de classe :
Pareil que pour les variables sauf que la première lettre doit être en majuscule.
Ne pas mettre de nom au pluriel pour un nom de classe! (pas sérieux pour les programmeurs Java)
Noms des objets :
Pareil que pour les variables.
Les constantes
Tout en majuscule!

ex : PI, TAILLE_MAX, ...

Utilité et rôle des constantes

Elles servent à ne pas devoir réécrire à chaque fois dans le programme une valeur lors de calculs.

Permet par exemple de ne pas devoir toujours réécrire r = 3.1415... * a mais r = PI * a.

On ne devra ainsi écrire 3.1415... qu'au début du programme car ce serait lourd de devoir réécrire 3.1415... à chaque fois dans le programme.
PI sera remplacé par 3,1415... lors de la compilation.

On peut aussi bien sur déclarer des constantes qui seront des objets que l'on utilisera dans tous le programme et qui resteront inchangés.

Exemple de déclarations (variable simples)


...

Déclaration de constantes.

C'est une variable mais qui n'est pas variable, sa valeur reste la même dans tout le programme, on ne peut pas la modifier, la variable s'initialise au début de la classe et on ne modifie plus sa valeur après. Idem lors de la création d'objet constant, la valeur des variables de ses objets reste la même dans tout le programme!

En java, c'est le mot clé final qui permet de définir des constantes, c'est comme le #define en C.

Syntaxe :

L'affectation des variables :

Elle se fait par le signe égal.

On peut aussi effectuer des affectations multiples comme ceci.

var2 prend la valeur 1, ensuite var1 prend la valeur de var2 c'est à dire 1.

L'affectation se fait donc de droite à gauche, contrairement aux opérations arithmétiques qui se font de gauche à droite!

Les conversions d'ajustement de type.

Très important, 2 choses à savoir :

La promotion numérique :

Cela signifie que java travaille au minimum avec des types int, donc lors des calculs, si vous avez des variables de type byte ou short intervenant dans vos calculs, le compilateur va automatiquement convertir leur valeur en int lors de vos traitements arithmétiques.
Exemple :
var1, var2 et var3 sont de type byte.
Si vous écrivez :

Les valeurs de ces variables seront convertie en type int.

Les conversions d'ajustements de type :

Elles permettent de ne pas perdre de la précision lors de l'affectation.

Vous savez que la précision varie en fonction du type de la variable.

Plus il y a d'octets réservé en mémoire par le type de la variable, plus il y a de précision.

Or on a vu que les variables peuvent avoir des types différents, et donc des représentations en mémoire de longueur différente.

Il est donc très fréquents de faire des opérations arithmétiques sur des variables de type mixtes!

Exemple : on veut faire ce calcul ci.
var1 est de type double.
var2 et var3 sont de type int.


Et bien, avant d'être stocker dans la variable var1, la valeur de var2 va être convertie par le compilateur en type double automatiquement, pour ne pas perdre de la précision.


Sinon si var2 vaut 1, le résultat serait 0 au lieu de 0.5.



Prenons maintenant le cas inverse, var1 est de type entier et var2 est de type double.

Le compilateur va faire le calcul et va se rendre compte qu'il doit mettre le résultat qui est de type double dans une variable de type entier. Il y aura donc perte de la partie fractionnaire de ce nombre. Il va devoir tronquer 0.5 à 0 et donc il va vous indiquer une erreur.

Mais si vous voulez vraiment le faire, parce que vous avez besoin d'un entier; il faudra préciser au compilateur que vous savez ce que vous faites.
Cela s'appelle le cast(ing) et il s'écrit de la manière suivante :



En mettant int entre parenthèses, on lui précise donc que l'on veut bien un entier, il va donc convertir la valeur de var2 en entier, faire le calcul et mettre le résultat dans var1.


Il vous suffit d'écrire ceci : valeur = nomObjet.var1;

exemple :

La concaténation :

Il s'agit d'affecter à une variable, du texte et le contenu d'une variable. Elle se fait à l'aide du signe +.

Exemple :

Les séquences d'échappement.

Elles permettent de pouvoir faire des tabulations, des retour à la ligne (mais println le fait aussi), afficher des guillements, etc...
Exemple :

Les litéreaux.

Pour terminer voici une dernière chose importante : les littéraux.

Ce sont des nombres ou chaînes de caractères entrées en toutes lettre, par défaut, Java les considères comme type int pour les nombres entier, double pour les nombres décimaux, si vous voulez par exemple mettre un littéral dans un float, il faudra que vous le fassiez suivre de la première lettre de son type, en maj ou min, cela importe peu.
Exemples :

Sinon 0.25 sera pris en compte comme un double et 48958496464 sera pris en compte comme un int.
Par conséquent lorsque vous écrivez des littéraux de type int ou double, la lettre à la fin n'est pas obligatoire vu que c'est le type pris par défaut.


Voilà, je crois que j'ai tout dis à propos des variables, si vous savez ça vous êtes près pour la suite.

L'addition du contenu 2 variables :

La soustraction :

La multiplication :



La division :

L'opérateur modulo :



Il renvoie le reste d'une division de 2 nombres.

Exemple :

resultat vaut 2.

La priorité des opérateurs.

1 : les ().
2 : le cast qu'on a vu avant.
3 : la multiplication, division, modulo.
4 : les additions, soustraction.
5 : l'affectation.

Les opérations ce font donc dans cet ordre, attention lors de vos calculs.

La classe Math :

Celle-ci propose plusieurs services tel que Math.sqrt () qui renvoie la racine carrée d'un nombre, attention la méthode sqrt renvoie un double!

Exemple, calculer delta et x1, x2. (comme on le voit à l'école)


Là ça marche plus!



Car la division est prioritaire sur l'addition donc il va d'abord calculer la racine carrée de delta qu'il va diviser par 2*a et ensuite seulement après il va effectuer l'addition.
Il faut donc mettre "-b+Math.sqrt (delta)" entre parenthèses.




Je vous ferai un tableau des priorités des opérations en java après.

Les racourcis

Comme en C, la syntaxe pour les opérations arithmétiques peut être raccourcie en java. (un informaticien par nature est fainéant :D)

Raccourci pour l'incrémentation :
i=i+1 devient i++ (post incrémentation) ou ++i; (pré incrémentation) il n'y a pas de différence fondamentale.
Sachez juste que si vous écrivez.

Il y aura un changement de priorité :
Dans le première affichage, il va d'abord incrémenter i puis l'afficher.
Dans le second affichage, il va afficher i et ensuite l'incrémenter.
Addition :
i=i+2 devient i += 2;
Pour la soustration, la multiplication et la division c'est pareil.

i = i - 1 devient i-- ou --i (Pour la décrémentation)
i = i - 2 devient i -= 2;
i = i*2 devient i *= 2;
i = i/2 devient i /= 2;
i = i % 2 devient %= 2;



Et oui, java est un langage compacte. ^^

En java, il existe des milliers de classes.
Chacune servent à faire quelque chose.

Comment invoque t-on une classe ?

Il suffit d'écrire son nom.
Par exemple "System".

Reprenons justement l'instruction qui affiche du texte à l'écran comme exemple.

Les méthodes :

C'est l'équivalent des fonctions en C/C++.

Elles permettent de faire des opérations sur les variables des objets d'une classe.

Par exemple la méthode println qui s'invoque sur l'objet "out" qui est une variable qui va préciser à la classe System que l'ordinateur doit écrire quelque chose. (out c'est l'abréviation de output, qui veut dire sortie)

System.out.println() est donc une instruction qui va afficher quelque chose à l'écran, puis retourner à la ligne.

Si l'on ne veut pas passer à la ligne, il faut utiliser une autre méthode : "print" à la place de "println".

Les arguments d'une méthode :

Une méthode peut avoir 0, 1, ou n arguments.
Ceci précise quelles variables il faut fournir à la méthode pour qu'elle puisse effectuer ses opérations. Ici, il faut lui fournir une variable de type String, qui contiendra le texte à afficher.


On peut soit indiquer un nom de variable de même type comme argument dans une méthode, ou alors une valeur prédéfinie mais de même type.

Par exemple, ici "println" doit recevoir du texte entre les (), ou une variable de type String.
Enfin les autres types marchent aussi vu que cette méthode à été surchargée, on verra cela plus loin.


C'est pour pas confondre le nom des méthodes et celui des variables d'un objet.

Pour invoquer une méthode, on écrit le nom de l'objet ou de la classe, séparé par un point, et le nom de la méthode, avec s'il y en a, ses arguments entre ().

Une méthode peut ne rien renvoyer ou renvoyer quelque chose.
Si elle renvoie quelque chose, il faudra préciser le type de retour lors de la déclaration de la méthode, et à la fin de la méthode, il faudra renvoyer une valeur (ou un objet).

Exemple :

Cette méthode renvoie un nombre entier, avant de le stocker dans la variable nombre.
nextDouble renvoie un double.
nextLine renvoie un string, etc....
next tout seul renvoie un objet de type Object. (on verra la classe Object plus loin)

Donc lors de la déclaration de la méthode nextInt il a fallut écrire : int nextInt() { ... }



S'il n'y a pas de type de retour à renvoyer par la méthode; "void" précède le nom de la méthode et là pas besoin de "return"!

On crée donc les méthodes comme ça dans une classe : typeDeRetour nomDeLaMéthode.
Et une dernière chose, chaque méthode sera précédé du mot clef public et chaque variables sera précédé du mot clef private. (Je vous expliquerai plus tard leur signification)

Exemple d'une méthode sans retour :

Exemple d'une méthode avec retour :






Retenez simplement maintenant qu'il y a des méthodes qui s'invoquent sur le nom de sa classe et des méthodes qui s'invoquent sur un objet de sa classe a qui a été créé.

Exemple d'une autre méthode utile : Pour forcer le programme à se terminer.

System.exit (0).

Les méthodes avec un nombre d'argument variable

Cette nouveauté apparait à partir de la version 5.0 de Java.
Cela permet à une méthode de pouvoir recevoir un nombre variable de valeurs.

Pour cela il suffit de faire précéder le paramètre par ...
Exemple :

Les énumérations

Ceci est un ajout à la version 5.0 de Java, qui permet de faire des énumérations comme en c/c++.
Mais il y a une différence, une variable énumérée ne peut pas être transposée en type int!

En réalité, on se moque totalement de la valeur d'une variable énumérée, elle sert juste à indiquer un cas possible pour une variable entière, pour simplifier la lecture du code.

Exemple :


Voilà, c'est la fin de cet partie.

Notion de chaînes de caractères

C'est une suite de caractères, elle se met entre guillemets "".
En java, chaque chaîne de caractère est un objet de la classe String.
Et chaque objet de la classe String est en fait, une liste de variables de type caractère. (Je vous parlerai des listes plus loin)

Ces chaînes de caractères se terminent tous par le caractère de fin de chaîne : le '\0'.
(on ne le voit pas, c'est juste pour préciser à la machine ou se trouves la fin de la phrase)
Il n'est pas nécessaire comme en c de préciser la longueur de la chaîne de caractère!

Vous verrez plus tard que les listes sont extensibles et n'ont pas de taille, leur dernier élément sera toujours null.

La classe String permet donc de gérer des variables de type chaînes de caractères très simplement.

Les méthodes de la classe String

Comme dans toutes les classes, il y a des méthodes :
Celles - ci sont : charAt qui renvoye le caractère n°i d'une chaîne de caractère. Elle prend donc un argument, la position du caractère à renvoyer dans la chaîne de caractère.
Le premier caractère occupe la position 0 et le dernier, la longueur de la chaînes - 1.

toUppperCase : convertit toute votre phrase en majuscule.
toLowerCase : convertit toute votre phrase en minuscule.
Ces deux méthodes prennent pas de paramètre, elles sont invoquées sur des objets de type String. (les chaînes à convertir)
Elles renvoient un objet de type String. (la chaîne convertie)
substring : crée une sous chaine à partir d'une chaine de caractères, la méthode renvoie donc un String.
Elle possède deux paramètres : le n° de la position du caractère ou l'on doit commencer à extraire les caractères de la chaîne dans la sous chaine et le nombre de caractères à extraire qui suivent.

Il y a aussi la méthode split, qui permet de séparer une chaîne de caractères en deux, celle-ci renvoie un tableau (je vous parlerez des tableaux plus loin) :
Elle prend un paramètre : le séparateur.
Bon j'ai envie d'écrire un code pour vous montrer à quel point c'est pratique le Java!



On verra les tableaux par la suite.

Exemple 2 : demander d'entrer une lettre à l'utilisateur l'afficher à l'écran.

Les packages : une bonne façon de regrouper les classes

Ce sont en fait des regroupements de classes. Ils servent à regrouper par exemple dans un même dossier, les classes servant à créer des interfaces graphiques, celles qui servent à gérer des actions, etc... Il existe des tas de classes préexistantes (plus de 3500!). Pour pouvoir utiliser dans vos classe, ces classes préexistantes, vous devez les importer!

Comment importer des packages dans une classe

Comment on fait, bah ça se fait tout au début de la classe à l'aide du mot clef import.
Syntaxe : import nomDossier.nomClasse;
Exemple : pour importer la classe Random qui se trouve dans C\java\util

util est un sous répertoire de java, il vous faut préciser dans quel sous répertoire la classe se trouve.



Là, il vous faut remplacer le nom de la classe par une astérix, cela veut dire all. (tout)
Exemple :

Créer un package dans son projet

Vous allez dans le menu de blue J, vous faîtes Edit, New package ou ctrl r. Vous aller voir un dossier s'afficher, vous faîtes un clic droit dessus et vous l'ouvrer, et là dedans vous créer vos classes. ^^
Voici comment je fais :




Nouveauté à partir de java 5.0
Il est possible maintenant d'importer dans une classe par exemple, que les classes d'un package qui sont static, on verra ce que sont les méthodes, classe et variables statiques, retenez juste que les classes statique n'ont pas pour but de créer des objets.
Exemple :

On est pus obligé d'écrire le nom de la classe System pour afficher un message, comme elle est statique, elle a été importée au début de la classe Dire.
Voila on est enfin arrivé à la fin de ce long tutoriel.

Ce qu'il faut savoir :

Toutes les instructions en Java se terminent pas un ; et les bloc d'instructions sont délimité par des {}.

Le nom des variables, objets et méthodes commence par un minuscule, et les nom de classes par une majuscule.

Il y a deux type de classes, celles pour créer des objet, celle pour effectuer des opérations sur certains types d'objets ou variables.

Il y a 8 types primitifs qui ne sont pas des objets et un objet est créé à l'aide de l'opérateur new.

L'appartenance à un package et l'importation d'un package à une classe se déclare tout au début du fichier .java

1) Observer le programme suivant :

a) Repérer tout d'abord les différents blocs d'instructions, l'endroit ou ils commencent et ou ils se terminent.

b) Repérer maintenant ou se trouvent les déclarations de variables.
c) Repérer les ordres de lectures et d'écriture.
d) Que vas faire ce programme ?

2) Faîtes un petit programme qui vas permettre de calculer le périmètre d'un carré, la longueur étant encodée par l'utilisateur. (périmètre = côté * 4)

//class donner un nom à votre classe.
//Importer le package pour la lecture de données au clavier.
//public static void main (String args) {
//Déclarer vos variables dont vous avez besoin.
//Déclaration de la variable qui va lire la longueur du côté du carré.
//Demander à l'utilisateur d'entrer la valeur.
//Lire la valeur que l'utilisateur à entrer.
//Calculer le périmètre de ce carré.
//Afficher le résultat.
} //Fin du main.
} //Fin de la classe.

3) Indiquer quelles sont les noms de variables qui respectent la convention.

NombreDeVie, nbMines, nombre_de_missiles, 3l3m3nt, orientation, cash$.

4) Dites si c'est une déclaration ou pas.

int nbBombes;
i = i + 1;
j++;
String char;
Etudiant etudiant1;
u/=10;
String url = "image1.gif";

5)Exercice sur l'affectation des variable. (Important : la permutation du contenu de 2 variables.

Soit 2 variables a et b : a=10 et b=20, on souhaite permuter leur contenu tel que a=20 et b=10, faîtes un programme qui permet de permuter le contenu de ces 2 variables. N'utiliser qu'une seule variable supplémentaire. (Aider vous d'un tableau avec le nom et la valeur de vos variables.

6)Pareil mais ici, on veut permuter le contenu de 3 variables. Donner vous même une valeur à vos variables, puis mettez le contenu de a dans b, de b dans c et de c dans a en n'utilisant qu'une seule variable supplémentaire, tester votre programme.

7)Expressions arithmétiques : quel sera la valeur des expressions suivantes.

int a = 5, b = 7;
float c = 3.0, d = 6.0, e = 4.0;
a / b;
a + b / c;
(a + b) / d;
a * d - e;
(a + b + c) % d;
a % b * (c + a);

8) Exercices sur les conversions d'ajustement de type. (Va t'il compiler ou pas, sinon pourquoi?)

int a, b, c;
flaot x, y, z;

a = 10; b = 20; c = 30;
a) x = a/2;
b) y = b % 3;
c) z = 1/4;
a = x;
a = (int) x;
a = (int) x+b;
a = (int) x + z;
a = (int) (x + z);

Petite anecdote marrante : Une fois lors d'une interro de programmation, je pris mon bic, le sortit avec peine de ma trousse, mes petits doigts tremblant, je lus la première question, il était écrit : Expliquer en quoi consiste les conversions d'ajustement de types. Je me mis à écrire : Ceci se passe lors de l'affection de variables, lorsque par exemple ....

Après lorsque je reçus ma copie, je fus sous le choc de remarquer que le prof avait barré le mot et écrit affectation au dessus. Je vis alors que l'avais écrit affection au lieu de affectation :D.

Bon, maintenant que vous avez bien ris de moi, je vous propose de faire l'exercice suivant :P.

Exercice 9 : (exercice récapitulatif) Ecrire un programme qui permet de demander à l'utilisateur d'encoder une variable de type byte, short, int, long, float, double, String et char et ensuite les afficher à l'écran. Ensuite, faîtes la somme des différentes valeurs et afficher les à l'écran. Ensuite, vous aller voir c'est magique : ajouter 'A' à la variable de type int et afficher le résultat :D. Qu'est ce que vous obtener ?

Voici les solutions des exercices précédant. Si vous êtes bloqué sur un exercice, regarder la solution pour vous aider puis essayer de le faire sans. Si vous ne comprenez vraiment pas, poser moi des questions sur le forum.
1.2) Il n'y en a que une c'est double a;
1.3) Ordre de lecture : lectureCLavier.nextDouble();
Ordre d'écriture : System.out.println(a);
1.4) Il va attendre que l'utilisateur tappe un nombre au clavier puis l'afficher.
2)

3)nbMines, nombre_de_missilles, orientation.
4)
oui, non, non, oui, oui, non, oui (déclaration et initialisation en même temps);
5)

6)

7)
5 / 7 = 0.
7 / 3.0 = 2 et 5 + 2 = 7.
5 + 7 = 12 et 12 / 6 = 2.
5 * 6 = 30 et 30 - 4 = 26.
5 + 7 + 3 = 15 et 15 % 6 = 3. (2*6 = 12 + reste : 15-12 = 3)
3 + 5 = 8 et 5 % 7 = 5 et 5 * 8 = 40.
8)
a) 10 / 2 = 5 dans x OK.
b) b % 3 = 2 (3*6 = 18 reste 20 - 18 = 2) dans y OK.
c) z = 0.25.
d) Il ne va pas compilé car il doit mettre le contenu de x (float) dans a qui est entier.
e) Là il va compiler car l'opération de cast va lui dire de forcer à mettre le contenu de x (float) dans en entier. a vaudra donc 5.
f) 5 + 20 = 25. Mais attention le cast est prioritaire à l'addition, donc ça va pas passer.
g) 5 + 0.25 = 5.25 Même remarque que le cas juste au dessus.
h) 5 + 0.25 = 5.25 Là il va compiler car x + z est entre () mais /!\ car a va valoir 5 et pas 5.25!!
9)