Introduction : l'histoire de Java

Java, appelé OAK à l'origine, est un langage de programmation orienté objet qui est né dans les années 90.
Il a été inventé dans le but de rendre interactif les appareils électroménagers entre eux.
Mais le projet fut un échec.
Par contre le langage a été reprit car c'est aussi à ce moment là qu'il y eu l'expention d'Internet!
Ce langage a donc été utilisé beaucoup car il peut marcher sous n'importe quel machine et système d'exploitation et pouvait rendre les pages internet interactives entre elles!

Il y eu une crise car sun (une grande entreprise de développement) à reprit le langage Java (window refusait de rendre le sien public) et ça lui fut devenir un langage privé. (plus accessible à tous)
Ce fut une grande perte pour les développeurs.
Mais heureusement, sun a accepté finalement de rendre ce langage publique! (accessible à tous)

Les différentes versions de Java :
Le Java à évolué de la version 1 à la version 6!

Il possède trois types de version servant à développer dans un domaine bien précis.

Java micro edition (JME) pour les systèmes portable. (gsm, etc...)
Java standart edition (JSE) pour les PC standarts. (PC portables, PC de bureau, etc...)
Java entreprise edition (JEE) pour les grandes entreprises qui ont un réseaux local. (client, serveur)

Chapitre 1 : Les bases du langage.

Toutes les instructions se termineront par un point virgule.(instruction;)
Tout les blocs de code seront mit entre accolades. {bloc d'instructions;}
Votre programme devra contenir au moins une méthode main et une classe la contenant pour pourvoir s'exécuter.
[information]Chaque classe que vous créerai peut contenir une méthode main pour la tester, mais au final une seule pourra être exécutée!
Voici le code minimal à avoir commun à tout vos programmes.
public class Test {
public static void main (String[] args) {
}
}
L'instruction print de la classe System permet d'afficher du texte à l'écran voici la syntaxe :
System.out.print("Bonjour!");
out est l'objet qui correspond à votre sortie écran, et System est la classe gérant principalement les flux d'entrée et sortie console!
Rajouter les instructions à l'intérieur de la méthode main.
L'instruction println est pareille à part qu'elle passe à la ligne.

System.out.println("Bonjour!")

Récupérer du texte à l'écran :
Il faut d'abord importer la classe Scanner qui se trouve dans le répertoire java.util!

L'importation se fait tout au début, avant la déclaration de la classe.

Comme ceci : import java.util.Scanner;

Il est vivement conseillé de créer vous aussi un dossier pour regrouper vos classe.

Pour ce faire, il faut ajouter ceci : (première ligne de votre programme)
package nomDeMonPackage;

Ensuite il faut dans votre main que vous créer un objet de type Scanner qui lira votre texte.
comme ceci :
Scanner lectureClavier = new Scanner (System.in);
Pour faire plus pro, on ne dira pas créer un objet mais instancier un objet.

Lors de sa création, l'objet Scanner prend un paramètre : l'objet in de la classe System qui correspondra à votre flux d'entrée.
Après il faut afficher un message à l'écran demandant à l'utilisateur d'entrer son texte.

Et enfin, il reste plus qu'a récupérer le texte tapé à l'écran dans une variable grâce à la méthode nextLine de la classe Scanner.

La classe String permet de stocker des objets de type chaîne de caractère :
String chaine = lectureClavier.nextLine ();
Ensuite afficher ce que l'utilisateur à taper.

Ce qui (en reprenant tout le code) nous donne ceci :
package nomPackage;
import java.util.Scanner;
public class Test {
public static void main (String [] args) {
Scanner lectureClavier = new Scanner (System.in);
System.out.println("Entrer votre texte : ");
String texte = lectureClavier.nextLine ();
System.out.println("Votre texte est : "+texte);
}
}

En ce qui concerne les packages : ce sont des répertoires regroupant vos classes, ils peuvent contenir aussi des sous répertoires.

Les répertoires et nom de classes lors de l'utilisation dans le programme sont séparé par un point et nom par un anti slach comme dans les chemins d'accès de windows comme vous avez pu le remarquer ici : import java.util.Scanner;
Et pas import java\util\Scanner;

Pareil lors de la création de répertoires et sous répertoire dans votre projet :
package monPackage.sousPackage;

Un package contenant les classes permettant de faire fonctionner correctement le langage Java est importé par défault dans votre programme, il s'agit de java.lang, les autres classes ne se trouvant pas dans ce package devront être importées dans votre programme!

Les variables : Il en existe de huit sortes, elles sont de type primitif car ce ne sont pas des objets! (Il y en a 8)
byte : [-127 à +128]
short : [-(2 puissance 8 / 2) + 1 à 2 puissance 8/ 2)]
int : [-(2 puissance 16 / 2) + 1 à 2 puissance 16 )]
long : [-(2 puissance 32 / 2) + 1 à 2 puissane 32)]
char : 2 puissance 16 lettres différentes.
float : Nombre décimaux à simple précision : max 2 puissance 12 chiffres, un octet est réservé pour la position de la virgule.
D'où nombre à virgule flottante car la position de la virgule peut varier.
double : Nombre décimaux à double précision : max 2 puissance 27 chiffres, un octet est réservé pour la position de la virgule.
Si vous mettez un nombre trop grand pour un type de variable, vous faîtes une erreur de dépassement de capacité. (overflow)
Prenez un type qui offre plus d'octets!
Pour les nombres décimaux, si vous mettez trop de chiffres après la virgule, vous faîtes un sous dépassement de capacité(underflow), prenez un type qui offre plus d'octet.
boolean : 2 valeurs possibles : true ou false. (Variables utilisées pour simplifier les tests)

