Dans cette série, vous travaillerez avec les bases de la programmation orientée objets. Vos programmes seront modularisés sous forme de méthodes auxiliaires ainsi que sous forme de classes comprenant des variables d'instance et des méthodes d'instance.
Le but de cet exercice est d'illustrer les notions d'objet et de classe au moyen d'un exemple simple.
Il s'agit ici de définir une classe Rectangle représentant une abstraction (informatique) de ce qu'est un rectangle : une largeur, une longueur et sa surface.
Commencez par ouvrir un fichier ManipRectangle.java et définissez-y la classe :
class Rectangle {
} |
Bien ! Prévoyons tout de suite d'utiliser notre toute première classe. Pour cela il faut déclarer une variable de type Rectangle. Cela se fait comme pour n'importe quelle autre variable utilisée jusque maintenant, la classe Rectangle étant simplement un nouveau type. La méthode main est mise ici dans la classe ManipRectangle qui constitue le programme principal :
class ManipRectangle {
public static void main(String[] args) {
Rectangle rect;
}
} |
Bon, jusque là pas grand chose de bien intéressant. Implémentons maintenant l'abstraction "rectangle" en commençant par les deux attributs largeur et longueur.
Cela se fait comme suit :
class Rectangle {
double largeur;
double longueur;
} |
Dotons notre classe d'une méthode constructeur construisant nos objets Rectangle et initialisant leurs attributs. Notez que le constructeur a le même nom que la classe, et que dans le programme principal la déclaration-initialisation d'un rectangle se fait en utilisant le constructeur.
class Rectangle {
double largeur;
double longueur;
//Le constructeur
public Rectangle(double uneLargeur, double uneLongueur) {
// largeur et longueur sont les attributs
// de la classe
largeur = uneLargeur;
longueur = uneLongueur;
}
// largeur et longueur sont les attributs
// de la classe
} |
Pour le calcul de la surface, nous implémentons une méthode, c'est-à-dire un traitement propre à la classe.
Les méthodes se déclarent comme les méthodes auxiliaires que vous connaissez jusqu'ici, sauf qu'on n'utilise pas le mot clé static.
class Rectangle {
double largeur;
double longueur;
//Le constructeur
public Rectangle(double uneLargeur, double uneLongueur) {
largeur = uneLargeur;
longueur = uneLongueur;
}
// largeur et longueur sont les attributs
// de la classe
// La méthode pour le calcul de la surface
public double surface () {
return largeur * longueur;
}
} |
On peut maintenant déjà tester notre programme :
class Rectangle {
double largeur;
double longueur;
public Rectangle(double uneLargeur, double uneLongueur) {
largeur = uneLargeur;
longueur = uneLongueur;
}
public double surface() {
return largeur * longueur;
}
}
class ManipRectangle {
public static void main(String[] args) {
Rectangle rect = new Rectangle(1.5,12.8);
System.out.println("Surface : " + rect.surface());
}
} |
Compilez et exécutez ce programme.
Supposons maintenant que nous souhaitions modifier les valeurs des attributs dans le programme principal:
...
class ManipRectangle {
public static void main(String[] args) {
Rectangle rect = new Rectangle(1.5, 12.8);
System.out.println("Surface : " + rect.surface());
rect.largeur = 3.2;
rect.longueur = 6.9;
}
} |
Essayons maintenant d'affiner notre "style objet" en rendant privés les attributs et ne laissant publiques que les méthodes :
class Rectangle {
private double largeur;
private double longueur;
public Rectangle(double uneLargeur, double uneLongueur){
largeur = uneLargeur;
longueur = uneLongueur;
}
public double surface() {
return largeur * longueur;
}
}
class ManipRectangle {
public static void main(String[] args) {
Rectangle rect = new Rectangle(1.5,12.8);
System.out.println("Surface : " + rect.surface());
rect.largeur = 3.2;
rect.longueur = 6.9;
}
} |
Essayez de compiler ce programme. Que se passe-t-il?
Le message est assez clair : tout les attributs sont privés. Cela veut dire qu'on ne peut pas les utiliser hors de l'objet (ils ne font pas partie de l'interface de l'objet).
En particulier, on n'a pas le droit de faire rect.largeur ! Ce n'est pas défini.
Pour rendre accessible depuis l'extérieur un attribut, il faut mettre en place les méthodes "get" et "set" correspondantes (qui devront évidement être publiques !).
Cela se fait simplement, comme pour la méthode du calcul de surface. Dans la méthode main l'accès aux attributs se fera désormais en passant par ces méthodes
class Rectangle {
private double largeur;
private double longueur;
public Rectangle(double uneLargeur, double uneLongueur){
largeur = uneLargeur;
longueur = uneLongueur;
}
public double surface() {
return largeur * longueur;
}
public double getLongueur() {
return longueur;
}
public double getLargeur() {
return largeur;
}
public void setLargeur(double l) {
if (l < 0) {
l = -l;
}
largeur = l;
}
public void setLongueur(double l) {
if (l < 0) {
l = -l;
}
longueur = l;
}
}
class ManipRectangle {
public static void main(String[] args) {
Rectangle rect = new Rectangle(1.5,12.8);
System.out.println("Surface : " + rect.surface());
rect.setLargeur(3.2);
rect.setLongueur(6.9);
System.out.println("Surface : " + rect.surface());
}
} |
Recompilez. Ça fonctionne cette fois-ci et vous avez codé votre premier programme objet !
Cette semaine vous devez visionner les vidéos de la semaine 1 et de la semaine 2 du MOOC. Pour bien assimiler ce contenu, il est recommandé de faire les quiz des mêmes semaines: Quiz «Classes et objets» et Quiz «Constructeurs».
Le fichier Surfaces.java contient les déclarations de trois classes: Surfaces, Terrain et Rectangle.
Attention: si vous avez fait le premier exercice, un classe Rectangle a déjà été créée dans le projet de cette série. Pour éviter les incompatibilités, renommez là.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
/* Dans ce programme, les 2 réctangles sont encapsulés dans un objet
* de type Terrain qui s'occupe de calculer et d'afficher la surface
* totale. Le mot-clé private a été utilisé le plus possible dans
* toutes les classes. La classe Rectangle met aussi à disposition des
* méthodes get et set pour ses variables (il s'agit d'un service que
* le programmeur de la classe peut offrir à ses utilisateurs s'il le
* juge utile).
*/
class Surfaces {
public static void main(String[] args) {
// Construction d'un terrain:
Terrain t = new Terrain(1.0, 2.0, 3.0, 4.0);
t.afficherSurfaceTotale();
}
}
class Terrain {
private Rectangle r1;
private Rectangle r2;
public Terrain(double l1, double h1, double l2, double h2) {
// Construction des 2 rectangles définissant le terrain:
r1 = new Rectangle(l1, h1);
r2 = new Rectangle(l2, h2);
}
private double calculerSurfaceTotale() {
return r1.calculerSurface() + r2.calculerSurface();
}
public void afficherSurfaceTotale() {
double surfaceTotale = calculerSurfaceTotale();
System.out.println("La surface totale est " + surfaceTotale);
}
}
class Rectangle {
private double largeur;
private double hauteur;
public Rectangle(double largeur, double hauteur) {
this.largeur = largeur;
this.hauteur = hauteur;
}
public void setLargeur(double largeur) {
this.largeur = largeur;
}
public double getLargeur() {
return largeur;
}
public void setHauteur(double hauteur) {
this.hauteur = hauteur;
}
public double getHauteur() {
return hauteur;
}
public double calculerSurface() {
return (largeur * hauteur);
}
} |
La vue "Outline" de IntelliJ synthétise la structure du fichier courant en terme de classes, attributs et méthodes. Ce tutorial vous montre comment activer cette vue.
En fait, il suffit de sélectionner "View->Tool Window->Structure" dans le menu principal :
La vue "Outline" va alors apparaître. Vous pouvez changer la position de cette vue au moyen de la souris. Voici un exemple de vue "Outline"pour le fichier Surfaces.java de l'exercice 2 de la série 6 :
Les icônes donnent le type de l'élément concerné ; par exemple :
Désigne une classe Désigne une méthode Désigne un attribut Désigne une méthode/attribut publique Désigne une méthode/attribut privé
