Cours Java : Classes abstraites et interfaces
...
La programmation orientée objet permet de concevoir une application sous la forme d'un ensemble d'objets reliés entre eux par des relations : Lorsque l'on programme avec cette méthode, on se pose plus souvent la question « qu'est-ce que je manipule ? », que « qu'est-ce que je fait ? ».
Le programme orienté objet est pensé en terme d'objets abstraits inter opérant entre eux alors que la programmation traditionnelle pense une application en termes de fonctionnalités.
L'une des caractéristiques de cette méthode permet de concevoir de nouveaux objets à partir d'objets existants. Ainsi, il est possible de spécialiser un objet pour des besoins spécifiques. On peut donc réutiliser les objets dans plusieurs applications. La réutilisation du code fut un argument déterminant pour venter les avantages des langages à objets.
Les interfaces graphiques se prêtent bien à une conception orientée objets car les objets ne sont pas seulement abstraits mais possèdent une représentation graphique sous la forme d'une fenêtre ou d'un élément graphique.
Dans ce cours de programmation orientée objet, nous allons découvrir les concepts de l’orienté objet implémentés par java à savoir :
- Objet et classe
- Héritage
- Encapsulation (Accessibilité)
- Polymorphisme
L’objectif de ce chapitre est de maîtriser les concepts relatifs aux objets et aux classes.
Objet, Classes
1-Objet
Un objet est une structure informatique caractérisée par un état et un ensemble d'opérations exécutables par cet objet qui caractérise son comportement.
Objet = état + comportement (opérations)
Exemples:
Une Fenêtre :
Un Fichier
On regroupe un ensemble de caractéristiques communes aux objets sous la forme de structures formelles, appelées classes:
Exemple de représentation graphique d’un objet (Notation UML) :
2- Classe :
Une classe est un modèle de la structure statique (les champs ou attributs) et du comportement dynamique (les opérations ou méthodes) des objets associés à cette classe, que l'on appelle ses instances.
La classe décrit le domaine de définition d’objets. Chaque objet appartient à une classe. Les généralités sont contenues dans la classe alors que les particularités dans les objets. Les objets informatiques sont construits à partir de la classe par un processus appelé instanciation. De ce fait tout objet est une instance de classe.
Une classe est définie par les attributs et les opérations (méthodes).
Exemple : considérons la classe Employé caractérisée par les attributs code, nom et nbEmployés (nombre d’employés)
Les attributs code et nom sont des caractéristiques de chaque objet Employé contrairement au champ nbEmployés qui est une caractéristique commune à tous les objets. On dira que nbEmployés est attribut statique.
Chaque objet, instance d’une classe, donne des valeurs particulières à tous les attributs définis dans sa classe sauf les attributs statiques ce qui détermine son état.
Exemples :
Définition :
Un attribut statique d’une classe est un attribut qui appartient à la classe et qui est partagé par tous les objets de cette classe. Un attribut statique est considéré comme étant une variable globale à tous les objets. Les attributs statiques ne sont pas instanciés dans les objets.
Dans l’exemple précédent, nous pourrons définir les méthodes afficheCode() et afficheNom() qui affichent respectivement le code et le nom d’un employé.
Exemple d’implémentation la classe Employé avec java :
class Employe{
// Les attributs
int code ;
String nom ;
static int nbEmployes = 0 ;
//Constructeur
Employe(){
++nbEmployes ;
code=nbEmployes ;
}
// Les méthodes
void afficheCode(){
System.out.println("Le code est : " + code) ;
}
void afficheNom(){
System.out.println("Le nom est : " + nom) ;
}
}
3- Création d’un objet à partir d’une classe :
L’opération de création d’un objet à partir d’une classe s’appelle instanciation. Pour créer un objet en Java, il faut utiliser le mot clé new, suivi du nom du constructeur de la classe, avec les parenthèses et les arguments éventuels. Par exemple, pour créer une instance de la classe Employé (ou, en d'autres termes un objet de type Employé), nous utiliserons la syntaxe suivante:
new Employe();
L’objet ainsi créé n’est identifié par un nom. C’est un objet qui ne peut pas être exploité une fois qu’il est créé. C’est donc un objet perdu en mémoire.
Comment retenir les objets : les handles :
Nous avons donc vu que nous pouvions créer un objet facilement à l'aide de l'opérateur new et du constructeur de l'objet. Nous pouvons utiliser immédiatement l'objet ainsi créé en utilisant par exemple la syntaxe suivante :
(new Employe()).afficheCode();
cette instruction permet de créer un objet de la classe Employe et en même moment appelle la méthode afficheCode() pour afficher le code de cet employé.
Si nous voulons pouvoir l'utiliser plus tard, il faut, avant de confier cet objet à Java, s'assurer que nous pourrons le récupérer. Pour cela, il suffit de pouvoir l'identifier.
En Java, tous les objets sont logés à la même enseigne : ils sont identifiés à l'aide d'un handle. Le mot handle signifie poignée, en français. Les objets peuvent avoir plusieurs handles. Autant que vous le souhaitez. En revanche, un handle ne peut correspondre qu'à un seul objet simultanément.
Création des handles
Rien n'est plus simple que de créer un handle d'objet. Il suffit pour cela de le déclarer en indiquant vers quelle classe d'objets il est susceptible de pointer. Par exemple, pour créer le handle alpha pouvant pointer vers une instance d'Employe, nous écrirons :
Employe alpha;
Vers quoi pointe ce handle ? Pour l'instant, vers rien. En effet, nous avons déclaré le handle, ce qui suffit à le faire exister. En revanche, nous ne l'avons pas initialisé, c'est-à-dire que nous ne lui avons pas attribué sa valeur initiale. Pour l'instant, il ne pointe donc vers rien.
Modifier l'affectation d'un handle
Nous avons vu qu'un objet pouvait être créé à l'aide de son constructeur et de l'opérateur new. Nous ne pouvons affecter un premier handle à un objet nouvellement créé qu'au moment de sa création. En effet, si nous écrivons les lignes :
Employe alpha;
new Employe();
Il n'y a ensuite aucun moyen d'établir un lien entre le handle créé à la première ligne et l'objet créé à la seconde. Il faut donc effectuer l'affectation en même temps que la création, de la façon suivante :
Employe alpha;
alpha = new Employe();
Ce qui ne signifie en aucun cas que le handle alpha soit égal à l'objet créé, mais simplement qu'il pointe vers cet objet. Il pourra donc servir à manipuler cet objet. Java nous permet même de condenser ces deux lignes en une seule sous la forme :
Employe alpha = new Employe();
Utilisation des membres de l’objet créé :
Pour accéder aux membres d’un objet créé, on utilise son handle suivi d’un point, puis du nom de l’attribut ou de la méthode.
Exemple :
appha.nom= "jamil " ;
alpha.afficheNom() ;
System.out.println(alpha.code) ;
System.out.println(alpha.nbEmployes) ;
System.out.println(Employe.nbEmployes) ;
Les membre statiques sont accessibles en utilisant soit le handle d’un objet quelconque de la classe, soit directement le nom de la classe.
La destruction des objets : le garbage collector
Avec certains langages, le programmeur doit s'occuper lui-même de libérer la mémoire en supprimant les objets devenus inutiles. C'est une des principales sources de mauvais fonctionnement des programmes.
Avec Java, le problème est résolu de façon très simple : un programme, appelé garbage collector, ce qui signifie littéralement "ramasseur d'ordures", est exécuté automatiquement dès que la mémoire disponible devient inférieure à un certain seuil. De cette façon, vous pouvez être assuré qu'aucun objet inutilisé n'encombrera la mémoire au point d'être une cause de problèmes.
Exemple Test
1- Ecrire le code java de la classe Employe
2- Enregistrer le fichier sous le nom Employe.java
3- Compiler le fichier Employe.java
class Employe{
// Les attributs
int code ;
String nom ;
static int nbEmployes = 0 ;
//Constructeur
Employe(){
++nbEmployes ;
code=nbEmployes ;
}
// Les méthodes
void afficheCode(){
System.out.println("Le code est : " + code) ;
}
void afficheNom(){
System.out.println("Le nom est : " + nom) ;
}
}
1- Ecrire le code java de la classe TestEmploye
2- Enregistrer le fichier sous le nom TestEmploye.java
3- Compiler ce fichier ( javac TestEmploye.java)
4- Exécuter ce programme (java TestEmploye)
class TestEmploye{
public static void main(String[] args){
new Employe(); // Crée un objet anonyme
Employe e2 ; // Crée un handle,pour le moment, in pointe vers null
e2=new Employe(); // Crée un objet Employe puis affecte son adresse au handle e2
Employe e3=new Employe(); // Crée le handle e3, crée un objet et affecter l'objet au handle e3
e2.nom="Jamil"; // définit la valeur l'attribut nom de l'objet e2
e2.afficheCode(); // On fait appel à la méthode afficheCode() de l'objet e2
e2.afficheNom(); // On fait appel à la méthode afficheNom() de l'objet e2
e3.afficheCode(); // On fait appel à la méthode afficheCode() de l'objet e3
System.out.println("Nombre d'employés en utilisant l'objet e2="+e2.nbEmployes);
System.out.println("Nombre d'employés en utilisant l'objet e3="+e3.nbEmployes);
System.out.println("Nombre d'employés en utilisant la classe Employe="+e2.nbEmployes);
}
}
Représentation graphique simplifiée des objets de l’application :
![All bootstrap classes with description [Eng]](/images/remos_downloads/id-9963.9963.pdf_thumb-min.webp)
