cour en java

1. LOGO
Plan
3
Class Vs Objet2
3
1
4 Encapsulation
Les Variables
5 Constructeur
1 Introduction
6 Héritage
7 Les classes abstraites et les Interfaces
8 Les Exceptions
9 Les Threads

2. LOGO2
Introduction
Java est un langage de POO éditer par SUN Microsystem ‘récemment achetée par
Oracle’.
Java est un langage supporté par la communauté des grands éditeur logiciel ‘IBM,
BEA Web Logique, Oracle, Red Hat …’
Au début Java a été destiné pour résoudre le problème de multitude des plateformes
de développement des terminaux mobiles.
Après le succès des Applet dans le monde web Java a devenu le langage le plus
utilisé dans le monde entier.

3. LOGO3
Introduction
Une fois compiler un fichier .java le compilateur nous génère un fichier .class ‘byte
code’ .
Le fichier .class sera interprété par la JVM ’Java Virtuel Machine’ pour assurer
l’indépendance % OS.

4. LOGO4
Class Vs Objet
La Class est une abstraction du monde ‘Exemple Homme, Femme etc.’.
La Class regroupe les caractéristiques de l’abstraction du monde ‘un Homme a un
nom, prénom, âge etc.’

5. LOGO5
Class Vs Objet
L’objet est la manifestation concrète d’une class, donc la manifestation concrète de
l’abstraction du monde . ‘c’est ce qui existe dans le mon réel c’est Mr.
Ahmed, Mr. Younes et non pas Homme.’
L’objet regroupe les données concrètes ‘Mr. Ahmed, El Alaoui,40 ans’

6. LOGO6
Les Variables
Dans JAVA il y a trois types de variable :
Variable local : déclarer un sein d’une méthode ‘ou constructeur’, elle est propre à la
méthode et nulle autre méthode ou class peut y accéder.
Variable d’instance : déclarer au sein de la class et hors toutes méthodes ou
constructeurs, et chaque objet stocke sa propre valeur dans cette variable.
Variable de class : comme la variable d’instance, elle est déclarer au sein de la class
et hors toutes méthodes ou constructeurs, et tous les objets partage cette
variable ‘le mot clé static distingue les variables de class dans Java’.

7. LOGO7
Les Variables
Dans JAVA il y a trois types de variable :

8. LOGO8
Les Variables
La variable de class nbrPersonne est partagé par tous les objets ‘X, Y, Z, Alpha et Beta’
de type Personne

9. LOGO9
Les Variables : TP 1
Créer une class Personne (age,nom,prénom) en suivant les JNS.
1- Créer trois attributs de la class Personne int age String nom et String prénom
2- Créer une méthode String toSting() qui affiche les propriétés de la class Personne
3- Calculer le nombre de fois que la méthode toSting() a été invoquer par la totalité des
objets.
4- Calculer le nombre de fois que la méthode toSting() a été invoquer par un objet.