La déclaration des variables : partout dans le programme, mais n'existent que dans le bloc d'instruction ou elles sont déclarées!
int var1, var2;
char caract;

Affectation d'une valeur à une variable, elle se fait avec le symbole égal, l'affectation se fait de droite à gauche :
var1 = 1;
var2 = 5;
caract = 'a';

Le compilateur à deux règles pour les variables :
La promotion numérique : java travaille minimum avec des type int, lors de vos calculs, la valeur de vos variables de type byte et short sera convertie en int, seul la valeur de vos variables changeront, le type de vos variable restera toujours le même dans tout votre programme!
Les conversions d'ajustement de type : lors de calculs avec des variables de type mixte : les valeurs de vos variables seront converties en celle qui a le plus de précision, la précision (du moins au plus précis) va dans ce sens :
byte => short => int => long => float => double
char
Si vous mettez une variable de type int dans un type double, le compilateur fera la conversion de la valeur int en double avant de l'affecter dans votre variable de type double.
Par contre si vous mettez une variable de type double dans un int, il ne compilera pas, car vous perdrez la partie décimale du nombre.
Si vous voulez vraiment le faire, il vous faudra utiliser l'opération de cast comme ceci :
double var2 = 5,6;
int var1 = (int) var2;
var1 vaudra 5. (le nombre tronqué)

Les opération mathématiques sur les variables :
addition : res = var1 + var2.
soustraction : res = var1 - var2;
multiplication : res = var1 * var2;
division : res = var1 / var2;
l'opérateur modulo : res = var1 % var2 (renvoie le reste de la division euclidienne)
Les racourcis :
incrémentation : i = i+1 => i++ ou ++i;
décrémentation : i = i-1 => i-- ou --i;
Dans le cas de ++i, la valeur de i sera augmentée avant de réaliser une opération tandis que dans le cas de i++, se sera l'inverse.
addition : var1 += var2;
soustraction : var1 -= var2;
multiplication : var1 *= var2;
division : var1 /= var2;
modulo : var1 %= var2;


La classe String : Elle s'occupe des chaines de caractères, elle a plusieurs méthodes comme par exemple length qui renvoie la longueur d'une chaine de caractère, substring qui récupère une sous chaine de votre chaine de caractères, et toutes vos chaines de caractères se terminent par un caractère spécial , le '\0'.
Les chaines de caractères se mettent entre guillemets.

Les séquences d'échappements : elles ont étées établies pour faire afficher des retours à la ligne, des tabulations, etc...

Exemple : afficher des guillemets : System.out.println("Il m'a dit \"bonjour\"");
Il en existe plein d'autres :
\n retour à la ligne.
\r retour chariot.
\t tabulation.
etc...

