Concepts Orientés Objets en JAVA
Plan
• Notion de classe • Attributs et méthodes • Objets et Instanciation • Membres statiques et mots clés final, this et null • Les classes internes • Les packages
1- Notion de classe Définition : • En Java : tout appartient à une classe • Une classe comporte des attributs et des méthodes. • Une classe se compose de deux parties : un en-tête et un corps. Le corps
peut être divisé en 2 sections : la déclaration des données et des constantes et la définition des méthodes.
• Les méthodes et les données sont pourvues d'attributs de visibilité qui gère
leur accessibilité par les composants hors de la classe.
• On ne peut accéder à une classe qu’à partir d’une instance de cette classe
(un objet).
• Les accès sont spécifiés à travers des modificateurs placés par le
concepteur de la classe qui définissent la possibilité de restreindre l'accès à certaines données, ou plus généralement à certains éléments (méthodes, classes, ...). En effet, les classes sont prévues pour être réutilisées.
Déclaration d’une classe : Syntaxe générale : <modificateurs de visibilité > class nom_de_classe {
//déclaration des données membres de la classe //déclaration des méthodes de la classe et du corps des méthodes
}
Modificateurs de visibilité de classe Les modificateurs de classe sont : • public : La classe est accessible pour n’importe quelle autre classe.
Certaines classes (comme la classe principale contenant la fonction main) doivent obligatoirement être déclarées publiques.
• private : la classe n'est accessible qu'à partir du fichier où elle est définie. • final : La classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage
est interdite. Les classes déclarées final ne peuvent donc pas avoir de classes dérivées.
• abstract : La classe est définie en tant que classe abstraite. C'est-à-dire, contenant une ou des méthodes abstraites, qui n'ont pas de définition explicite. Une classe abstraite ne peut pas être instanciée : elle ne peut être instanciée qu’à travers des classes dérivées.
Remarques: • Par convention, les noms de classes commencent par une lettre
majuscule, si elle est composé de plusieurs mots, ces mots doivent être liés par « _ ».
• Les modificateurs : abstract et final ainsi que public et private sont
mutuellement exclusifs.
• L'ordre des méthodes dans une classe n'a pas d'importance. Si dans une classe, on rencontre d'abord la méthode A puis la méthode B, B peut être appelée sans problème dans A.
Membres d’une classe
1- Attributs Les données d'une classe sont contenues dans des variables nommées attributs. Ce sont des variables qui peuvent être des variables d'instances (d’objet), des variables de classes ou des constantes.
Syntaxe générale : <modificateurDeVisibilité>[static][final]<type><nomAttribut>[=<expression>] ;
Modificateurs de visibilité des attributs : • public : L’attribut est visible pour n’importe quelle autre classe. Il est
préférable de ne pas déclarer un attribut public car c’est contradictoire avec la philosophie objet qui protège les données des objets.
• private : l’attribut n'est accessible qu'à l’intérieur de la classe où il est
défini. C’est le niveau de protection le plus fort.
• protected : Seules les méthodes présentes dans le même package ou
dans les sous classes pourront accéder à cet attribut.
• Sans modificateur (friendly) : Si aucun modificateur n’est spécifié,
alors cet attribut est visibles pour toutes les classes se trouvant dans le même package. Le mot friendly n'est pas officiel : il est empruntée au langage C++.
Exemple public class MaClasse { public int valeur1 ; int valeur2 ; protected int valeur3 ; private int valeur4 ;
}
Exercice Définir dans la classe Rectangle les attributs longueur et largeur de type entier. Ces attributs ne doivent être accessibles qu’à l’intérieur de la classe elle-même.
Solution: class Rectangle {
private int longueur ; private int largeur ;
}
Variable d’instance (Attribut d’objet) • Une variable d’instance précise l'état d'un objet auquel elle se réfère. • Deux objets différents, de la même classe, peuvent avoir des valeurs
différentes dans leurs attributs respectifs.
Exemple Les attributs longueur et largeur déclarés dans la classe Rectangle sont des variables d’instances.
Variable de classe (Attribut de classe) • Une variable de classe est une variable représentant des propriétés dont la valeur est partagée par toutes les instances d’une même classe.
Publicité
• Elles ne sont définies qu'une seule fois quel que soit le nombre
d'objets instanciés de la classe. Leur déclaration est accompagnée du mot clé static.
• Chaque instance de la classe partage la même variable.
Exemple public class MaClasse {
static int compteur ;
}
Exercice: Ajouter à la classe Rectangle précédemment définit, un attribut permettant de compter le nombre de rectangle créés.
Solution: Public class Rectangle {
private int longueur ; private int largeur ; static int count ;
}
Les Constantes: Les constantes sont définies avec le mot clé final : leur valeur ne peut pas être modifiée une fois qu'elles sont initialisées.
Exemple public class MaClasse { final double pi=3.14 ;
}
2- Les Méthodes: • ce sont des fonctions qui implémentent les traitements de la classe. • Elles représentent l’équivalent des procédures ou fonctions. • Les méthodes agissent sur les attributs définis à l’intérieur de la classe.
Syntaxe générale <Modificateur> [static][final] type_de_retour nom_de_la_méthode(liste des paramètres>) {
//déclarations des variables locales // code de la méthode
} Exemple: public int add(int a, int b) {
return a + b;
}
Remarque: Si la méthode retourne un tableau alors les [] peuvent être précisés après le type de retour ou après la liste des paramètres. Exemple : int[] getValeurs() { ... } int getValeurs()[] { ... }
Modificateurs de visibilité des méthodes: • public : la méthode est accessible aux méthodes des autres classes • private : l'usage de la méthode est réservé aux autres méthodes de la
même classe
• protected : la méthode ne peut être invoquée que par des méthodes de la
classe ou de ses sous classes.
• Sans modificateur : la méthode peut être appelée par toutes autres
méthodes des classes du package auquel appartient la classe.
• final : la méthode ne peut être modifiée (redéfinition lors de l'héritage
interdite)
• static : la méthode appartient simultanément à tous les objets de la classe
(comme une constante déclarée à l'intérieur de la classe). Il est inutile d'instancier la classe pour appeler la méthode mais la méthode ne peut pas manipuler de variable d'instance. Elle ne peut utiliser que des variables de classes.
Exemple class MaClasse{
public int valeur ; public void afficheValeur() {
System.out.println(" nombre entier = " + valeur);
} public boolean estPositif (){
if (valeur>0) return true ; else return false ;
}
}
Exercice Complétez la classe rectangle par les méthodes suivantes : - La méthode Affiche() permettant d’afficher les caractéristique d’un
rectangle.
- La méthode calcul_surface() retournant la surface d’un rectangle
Solution: class Rectangle {
private int longueur ; int largeur ; public void affiche( ) {
System.out.println( " la longueur est : "+longueur+ "la largeur est" : +largeur) ;
} public int calcul_surface ( ) {
return (longueur*largeur) ;
Publicité
}
}
La Méthode main() • La méthode main de la classe principale, est exécutée la première lors
de l'exécution d'un programme Java.
• Elle doit avoir obligatoirement la signature suivante : public static void main(String args[]) Ou public static void main(String[] args)
• Le nom de l'argument args peut être quelconque. C'est un tableau de
chaînes de caractères représentant les arguments de la ligne de commande.
Envoi de messages Lorsqu'on demande à un objet d'exécuter l'une de ses méthodes, un message est envoyé. Syntaxe :
nom_objet.nom_méthode(parametre, … ) ;
Remarque: Si la méthode appelée ne contient aucun paramètre, il faut laisser les parenthèses vides.
Un Constructeur • est une méthode particulière permettant lors de la création des
objets, d’initialiser les attributs.
• Elle est systématiquement invoquée lors de la création d'un objet. • Le nom d’un constructeur, doit obligatoirement correspondre à celui
de la classe.
• Le constructeur est la seule méthode qui n’a pas de type de retour, pas même void, donc il ne peut pas y avoir d'instruction return dans un constructeur.
Il existe plusieurs types de constructeurs : • Le constructeur simple (par défaut) : ce type de constructeur ne
nécessite pas de définition explicite: son existence découle automatiquement de la définition de la classe. Il attribue des valeurs par défaut.
Type de l’attribut
Valeur par défaut
boolean
char
int, byte, short, int long
float, double
objet
false
Caractère de code null
0
0,0
null
Exemple : public class MaClasse { private int nombre ; public MaClasse() {} // constructeur simple
}
Le constructeur avec initialisation fixe : il permet d’attribuer des valeurs prédéfinies
Exemple : public class MaClasse {
private int nombre ; public MaClasse() { nombre = 5;} // constructeur avec initialisation fixe
}
Le constructeur avec initialisation des variables : pour ne pas attribuer les mêmes valeurs aux attributs des objets lors de leur création, on peut les passer en paramètres au constructeur.
Exemple : public class MaClasse {
private int nombre ; // constructeur avec initialisation des variables public MaClasse (int valeur) {
nombre = valeur;
}
}
Remarque : On peut définir plusieurs constructeurs dans une même classe
Exemple : public class MaClasse { private int nombre ; public MaClasse() { nombre = 5;} public MaClasse(int valeur) { nombre = valeur;
}
}
Publicité
Exercice : Définir 3 constructeurs pour la classe Rectangle : - Un constructeur sans paramètres permettant d’initialiser la longueur
à 10 et la largeur à 5.
- Un constructeur à deux paramètres qui permettent d’initialiser
successivement la longueur et la largeur du rectangle.
- Un constructeur à un paramètre, qui fait en sorte que la largeur reçoive la valeur du paramètre passé au constructeur et que la longueur fasse deux fois la valeur de celui-ci.
Solution: class Rectangle{
private int longueur ; private int largeur ; Rectangle () {longueur =10 ; largeur = 5 ;} // constructeur sans paramètres Rectangle (int x, int y) { //constructeur avec 2 paramètres
longueur =x ; largeur = y ;}
Rectangle (int x) { // constructeur avec 1 paramètre
longueur =2*x ; largeur = x ;}
public int calcul_surface ( ) {return (longueur*largeur) ;}
}
L’instanciation
Syntaxe générale de création d’objet
Nom_Classe nom_Objet ; nom_Objet=new nomClasse(<liste d’arguments>) ;
Ou en une seule déclaration
Nom_Classe nom_Objet = new nomClasse(<liste d’arguments>) ;
Exemple
MaClasse m; m = new MaClasse(); ou en une seule déclaration :
MaClasse m = new MaClasse();
Exercice Créez deux rectangles, ayant comme longueur 10 et comme largeur 5, l’un en vous basant sur le constructeur sans paramètres précédemment définit et l’autre en se basant sur le constructeur à 2 paramètres.
Solution: Rectangle r 1; Rectangle r2 ; r1 = new Rectangle (10,5); r2 = new Rectangle (); Ou bien, effectuer les deux étapes en même temps : Rectangle r1= new Rectangle (10, 5); Rectangle r2= new Rectangle ();
Manipulation des objets
Manipuler signifie accéder aux données d'un objet ou appeler une méthode de cet objet (lui envoyer un message). Dans les deux cas, on utilise en Java l'opérateur "." séparant le nom de l'objet du nom du membre auquel on veut accéder. 1. L’accès aux attributs - Pour accéder aux attributs de l’intérieur de la classe, il suffit
d’indiquer le nom de l’attribut que l’on veut y accéder.
- Pour accéder de l’extérieur de la classe, on utilise la syntaxe suivante :
<nom_Objet>.<nom_attribut>
2. L’accès aux méthodes - A l’intérieur d’une classe, les méthodes de cette classe seront
appelées en indiquant le nom et la liste des paramètres effectifs de la méthode.
- A l’extérieur de la classe, l’invocation d’une méthode se fait comme
suit : <nom_Objet>.<nom_méthode> ( [<liste des arguments effectifs>] ) ;
Exemple Dans la méthode « main » de la classe Test_Rect, on peut appeler les méthodes ainsi : Rectangle r = new Rectangle (10,5) ; r.affiche() ; // Appel de la méthode affiche int s = r.calcul_surface() ; //Appel de la méthode calcul_surface r.setlong(20) ; //Appel de la méthode setlong pour modifier la longueur
Le mot clé « this »
Cette variable sert à référencer, dans une méthode, l'instance de l'objet en cours d'utilisation. this est un objet qui est égale à l'instance de l'objet dans lequel il est utilisé. La référence « this » peut être utile : - Lorsqu’une variable locale (ou un paramètre) cache, en portant le
même nom, un attribut de la classe.
- Pour appeler un constructeur depuis un autre constructeur.
Exemple public maclasse{
private int nombre1; private int nombre2; public maclasse(int nombre1) {
this.nombre1 = nombre1; // variable de classe = variable en paramètre du
constructeur
} public maclasse(int nombre1, int nombre2) { this(nombre1) this.nombre2 = nombre2; }
}