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 d'un test.

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 Principe 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 interragir les objets entre eux. On va donc appelé 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ère 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 nouveuté en Java : les interfaces car l'héritage multiple est interdit en Java.
Mais les interface pourront être impémentées et instncié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 info sur vos classes!

Partie III : Interface graphique, é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 window en java, comment importer des images dans des fenêtres window à partir de l'endroit où elles sont dans votre PC, comment faire des boutons et comment placé vos skin favoris sur vos composants. (On pourra faire celà 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, le clavier, ... Par exemple faire avancer un personnage, ...
On pourra donc créer nos action personnalisées en utilisant ce qu'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écutes les méthodes des différentes classes. (avec la classe Thread)

Chapitre 11 : La création de jeux simple

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 : La réalisation de jeux plus complexes
Ce sera un des chapitres les plus long, il faut au moins 5 ans pour en créer un tout seul. Je vais vous montrer ici, comment créer des jeux style des mmorpg, ... Pour cela nous tenterons d'en créer un ensemble pour que vous compreniez bien. ^^

Partie IV : Annexes

Chapitre 13 : Les jeux en réseaux

Ici, nous verront comment on pourra créer des jeux en réseaux en java du style multi-joueur.
Nous développerons des classes particulières spécialisées appelées Applet également. (Pour créer des mini jeux sur vos pages internet!)

Partie I

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 modifiers!
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 de l'attribut nom.

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 de nom sera différentes pour chaque étudiant!

Les valeurs des attributs des objets peuvent donc bien sur 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.

Et 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)

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 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!
Et enfin, les méthodes 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.

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 celà 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, vosu 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 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 sourlignera 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.

Vous voyez tout à gauche 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)

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 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. (Ca 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 celà 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 clef new.

Il faudra comme pour les variables préciser 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, 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 à un attribut, il faut d'abord préciser sur quel objet 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.
Donc en résumant le code de base on aura ceci. (pour un objet créer dns 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 allons pas commencez tout de suite par celà, nous allons maintenant passer au point suivant et vous pourrez enfin faire votre premier programme en Java!

Exemples de petits programmes

La syntaxe, elle est semblable à celle de c/c++.

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

Exemple de syntaxe :
Créer un projet (project => new project)
Créer une classe que vous appellerez SayHello (edit => new class) et écrivez y le code suivant!


Compiler le en cliquant sur le bouton compile en haut de votre classe!


Explication de ce code de base. (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 standart pour les programmes en console.

out est un objet de la classe System (un flux de sortie) qui permet de gérer les soties consoles.

println est une méthode de la classe System qui passe le texte à afficher à la sortie console puis passe à la ligne.

C'est une instruction importante à mémoriser. Il sera souvent utilse pour des programmes complexe 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 Word à 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 mit dans une variable.
Faîtes une autre classe et donnez lui un nom.


Tout d'abord ne vous occuppez 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 appellé lectureClavier, celui-ci va lire le texte qu'on aura tapper au clavier.
Vous voyez que entre les parenthèses du new j'ai mis, System.in, c'est normal.
in est l'objet 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.
Ca peut sembler superflux au début mais c'est normal.

La méthode main

Comme en 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.

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 du 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.
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.


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



Astuces 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 é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 back slash que j'ai rajouté et ainsi de suite jusqu'à que ça marche au lieu de tout redevoir à chaque fois remettre 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 varaibles et leur capacité de stockage en mémoire.
byte = 1 octets. (des nombres entiers que 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 très grands)
char = 2 octets. (un caractère) 2 exposant 16 caractères différents correspondant à 1 nombre : c'est le code UNICODE

La lettre devra être mit 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)
float ça équivaut donc à des nombres décimaux à virgule flottante à simple précision 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)

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

boolean = 1 octet avec 2 valeur possibles (soit true, soit false) type de variable particulier utiliser pour simplifié l'utilisation de tests 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 double donc faîtes de même.

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


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

En java, les variables peuvent se déclarer n'importe ou dans le programme, dans n'importe quel bloc. (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.
-On utilisera l'underscore '_' pour séparer les mots.
-Ou alors on peut faire comme ça : nomDeLetudiant.
-Pas de caractères accentués, d'apostrophes,de virgules, ...
-Le nom des variables ne peut pas être un mot clef 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 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é 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.

Exemple de déclarations (variable simples)


...

Déclaration de constantes.

C'est une variable mais 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 le 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 clef final qui permet de définir des constantes, c'est comme #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 :

Celà 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 pour le type de la variable, plus il y a de précision.

Or on a vu que les variables peuvent avoir des type 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étique sur des variables de type mixtes!

Exemple : on veut faire ce calcul ci.
var1 est de type double.
var 2 et var 3 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 du 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. 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 l'expression en entier et la mettre 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 plus.

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, ...
Exemple :



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

L'addition de 2 variables :

la soustraction :

la multiplication :


La division :

l'opérateur modulo :


Il renvoie le reste d'une division entière de 2 nombres entiers.

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 telle que Math.sqrt (), attention la méthode sqrt renvoie un double!
la méthode sqrt de la classe Math calcule la racine carrée d'un nombre.

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 pas 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.

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 (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. Chacunes 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.

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 dire à la classe System, qu'elle doit afficher quelquechose à 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 d'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.

C'est pour pas confondre le nom des méthodes et celui des variables appelée sur 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 faudrat préciser le type du 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.

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

System.exit (0).

Partie I (suite)

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 liste plus loins)
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)
[color = red]Il n'est pas nécessaire comme en c de préciser la longueur de la chaîne de caractère![/color]

Vous verrez plus tard que les listes sont extensibles et n'ont pas de taille, leur dernière é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 toute 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.

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) :
Bon j'vais é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 package : une bonne façon de regrouper les classes

Ce sont en fait des regroupements de classes. Il 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 :

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)