La concaténation : Permet de fusionner plusieurs chaines de caractère et même fusionner des chaines de caractère et le contenu d'une variable!

String chaine1 = "Bonjour!\nJ'ai ";
String chaine2 = " ans.";
int age = 16;
String chaineConca = chaine1 + age + chaine2;

Cette chaine vaudra : "Bonjour!\nJ'ai 16 ans.".
Ca affichera :
Bonjour!
J'ai 16 ans.

chapitre 2 : les structures de contrôles

L'alternative : elle permet d'exécuter certaines instructions si une condition est vraie et éventuellement en exécuter d'autres si la condition est fausse.

Établir une condition : il suffira de comparer deux variables entre elles.
l'égalité : var1 == var2;
Strictement plus grand que : var1 > var2;
Plus grand ou égal : var1 >= var2;
Strictement plus petit que : var1 < var2;
Plus petit ou égal : var1 <= var2;
Différent de : var1 != var2;
On peut comparer une variable avec une autre variable ou avec une valeur. (ceci s'appelle faire un prédicat)

Les condition multiples : ce sont plusieurs conditions reliées entre elle par des opérateurs logiques.
Le et : var1 < var2 && var1 < 5 => Renvoie vrai si les deux conditions sont vraies.
le ou exclusif : var1 < var2 | var1 < 5 => Renvoie vrai si une et une seule des deux conditions est vraie.
le ou inclusif : var1 < var2 || var1 < 5 => Renvoie vrai si une ou les deux conditions sont vraies.
le non : !(var1 < var2) => Renvoie vrai lorsque la condition est fausse!


Construction des alternatives : La condition qui doit être vérifiée se met dans un if comme ceci :
if ((var1 < var2) && (var < 5)) {
instructions à exécuter si la condition est vraie.
} else {
instructions à exécuter si la condition est fausse. (pas obligatoire)
}
On peut inclure un if dans un autre comme ceci :
if (var1 < var2) {
if (var2 < 5) {
}
}

Le else if permet de refaire un test si la condition est fausse :
if (var1 < var2) {
}
else if (var1 < 5) {
}

Les variables booléennes : permettent de simplifier un test.
Utilisation de variable booléennes dans un test :
boolean var1 = true;
if (var1) revient au même que d'écrire if (var1 == true)
if (!var1) revient à écrire if (var1 == false)

L'instruction switch : évalue une variable (de type int, char, byte, short ou long uniquement) en fonction des différentes valeurs qu'elle peut prendre :
switch (var1) {
case 1 : instructions si var1 vaut 1 break; //Le break signifie sortir du switch!
case 2 : instructions si var1 vaut 2 break; //Si on met pas le break, les instructions du switch qui suivent seront aussi exécutées!
case 3 : instructions si var1 vaut 3; //Exemple sans le break.
case 4 : instructions si var1 vaut 3 ou 4;
default : instructions si aucune valeur de var1 ne correspond à celle d'un case.
}

L'opérateur ternaire : Permet d'évaluer une condition de manière simple comme ceci :
(condition ? instruction si vrai : instruction si faux);

Les structures répétitives.

Le for : Permet de répété une série d'instructions n fois :
for (int n = 0; n < 5; n++) {
instructions;
}
On peut incrémenter plusieurs variables à la fois comme ceci :
for (int n = 0, x = 5; n < 5; n++; x += 2) {
instructions
}
Le while : permet de répéter des instructions 0, 1 ou n fois tant que une condition est vraie.

int n = 0;
while (n < 5) {
n++
instructions
}

Le do~while : pareil que le while sauf que les instructions dans le do~while seront exécutées au moins une fois quoi qu'il arrive.
int n = 5;
do {
instructions
n++;
} while (n < 5);

Le break et le continue : le break permet de sortir d'une boucle lors d'un test dedans par exemple.

for(int n = 0; n < 5; n) {
instructions
if (n = 4) break;
instructions
}


Et le continue permet d'ignorer les instructions qui suivent dans une boucle lors d'un test dedans par exemple :

for (int n = 0; n < 5; n++) {
instructions
if (n = 3) continue;
instructions
}
Le break et le continue peuvent s'utiliser dans un for, un while et un do~while.

Les boucles infinies :
for ( ; ; ) {} (On met juste les ";" dans le for)
while (true) {} (Toujours vrai)
do {} while(true);

Chapitre 3 : les tableaux.

Les tableaux sont des variables spéciales qui peuvent stocker une grande quantité de valeurs.
Chaque valeur aura une place dans le tableau, et pourra être récupéré par son index dans le tableau.

L'index est toujours une variable de type entier et est toujours un nombre positif!
Déclaration d'un tableau : int[] iTab;
Les tableaux sont des objets, il faut donc les instancier :
int[] iTab = new int[50]; //On l'instancie en indiquant sa taille. (ici je crée un tableau qui pourra contenir 50 valeurs)

Affectation d'un tableau : soit comme ceci : iTab = {0, 7, 8, 9, ...};

Ou alors avec une boucle :
for (int i = 0; i < iTab.length; i++) {
iTab[i] = i;
}

On peut rassembler initialisation, création et affectation comme ceci :
int[] iTab = new int[]{0, 5, 6, 10, ...};

Les tableaux à plusieurs dimensions :

Chaque valeur du tableau ne sera plus associée à un seul index, mais à deux index. (Plus que deux c'est déconseiller)

int [][] iTab = new int[][]{3, 4, 7},{6, 5, 3};

On va utiliser donc deux boucles for imbriquées pour la deuxième solution pour les affecter à des valeurs.

for (int i = 0; i < iTab.length; i++) {
for (int j = 0; j < iTab[].length; j++) {
iTab[i][j] = i;
}
}

Il est possible de copier un tableau dans un autre, etc.. (revoir le chapitre concerné pour plus d'information sur les tableaux)

Les fonctions en Java appelées les méthodes

Il y en a de deux type : celles qui retournent une valeur.

public int getValeur () {
valeur = 5;
return valeur;
}

Et celles qui n'en retourne pas.

public void (int v1, int v2) {
v1 += 3;
v2 += 6;
}

Attention, pas de pointeurs en Java!

Mais les variables modifiées sur vos objet seront modifiées.

Une méthode peut posséder 0, 1 un ou plusieurs paramètres.

Il n'est pas nécessaire de déclarer les prototypes des méthodes dans la classe comme en c++.

L'appel des méthodes dans votre programme principale :
Il y a deux sortes de méthodes :

Les méthode appelées sur le nom d'une classe. (méthode statiques)

C'est le cas de la méthode random de la classe Math :
double nombre = Math.random () * 100;

Lors de leur création, ses méthodes seront précédé du mot clé static devant comme ceci :
public static void maMethode () {
}

Les méthodes non statique : il faut d'abord instancier un objet de la classe pour pouvoir les appeler.
C'est le cas de la méthode nextLine de la classe Scanner :
Scanner lectureClavier = new Scanner(System.in);
String chaine = lectureClavier.nextLine();

Lors de leur création donc, pas de mot clé statique devant!

Les variables de classe et les variables d'objet.

Les variables propres aux objets pourront prendre des valeurs différentes en fonction de l'objet que vous instancier.
Les variables de classe elle, leur valeur sera commune pour tout les objets que vous créerai :
Déclaration d'une variable statique :
private static int NbObjetCreer;

Les limites : Dans des méthodes statiques, on ne pourra modifier le contenu uniquement que de variables déclarées statiques et on ne pourra faire appel que à des méthodes statiques!

Voilà j'ai fini le récapitulatif en ce qui concerne la première partie du cours.

Chapitre 1 : Le monde le la POO

On a vu que la POO était un moyen de simplifier la lecture du code.

Pour cela je vais faire une comparaison entre les langages orientés objets et les langages procéduraux.

Langages procéduraux : Ceux-ci donc, ne s'intéressent qu'aux grandes finctionnalités de votre programmme.

Il découpe donc le code de votre programme selon les grandes fonctions que celui-ci devra pouvoir faire.
Les fonctions seront donc communes pour tout dans votre programme et lors d'un changement, une mise à jour, il faudra revérifier le code de tout votre programme et appliquer les changements.

Langages orientés objet : Ils permettent de pouvoir identifier les grands acteurs de votre programme.
Chaque acteur aura ses caractéristiques propres (les variables) qui pourront changer de valeur et ses propres fonctions. (Appelé les méthodes)

On ne fait donc plus une seule découpe dans le code, mais deux. D'abord on identifie les grands acteurs du programme et leurs attributs, et ensuite on s'intéresse aux grandes fonctionnalités que doivent pouvoir accomplir ces acteurs.

Les caractéristiques propres à chaque acteur ne seront pas accessibles aux autres, les autres ne pourront que les modifier grâce aux méthodes, c'est le principe de l'encapsulation. (un avantage de la POO)
Les différents acteurs du programme porteront le nom de (c'est pas une insulte) objet.

Chaque classe sera garante de respecter le principe d'encapsulation, une classe est un moule permettant de créer correctement les types d'objets avec ses valeurs par défaut(le constructeur), ses variables (privées) et ses méthode (publiques)

Une classe permet de créer donc des types de variables plus complexes avec des fonctions et des variables qui lui sont propre!

Une classe peut avoir comme variable des objets d'une autre classe, le type d'une variable objet, que j'appellerai maintenant variable d'instance, sera tout simplement le nom de sa classe.

Tous les objets instancier à partir d'une même classe possèderont le même nombre de variables, les même nom mais chaque objet pourra avoir une valeur différentes pour ses variables. (sauf celle qui seront déclaré statique)

Pareil pour les méthodes : les objets appartenant à une même classe auront tous les même méthodes. Et ses méthodes devront être appelées sur une variable d'instance de leur classe. (sauf pour les méthode statique)

Cela parait compliqué, mais une fois que vous aurez comprit le principe, ce sera encore plus simple pour vous de faire des jeux en Java que d'en faire en C++ qui n'est pas un langage orienté objet à 100%, et qui est plus compliqué à utiliser que le Java à cause des pointeurs, des destructeurs, etc...

En effet, j'ai déjà tester les deux langages, et je trouves que le Java est nettement plus simple, (même s'il est moins performant car il y a pas de pointeurs) mais le Java ne vise pas la performance mais plutôt la simplicité de conception!

Vous verrez que en Java, on sait en faire autant qu'en C++!!

Un langage n'est pas meilleur qu'un autre, c'est juste la manière d'encoder son programme qui est différente.

Créer une classe :
Il faut créer un nouveau projet et ensuite un nouveau package si vous n'en avez pas déjà un.

Ensuite suffit de cliquer sur le bouton new classe, et donner lui un nom.

comme ceci :
public class Voiture {

Ensuite on définit les variables de notre objet.

private int couleur;
private String marque;

Ensuite on définit ses méthodes avec le corps des méthodes :

public void changeMarque (String nvMarque) {
marque = nvMarque;
}

Il y a bien sur du procédural qui sera encore présent (on ne peut pas s'en passer des if, des boucles, etc...) mais il sera tout simplement moins important disons en orienté objet.

Et n'oublier pas de fermer votre classe à la fin!

Après il ne vous restera plus qu'à instancier ces objets dans votre méthode main avec le mot clefs new et d'appliquer les méthode nécessaires.
Voiture v1 = new Voiture ()

Lors de l'invocation de méthodes sur un objet, ou une classe pour les méthodes statiques, le nom de l'objet ou de votre classe et celui de la méthode sera toujours séparé par un point!

v1.changeMarque ("Peugeot");

A la fin de vos méthodes, mettez toujours des parenthèses sinon, votre programme croira que changeMarque est une variable! Ce sont donc les parenthèses qui différencie les méthodes des variables pour les objets.

La surcharge des méthodes :
La signature : c'est le nom de votre méthode suivit de la liste du type de ses arguments.

public void changeMarque (String nvMarque) à donc pour signature changeMarque (String)

C'est ce qui permet à votre compilateur de reconnaitre la méthode qu'il doit appeler dans votre classe.

La surcharge des méthodes : Ce sont des méthode qui ont le même nom mais dont la liste des types de ses arguments diffère.
Exemple :
public void change (String nbMarque) {}
signature : change (String)
public void change (int couleur) {}
signature : change (int) {}

Les constructeurs : c'est ce qui permet de donner une valeur par défaut à chaque variables de votre objet, lorsque vous le créer.

Le constructeur est appelé automatiquement lorsque vous instancier une classe avec new.

s'il n'y a pas de constructeur dans votre classe, le constructeur par défaut est appelé, il met tout vos variable int, double, etc... à zéro et vos objets à vide et vos booléens à false. (null)

Mais ce constructeur par défaut est déconseiller.

Pour créer un constructeur, on fait comme si on devait créer une méthode sauf que là, il n'y aura pas de type de retour même pas void!

Et le nom de votre constructeur sera toujours le même que celui de votre classe.

Un constructeur pourra avoir 0, 1 ou plusieurs arguments.

Il faut juste faire attention que si vous appeler un constructeur avec deux arguments lors de l'appel avec new, celui-ci existe dans la classe que vous voulez instancier.

Les constructeurs peuvent comme les méthodes être surchargés.

Exemple :

public Voiture () {
marque = "Peugeot";
couleur = 3;
}
public Voiture (Strin nvMarque, int nvCouleur) {
marque = nvMarque;
couleur = nvCouleur;
}

Et lors de l'instanciation de vos objets dans votre main :

Voiture v1 = new Voiture ();
Voiture v2 = new Voiture ("BMW", 5);

Le mot clef this.

Il fait référence à l'objet lui même qui est entrain d'être créer ou modifier.

Il a deux utilités : il est utilisé dans un constructeur pour ne pas confondre le nom d'une variable liées à un objet et le paramètre de votre constructeur.

Exemple :
public Voiture (String marque, int couleur) {
this.marque = marque;
this.couleur = couleur;
}

this pointe sur l'objet que vous êtes entrain d'instancier.

Chapitre 2 : L'association entre les classes

La composition :
Un objet peut en composer un autre.

Exemple, vous voulez mettre un moteur dans votre Voiture.

public class Voiture {
private Moteur moteur;
private String marque;
private int couleur;
//méthodes.
}
public class Moteur {
private int puissance;
//Méthodes.
}

L'objet moteur sera créer dans le constructeur de l'objet voiture comme ceci :
public class Voiture {
private Moteur moteur;
....
public Voiture () {
moteur = new Moteur ();
}

L'objet moteur sera stocké dans la mémoire de l'objet voiture.

Si l'objet voiture disparait de la mémoire, l'objet moteur disparaitra avec lui.

L'objet voiture est l'objet composite et l'objet moteur est l'objet composant.

L'agrégation.

Là, imaginer que l'on veut créer une classe feu de signalisation avec une voiture devant lui.

Au niveau de la déclaration des variables, il n'y a rien qui change :

public class FeuDeSignalisation {
private Voiture voitureDevant;
}

Ou ça change c'est dans le constructeur, on ne vas plus instancier l'objet dans le constructeur mais on va créer une variable qui servira de référent dans le paramètre du constructeur comme ceci :

public FeuDeSignalisation (Voiture voitureDevant) {

Et ensuite on copie l'attribut référent dans la variable de la classe.

this.voitureDevant = voitureDevant;

De ce fait, l'objet voiture n'est pas stocké dans la mémoire de l'objet feuDeGinalisation, donc si on supprime le feu, on ne supprime pas l'objet voiture.

La dépendance :
Là, on ne va plus déclarer la variable d'instance dans la classe, mais on va le faire dans une de ses méthode

exemple :
public changeMoteur (Moteur moteur) {
moteur.change(12);
}

Là, l'objet moteur n'existera en fait que le temps de l'exécution de la méthode.

Votre objet moteur est stocké dans la mémoire des méthodes.

Envoi de messages :

Il s'agit de faire communiquer plusieurs objets entre eux.

L'objet qui sera chargé d'appeler une méthode sur un autre objet sera appelé l'objet expéditeur et celui qui recevra le message sera appelé objet destinataire.

Pour cela, il faut créer un lien vers l'objet destinataire dans la classe de l'expéditeur.

On peut soit le faire via l'agrégation/composition ou via la dépendance.

Exemple dans le premier cas :
public class O1 {
....
public void methodeDeO1 () {}
}
public class O2 {
private lienO1 o1;
public O2 (O1 o1) {
lienO1 = o1;
}
public void methodeDeO2 () {
lienO1.methodeDeO1();
}
}

Exemple dans le second cas :

public class O2 {
public void methodeDeO2 (lienO1 o1) {
o1.methodeDeO1 ();
}
}

La gestion d'évènement et l'envoi de messages :

Imaginer qu'on aie une classe feuDeSignalisation et une classe Voiture :
Soit que l'on décide que le feu envoie un message à la voiture dès qu'il passe au vert pour la faire redémarrer.

C'est l'envoi de messages.

Ou bien la voiture attend que le feu soit vert avant de redémarrer : c'est la gestion d'évènement.

Chapitre 3 : L'héritage, les classe abstraites et interfaces.

L'héritage : C'est en fait une hiérarchie de classes, un classement et les classes qui permettent de créer des objets plus généraux sont placés en haut de la hiérarchie.

La classe la plus haute est la classe Object, toutes les classes que vous créer en hérite automatiquement.

Ensuite tout en bas on a les classes qui créent des objets plus particulier comme la classe String par exemple.

L'héritage permet de na pas devoir réécrire le code des méthodes qui se trouvent dans les classes créant des objets plus génériques dans les classes filles.

La classe la plus générale sera appelée la superclasse et les classes plus spécifiques seront appelé les sous classes.

Comment dire à une sous classe qu'elle hérite d'une superClasse :

comme ceci :

public class Fille extends Mere {}

L'héritage des constructeurs, il se fait à l'aide du mot clef super :

public class Fille {
super ();
}

Ce mot clef appel automatiquement le constructeur de votre superclasse.

La redéfinition des méthodes :

C'est une méthode héritée de la superclasse qui sera redéfinie pour une sous classe :

public void maMethode () {
super.maMethode ();
....
}

On peut réinvoquer la méthode de la superclasse dans celle de la classe fille, ça permet de réutiliser le code de la méthode qui a été redéfinie!
Une méthode redéfinie doit posséder la même en tête que celle de la superclasse.

Le polymorphisme : L'objet expéditeur de message n'a pas besoin de connaitre le type bien précis de votre objet destinataire, le compilateur va, s'il ne trouve pas la méthode dans votre sous classe, aller la rechercher dans votre superclasse.

Le casting implicite : Il s'agit d'affecter une variable instance de votre sous classe dans une variable instance de votre superclasse, le compilateur ne bronchera pas.
C'est la covariance des variables.

Le casting explicite : Il s'agit de faire l'inverse, affecter une variable instance de votre superclasse à une variable instance de votre sous classe, là, le compilateur ne va pas accepter, vous devrez appliquer l'opération de cast comme on a vu pour mettre une variable de type double dans une variable de type int.

Les classe abstraite :
On déclarera une classe abstraite que lorsqu'on voudra ne pas instancier des objets de la superclasse :

public abstract class Mere {}

Méthode abstraite :

C'est une méthode qui ne possède pas de corps.


public abstract maMethode ();

Les méthodes abstraite de la superclasse devront être redéfinies dans toutes leurs sous classes!

Une classes abstraite peut posséder 0, 1 ou n méthodes abstraites mais, une classe contenant une méthode abstraite devra être déclarée abstraite obligatoirement.

Les classes abstraite ne pourront donc pas être instanciées.

Les interfaces : Elles permettent de créer d'autres super classes qui pourront être implémentées, car l'héritage multiple est interdit en Java, une sous classe ne peut hérité que d'une seule superclasse.

Création d'une interface :
public interface I {

Cette interface ne devra contenir que des méthodes abstraites (sans le mot clef abstract devant) ou des constantes (d'office plublic static final) donc que des en tête de méthodes, et celles-ci devront être redéfinie toutes obligatoirement dans la classe qui implémente votre interface.

Une classe peut implémenter plusieurs interfaces.
Une interface pour implémenter plusieurs autres interfaces.
Une interface peut hériter d'une autre interface.

Chapitre bonus.

Les listes : ce sont des objets qui servent à stocker un grand nombre d'objets.
On peut les parcourir facilement grâce aux Iterator.
Voir le chapitre consacré aux listes pour les différents styles de listes.

Les Exceptions :

Le bloc try catch permet de récupérer une erreur :
try {
instructions.
}
catch (Exception e) {
instructions à appliquer en cas d'erreur.
}

Créer ses propres Exception :
On fait une classe héritée de la clase Exception:
public class PersoExcpetion extends Exception {
public PersoExcpetion () {
....
}

Jeter les erreurs :
On utilise les mot clefs throws et throw :

public class MaClassse {
public MaClasse () throws Excpetion {
if () throw new Exception ();
}
}

On peut bien sur jeter plusieurs exceptions à la fois.
Il ne faut pas oublier d'inclure le bloc try catch dans votre main.

La généricité.

Elle intervient lorsque l'on veut créer une classe mais qu'on ne sait pas quels types d'objets on va instancier.

On fera appel donc à des variables génériques qui n'auront pas de type précis avant leur utilisation.

On déclare les variables générique comme ceci :

public class Solo <T>
pirvate T var1;
//méthodes

Ensuite lors de l'utilisation ont peut donc créer n'importe quel type d'objet et utiliser les méthodes de la classe Solo sur n'importe quel type d'objet.

Solo<Integer> solo = new Solo<Integer>(12);

Mais là, on ne pourra instancier que des Integer, pour vraiment dire à la classe Solo qu'on veut instancier n'importe quelle type de variable, on utilisera la willcard '?' comme ceci :

Solo<?> solo = new Solo<Integer>(12);
int nombre = solo.getValeur ();
solo = new Solo<String>("Coucou!");
String chaine = solo.getValeur ();

etc....

La généricité et les collections :
On peut créer des listes d'objets avec la généricité comme ceci :

Solo <Integer> liste = new ArrayList ();


La généricité et l'héritage :

Circle hérite de point.

Solo<Circle> listeC = new ArrayList ();
Solo<Point> listeP = new ArrayList ();

La covariance des variables ne marche pas ici et le polymorphisme non plus car listeP n'accepte que des objet de type Point, on ne peut pas écrire :
ListeP = listeC!

Pour que cela soit autorisé on doit préciser que l'on peut
mettre des instances des sous classe et de sa superclasse dans la liste comme ceci :
ListP<? extends Point>

On fait la même chose si on veut mettre des instances d'une interface implémentée dans une classe dans la liste.

La réflexibilité.

Elle est utile car elle permet de récupérer des informations d'une classe.

A chaque fois que vous créer une classe, un objet de type classe est créé!
Pour récupérer les informations de cette classe, on utilisera des méthodes qui sont dans la classe Class.

Cette classe contient aussi des sous classes (Method, Constructor, Field, ...)
Voir la partie concernée pour découvrir toutes ces méthodes.

Ceci permet aussi l'instanciation dynamique. (sans le mot clé new)

La gestion des fichier en Java :

Pour créer un fichier dans votre projet, on crée un nouvel objet de type File en indiquant en paramètre le nom de votre fichier.

Ensuite on crée un objet FileWriter pour écrire dedans.

Il ne faut pas oublier de gérer les IOException à l'aide du bloc try catch.

La classe FileReader permet de lire dans un fichier caractère par caractère.

Grâce aux classe BufferedReader et BufferedWriter, on peut lire une ligne d'un coup dans un fichier.

(voir la partie concernée pour plus de détails)

Les classes et interface internes :
On peut imbriquer des classes dans des autres, ces classes seront privées, c'est surtout utile lorsqu'on doit créer des objets complexes et que l'on ne veut pas que les classes externes puissent accéder à leurs méthodes.

public class MaCLasse {
...
private class MaClasse interne {
....
}
}

Et on peut aussi inclure des interfaces internes, et redéfinir leurs méthodes abstraite dans les méthodes de votre classe, il suffit d'instancier votre interface dans un paramètre d'une de vos méthode qui a pour argument un objet de l'interface.

public interface I {
public void methode (int x);
}
public void methode2 (int x, I i) {
i.methode(x);
}
public void methode3 (int x) {
methode 2 (x, new I () {
public methode (int x) {
//Redéfinition.
} //Fin de la redéfinition.
});//Fin de l'instanciation et du code inséré à éxécuter.
}