Cours JAVA/J2EE concepts de base de la programmation orientée objet, tutoriel & guide de travaux pratiques en pdf.
Concepts de base de la programmation orientée objet
Introduction
« Tout est objet ! »
Le principe fondamental d’un langage orienté objet est que le langage doit permettre d’exprimer la solution d’un problème à l’aide des éléments de ce problèmes. Par exemple, un programme traitant des images doit manipuler des structures de données représentant des images, et non leur traduction sous formes d’une suite de bits. De cette façon, on procède à une abstraction.
Java est l’aboutissement (pour le moment, du moins) de ce concept. Pour Java, l’univers du problème à traiter est constitué d’objets. Cette approche est la plus naturelle car elle correspond à notre façon d’appréhender l’univers, ce qui facilite la modélisation des problèmes.
Rappelons ici le deuxième et troisième précepte de Descartes extraits du discours de la méthode (1637) et qui vont dans ce sens :
« Le deuxième, de diviser chacune des difficultés que j’examinerais , en autant de parcelles qu’il se pourrait, et qu’il serait requis pour les résoudre. »
« Le troisième, de conduire par ordre mes pensées, en commençant par les objets les plus simples et les plus aisés à connaître, pour monter peu, comme par degrés, jusques à la connaissance des plus composés ; et supposant même l’ordre entre ceux qui ne se précèdent point naturellement les uns les autres. »
Tout est donc objet. Il faut entendre par objet, élément de l’univers relatif au problème à traiter. Les objets appartiennent à des catégories appelées classes, qui divisent cet univers.
Illustration des concepts de classe et d’objet
Si notre problème concerne les animaux, nous pouvons créer une classe que nous appellerons Animal. Si nous devons considérer les chiens et les chats, nous créerons les trois classes dérivée de la classe Animal : les classes Chien et Animal. Peu importe que cette division ne soit pas pertinent dans l’univers réel, il suffit qu’elle le soit dans celui du problème à traiter.
Nous représenterons cette division de l’univers de la façon suivante :
Animal
Chien
Chat
Considérons à présent le modèle suivant :
Il est évident que le rapport entre milou et Chien n’est pas de la même nature que le rapport entre Chien et Animal. Chien est une sous-classe de Animal. Dans la terminologie de Java, on dit que Chien étend la classe Animal. En revanche milou n’est pas une classe. C’est un représentant de la classe Chien. Selon la terminologie Java, on dit que milou est une instance de la classe Chien.
Les classes
Définition
La classe regroupe la définition des membres de classe, c’est-à-dire :
– des méthodes, les opérations que l’on peut effectuer ;
– des champs, les variables que l’on peut traiter ;
– des constructeurs, qui permettent de créer des objets ;
– et encore d’autres choses plus particulières.
Plus précisément, une classe peut contenir des variables (primitives ou objets), des classes internes, des méthodes, des constructeurs, et des finaliseurs.
La déclaration d’une classe se fait de la façon suivante :
[Modificateurs] class NomClasse
{
corps de la classe
}
Le nom de la classe doit débuter par une majuscule.
Considérons l’exemple suivant :
Class Animal {
// champs
boolean vivant ;
int âge ;
// constructeurs
Animal() {
}
// méthodes
Animal
Chien
Chat
milou
rantanplan
félix
sylvestre
void viellit() {
++âge ;
}
void crie() {
}
}
Les classes final
Une classe peut être déclarée final, dans un but de sécurité ou d’optimisation. Une classe final ne peut être étendue pour créer des sous-classes. Par conséquent, ses méthodes ne peuvent pas être redéfinies et leur accès peut donc se faire sans recherche dynamique.
Une classe final ne peut pas être clonée.
Les classes internes
Une classe Java peut contenir, outre des primitives, des objets (du moins leurs références) et des définitions de méthodes, des définitions de classe. Nous allons maintenant nous intéresser de plus près à cette possibilité.
Plusieurs classes dans un même fichier
Il arrive fréquemment que certaines classes ne soient utilisées que par une seule autre classe. Considérons l’exemple suivant :
Class Animal {
// champs
boolean vivant ;
int âge ;
Coordonnées position ;
// constructeurs
Animal() {
position = new Coordonnées() ;
}
…
}
Class Coordonnées {
// champs
int x = 0;
int y = 0;
…
}
Toutes ces classes sont définies dans le même fichier, ce qui convient dans le cadre de la démonstration mais certainement pas pour la pratique courante de la programmation efficace. Chacune de ces classes pourrait être définie séparément dans un fichier et affectée à un package.
Lors de la compilation du précédent fichier Animal.java, le compilateur produit deux fichiers : Animal.class et Coordonnées.class.
Les classes imbriquées ou static
Il peut être avantageux dans certains cas placer la définition d’une classe à l’intérieur d’une autre, lorsque celle-ci concerne uniquement « la classe principale ». Voyons pour notre exemple :
Class Animal {
// champs
boolean vivant ;
int âge ;
Coordonnées position ;
// classes imbriquées
static Class Coordonnées {
// champs
int x = 0;
int y = 0;
…
}
// constructeurs
Animal() {
position = new Coordonnées() ;
}
…
}
La définition de la classe Coordonnées est maintenant imbriquée dans la classe Animal. Par ailleurs, la référence à la classe Coordonnées devient Animal.Coordonnées. De manière générale, les références à une classe imbriquée en Java se font en utilisant le point comme séparateur.
Lors de la compilation du fichier ci-dessus, Animal.java, le compilateur produit deux fichiers : Animal.class et Animal$Coordonnées.class pour la classe imbriquée.
Quant au chemin d’accès, notons que mesclasses.Animal désigne la classe Animal dans le package mesclasse, tandis que mesclasses.Animal.Coordonnées désigne la classe Coordonnées imbriquée dans la classe Animal, elle-même contenu dans le package mesclassses. Ainsi il est possible d’utiliser la directive import pour importer les classes imbriquées explicitement ou en bloc :
import mesclasses.Animal.Coordonnées ;
import mesclasses.Animal.* ;
Les classes imbriquées peuvent elles-mêmes contenir d’autres classes imbriquées, sans limitation de profondeur, du moins du point de vue de Java.
Un dernier point. La classe Coordonnées a été déclarée static, ce qui est obligatoire pour toute classe imbriquée. En revanche, les interfaces imbriquées sont automatiquement déclarées static et il n’est donc pas nécessaire de les déclarer explicitement comme telles.
Les classes membres
La particularité des classes imbriquées est qu’elles sont…
Les classes locales
Les classes anonymes
Les champs
Définition
L’état représente l’ensemble des variables qui caractérisent une classe ; on parle encore de champs ou de membres. Notons que Java initialise par défaut les variables membres.
Considérons l’exemple suivant :
Class Animal {
// champs
int âge ;
static int longévité = 100 ;
}
Variables d’instances & Variables static
Dans l’exemple ci-dessus, âge est une variable d’instance, tandis que longévité représente une variable static.
Dans cet exemple, nous avons considéré que la longévité était une caractéristique commune à tous les animaux, mettons 100 ans ! Il n’est donc pas nécessaire de dupliquer cette information dans chacune des instances de la classe. Nous avons donc choisi de déclarer longévité comme une variable static. Il en résulte que cette variable appartient à la classe et non à ses instances.
Chapitre 1 – Les bases du langage Java
Les données
Les primitives
Table des primitives
Portabilité
Initialisation des primitives
Les valeurs littérales
Casting sur les primitives
Les constantes
Les handles
final
Les chaînes de caractères
Les tableaux
Déclaration
Initialisation
Les vecteurs
Les collections
Les itérareurs
Les comparateurs
Les opérateurs
Description des principaux opérateurs
Opérateur d’affectation
Opérateurs arithmétiques à deux opérandes
Opérateurs à un opérande
Opérateurs relationnels
Méthode equals
Opérateurs logiques
Opérateurs d’arithmétique binaire
L’opérateur à trois opérandes
Opérateurs de casting
new
instanceof
L’opérateur + pour String
Priorité des opérateurs
Les structures de contrôle
Mots clés
static
final
synchronized
native
transient
volatile
abstract
Chapitre 2 – Concepts de base de la programmation orientée objet
Introduction
« Tout est objet ! »
Illustration des concepts de classe et d’objet
Les classes
Définition
Les classes final
Les classes internes
Plusieurs classes dans un même fichier
Les classes imbriquées ou static
Les classes membres
Les classes locales
Les classes anonymes
Les champs
Définition
Variables d’instances & Variables static
Les variables final
Les méthodes
Les retours
Les méthodes d’instances
Les méthodes static
Les méthodes native
Les méthodes final
Les constructeurs
Les constructeurs : création d’objets
Les constructeurs (constructor)
Exemple de constructeurs
Création d’objets (object)
Surcharger les constructeurs
Autorisation d’accès aux constructeurs
Initialisation des objets
Les initialiseurs de variables d’instances et statiques
Les initialiseurs d’instances
Les initialiseurs statiques
Les variables final non initialisées
Les finaliseurs
La destruction des objets (garbage collector)
Le concept de l’héritage
Chapitre 3 – Spécificités du langage
Les entrées / sorties
Package
Les packages
Les packages accessibles par défaut
L’instruction package
L’instruction import
Le clonage
Les threads
Programme principal : la méthode main
Les exceptions (exception) et les erreurs (error)
Deux types d’erreurs en Java
Principe
Attraper les exceptions
Annexes
La machine virtuelle Java (JVM)
Compilation
Diagramme de classe – UML
Représentation d’une classe
visibilité
Relations de dépendances
Généralisation – Relation d’héritage
Association – Relation de contenance
Généralisation particulière – Implémentation d’une interface
Autres relations de dépendance
Diagramme de séquence – UML
Télécharger le cours complet