10. LOGO10
Encapsulation
L’encapsulation est l’un des concepts fondamentale de la OOP il consiste à :
Protéger les variables ‘d’instance ou de class’ contre les manipulations inappropriés
‘personne.age = -12 !!!’.
Techniquement c’est réduire la visibilité des variables à ‘private’ et implémenter des
Getters and Setters pour y accéder.
Le Getter est une méthode pour accéder à une variable en mode lecture seule, alors
que le Setter en mode écriture ‘avant de faire la modification des variables
dans le Setter on fait des testes if(age>0){//modifier age}’

11. LOGO11
Encapsulation

12. LOGO12
Constructeur
La création d’un objet se fait dans le constructeur où on initialise les différents
attributs.
Le constructeur porte le même nom que sa class.
Si le programmeur n’a pas mentionner un Constructeur, il sera généré
automatiquement par le compilateur.
On pourra surchargé le constructeur pour personnaliser l’initiation de nos
paramètres.

13. LOGO13
TP 2
1- Créer une class Personne (age,nom,prénom) en respectant le principe de
l’encapsulation.
2- Créer un constructeur par défaut qui initialise les attributs de la class Personne.
3- Créer un constructeur avec argument qui initialise les attributs de la class Personne.
4- Instancier un objet en utilisant le constructeur par défaut et le constructeur avec
arguments.

14. LOGO14
Héritage
L’héritage exprime une relation sémantique entre deux classes ‘, il reflète la relation
IS A entre deux classes’
L’héritage en Java se fait par le mot clé extends.
L’héritage permet la non duplication du code source.
La class fille hérite toutes les méthodes et les attributs de la class mère et elle peut
redéfinir ‘en cas de nécessité’ les méthodes déjà hérité.
La class fille n’hérite pas le/les constructeurs.

15. LOGO15
Héritage
Toutes les classes hérite par défaut de la class Object.
L’héritage permet de gérer le problème de duplication du code ( en centralisant le
code redondant dans la class mère )
L’héritage permet plus de souplesse à notre code source.
L’héritage permet de capturer des relations naturelle et réelle.

16. LOGO16
Héritage&Encapsulation
Pour une class On distingue 2 niveau de visibilités :
Public : la class est vue par toutes les autres class.
Default : la class est vue seulement par les classes de la même package.
Si une class peut voir une autre class cela signifie pas qu’elle peut l’utilisée.
La Visibilité d’une class est la première condition de son utilisation.
On a le droit d’une seule public class par fichier.

17. LOGO17
Héritage&Encapsulation
On distingue 4 niveau de visibilités pour les méthodes les attributs d’instance&class :
visibilité Public Protected Default Private
la même class OK OK OK OK
classes de la
même package
OK OK OK NO
Une class fille qui
se trouve dans le
même package
OK OK OK NO
Une class fille qui
se trouve dans un
autre package
OK OK NO NO
Une class non-
fille qui se trouve
dans un autre
package
OK NO NO NO

18. LOGO18
Héritage&Encapsulation

19. LOGO19
Héritage
Les 3 étapes de création d’un objet sont les suivant
Personne pers1 : c’est la déclaration de la référence de type Personne;
new Personne() : c’est la création de l’instance via le constructeur sans argument;
Personne pers1 = new Personne() : l’affectation de l’instance à la référence.
La Référence doit être soit une class mère de l’instance, soit l’instance elle même.

20. LOGO20
Surcharge&Redéfinition
On parle d’une méthode redéfinie ‘overriden’ lorsqu’une class fille :
Redéfini une méthode héritée en gardant le même nom du fonction avec les même
arguments ‘avec leurs ordre’ et aussi le même type de retour ‘les propriétés de
la fonction ‘nom, arguments et le type de retour est précisée par la class
mère’’.
La méthode redéfinie doit avoir une visibilité plus large que celle de la class mère
On parle d’une méthode surchargée ‘overloaded’ lorsque la même class réutilise le
même nom d’une fonction avec des arguments différents.
Les méthodes peuvent être surchargées ou redéfinies alors que les constructeurs
peuvent être seulement surchargés.
Polymorphisme  Redéfinition et non pas la surcharge.
instance  Redéfinition && référence  surcharge.

21. LOGO21
Héritage&Polymorphisme
Polymorphisme nous permet de manipuler des objets sans vraiment connaître leur
type ‘on connait juste la référence mais le type de l’instance sera déterminé au moment
de l’exécution’.
Exemple :
Etape 1 : Dans la class Personne on définit la méthode décriToi() et dans sa class
fille Habitant on redéfinit la méthode décriToi()
Etape 2 : List<Personne> pers = new ArrayList<Personne> ();
pers.add(new Personne())
pers.add(new Habitant())
Etape 3 : for (Iterator<Personne> iterator = personnes.iterator(); iterator.hasNext();)
{Personne personne = (Personne) iterator.next();
personne.presenteToi(); }

22. LOGO22
Héritage&Constructeur
L’initialisation des paramètres d’une class passe par l’initialisation des attributs de la
class mère selon les règles suivants :
Dans un constructeur la première ligne doit être soit super() ou this().
Par défaut le constructeur d’une class invoque le constructeur de sa class mère.
Toutes les classes héritent directement ou indirectement de la class Object.

23. LOGO23
Les tableaux et les listes
Un tableau est un empilement d’objet ou de primitif de taille fixe
exemple : int tab = new int[3]; ou bien Personne prs = new Personne[9];
La manipulation d’un tableau se fait d’une manière standard (on boucle sur le
tableau et on accède à chaque fois à l’élément d’indice i)
Une liste est un empilement d’objet de taille variable.
exemple : ArrayList liste = new ArrayList();
A partir de Java 1.5 on peut spécifier le type des éléments de la liste
exemple : ArrayList<String> liste = new ArrayList<String>();
exemple : ArrayList<Personne> liste = new ArrayList<Personne>();

24. LOGO24
Les tableaux et les listes
Pour manipuler une liste il y a plusieurs méthodes prédéfinis : add(Object o), get(int
indice), size(), remove(int indice)..
Pour parcourir une liste 3 alternatives sont possibles : une simple boucle for,
enhaced boucle, et le Iterator)
Plusieurs type de liste sont proposés par JAVA : ArrayList, LinkedList, HashList…
NB : Voir TP 2 et 3

25. LOGO25
Les classes abstraites et les
Interfaces
Une class abstraite reflète un concept inexistant dans la réalité mais qui nous
permet de s’organiser.
Une class abstraite est une class qui a un comportement non tangible.
Une class abstraite centralise des attributs et des méthodes (c’est le point de
différence avec une Interface).
Logiquement c’est interdit d’instancier une class abstraite.

26. LOGO26
Les classes abstraites et les
Interfaces
Une class est déclarée abstraite via le mot clé abstract.
Les méthodes abstraites n’ont pas un corps ( elles se terminent par un point virgule
puisqu’il ne contient pas un comportement)
Les méthodes abstraites d’une class abstraite doivent être redéfinie dans la première
class fille concrète.
Une class abstraite peut contenir des méthodes non abstraites.

27. LOGO27
Les classes abstraites et les
Interfaces
Une interface est une class dont toutes les méthodes sont abstraites (class abstraite
à 100%).
Une interface est un contrat qui doit être respecté.
On peut implémenter plusieurs Interfaces à la fois.
Toutes les attributs déclarés dans une interface sont des constantes qui ne peuvent
pas être modifié .

28. LOGO28
Les classes abstraites et les
Interfaces
Une interface peut hérité d’une autre interface.
La première class concrète doit redéfinir toutes les méthodes définis dans son
interface mère.
Les interfaces sont largement utilisées comme une vision client « Spring, EJB, WS ».
Les interfaces sont largement utilisées dans les Design Pattern « code to interface
not to implementation» .

29. LOGO29
Les classes abstraites et les
Interfaces
Une interface est déclarée via le mot clé interface.
Une méthode d’une interface est par défaut déclarée comme public abstract.
Les attributs d’une interface sont marqués ‘par défaut’ comme public static final.
L’interface sert comme une référence à ses implémentation.
Une interface s'implémente dans une classe en utilisant le mot clé implements.

30. LOGO
Remerciement
30
Merci Pour Votre AttentionMerci Pour Votre Attention