Ce cours introduit la programmation orientée objet (encapsulation, abstration, héritage, polymorphisme) en l'illustrant en langage Java. Il présuppose connues les bases de la programmation (variables, types, boucles, fonctions, ...). Il est conçu comme la suite du cours « Initiation à la programmation (en Java) ». Comme son prédécesseur, ce cours s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Classes, objets, attributs et méthodes en Java
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Introduction à la programmation orientée objet (en Java)
176 notes
École Polytechnique Fédérale de Lausanne
176 notes
À partir de la leçon
Introduction à la Programmation Orientée Objet
Cette semaine vous accueille dans le cours et vous présente les premiers concepts de base de la programmation dite « orientée objet ».
Rencontrer les enseignants
Jamila SamDr
School of Computer and Communication Sciences
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Dans la séquence vidéo précédente,
nous avions vu les concepts généraux de la programmation orientée objet.
Dans cette séquence vidéo-ci,
nous allons voir comment écrire tout ceci concrètement en Java.
Nous avions donc vu que la programmation orientée objet définit la notion de
classe, qui est le résultat des processus d'abstraction et d'encapsulation,
comme par exemple la définition d'une classe rectangle qui aurait des
attributs largeur et hauteur, et qui aurait une méthode surface.
La classe au sens des langages de programmation définit un nouveau
type qui nous permet de créer différentes variables,
comme par exemple 3 variables, rect1, rect2, rect3,
qui sont donc en langage orienté objet des instances ou des objets.
Et comment tout ceci s'écrit-il concrètement en Java?
Pour déclarer une nouvelle classe,
on va simplement utiliser le mot réservé class, donc, par exemple, ici,
class Rectangle pour déclarer une classe que l'on a décidé d'appeler rectangle,
suivi ensuite donc de la définition qui sera détaillée par la suite.
Cette écriture class Rectangle définit un nouveau type,
que l'on peut utiliser maintenant comme n'importe quel autre type,
pour déclarer par exemple des variables.
Donc, on utilisera le nom du type, c'est-à-dire le nom de la classe,
suivi du nom de la variable, c'est-à-dire du nom de l'instance.
Donc, par exemple, pour déclarer une instance que l'on décide de nommer rect1
de la classe Rectangle, on écrira simplement Rectangle rect1; En
terminologie orientée objet, une variable correspond à une instance.
En Java concrètement nomInstance, c'est-à-dire rect1 dans cet exemple
précis, est en fait une référence sur un objet concret en mémoire.
Tout ceci sera expliqué plus en détail plus tard dans le cours.
Mais où concrètement écrire toutes ces lignes.
Vous avez pour cela 2 solutions, soit vous pouvez déclarer toutes vos classes dans un
même fichier, soit vous pouvez mettre une classe par fichier.
Regardons le premier cas où l'on déclare toutes les classes dans le même fichier.
Donc, par exemple supposons, et pour l'instant peu importe les détails
mais retenons les idées, que l'on veuille avoir une classe Dessin et
qui utilise par exemple donc une classe Rectangle, tout ceci, on va donc les
déclarer dans un seul et même fichier, qu'on a décidé d'appeler donc Dessin.java,
donc, ici, l'intégralité du fichier Dessin.java et donc on peut tout à fait
comme ça déclarer ici une classe Rectangle, une autre classe Dessin.
Concrètement pour le compiler,
on utilisera donc simplement la compilation javac Dessin.java,
que vous tapiez directement cette commande sur le terminal ou que ce soit votre
environnement de développement Eclipse ou autre qui le fasse pour vous.
Et cette compilation va par contre produire 2 fichiers,
un fichier Dessin.class et un fichier Rectangle.class.
Et ensuite pour exécuter tout ceci, la méthode main étant dans la classe Dessin,
on écrirait donc simplement java Dessin sur le terminal ou alors
on lancerait directement l'exécution de ce Dessin.class depuis Eclipse, par exemple.
Voilà donc la première solution pour déclarer les classes.
Une autre solution consiste à déclarer une classe par fichier,
donc chaque fois que vous avez une classe, vous avez un fichier à part.
Donc, vous déclareriez la classe Rectangle dans, par exemple,
le fichier Rectangle.java, la classe Dessin dans le fichier Dessin.java,
et dans ce cas, si vous compilez depuis le terminal,
il faudrait compiler séparément chacun des fichiers.
Bien sûr dans un environnement de développement intégré, ces 2 fichiers
seraient intégrés dans le même projet et on les compilerait les 2 séparément,
mais en appelant une seule fois,
donc, la commande Build, et Eclipse qui se chargerait de compiler ces 2 fichiers,
et qui donc produirait comme dans le cas précédent 2 fichiers .class.
Si on l'exécutait depuis le terminal, on taperait donc ici java Dessin,
puisque c'est la classe Dessin qui a la fonction main, c'est également ce que
fera pour vous Eclipse si vous lancez l'exécution depuis là.
Et si par hasard, vous aviez envie de faire java sur Rectangle.class,
Rectangle qui ne contient pas de main, va vous donner donc à ce moment-là une
exception, qui vous dit qu'il n'existe pas de main dans NoSuchMethod,
il n'existe pas de méthode main dans la classe Rectangle.
Voyons maintenant comment remplir cette partie,
c'est-à-dire comment mettre des attributs et des méthodes à notre classe.
Commençons par les attributs,
les attributs de la classe Rectangle sont donc sa largeur et sa hauteur.
Pour ça, pour déclarer des attributs, il suffit simplement de déclarer
les différents attributs en mettant le type et le nom de l'attribut.
Donc, on déclare ici pour chacun des attributs, son type, son nom d'attribut,
suivi d'un point-virgule.
Donc, pour notre exemple de classe Rectangle, ceci donnerait simplement,
double hauteur, double largeur, c'est aussi simple que ça.
De même, pour l'utilisation des attributs d'une instance, pour cela,
on aura donc le nom de l'instance,
suivi d'un point, suivi donc du nom de l'attribut que l'on veut désigner.
Donc, par exemple, pour désigner la hauteur du rectangle rect1,
on écrirait rect1.hauteur.
Illustrons tout ceci sur un exemple concret,
donné ici dans un seul et même fichier,
qui contiendrait donc une première classe Exemple, pour avoir la méthode main,
et puis qui utilise une classe Rectangle, donc dans laquelle on déclare une hauteur,
2 attributs, une hauteur de type double et puis une largeur de type double.
Et donc, la classe Exemple ici va créer une instance,
utiliser une instance de la classe Rectangle.
Et pour ceci donc, il faut utiliser la syntaxe suivante.
La déclaration-initialisation d'une instance se fait en utilisant le nom de
classe, suivi donc du nom d'instance, et puis égale new avec le nom de classe,
suivi entre deux parenthèses, comme ceci.
Donc, par exemple, on l'a vu dans l'exemple précédent, pour créer une
instance rect de la classe Rectangle, on écrirait : égal new Rectangle.
Et ce qui va donc créer et initialiser
tous les attributs avec les valeurs suivantes.
Si on a des attributs de type int, ça sera la valeur 0 int,
si on a des attributs de type double, ça sera la valeur 0 double,
pour les booleans, ça sera false et pour les objets,
ce sera donc la valeur spéciale null, sur laquelle nous reviendrons par la suite.
Et donc, dans notre exemple précédent, ici, à ce stade,
rect1 a une largeur et une hauteur nulles, avant donc qu'on les modifie.
Passons maintenant à la déclaration des méthodes.
Les méthodes sont simplement des fonctions que l'on va mettre au sein de la classe.
Donc, dans le cas de notre classe Rectangle,
on va s'intéresser ici à lui ajouter la méthode surface.
Donc une méthode se déclare simplement comme d'habitude,
avec le type de retour, le nom de la méthode,
puis ensuite entre parenthèses rondes la liste des éventuels paramètres.
Tout ceci donc qui est l'entête de la méthode, étant suivi
par la définition de la méthode, donc le corps de cette méthode, entre accolades.
La seule différence simplement,
c'est que les méthodes sont mises dans la classe elle-même.
Dans le cas de notre exemple de la classe Rectangle, la méthode surface s'ajouterait
donc dans la classe Rectangle ici avec donc sa valeur de retour double,
une surface retourne en double, son nom et puis si elle n'a pas besoin de prendre
de paramètres et elle retournerait donc la hauteur fois la largeur.
La question qu'on pourrait se poser, c'est mais où sont donc passés les paramètres.
En effet, si l'on avait à écrire une méthode comme nous le faisions auparavant,
en dehors de toute classe, alors on aurait eu besoin de passer
la hauteur et de passer la largeur, comme argument à la fonction,
de sorte que hauteur et largeur soient connues pour effectuer ce calcul.
Comment se fait-il qu'ici dans la méthode de la classe Rectangle,
on n'ait rien eu besoin de passer.
Parce que tout simplement cette hauteur et cette largeur sont des attributs de la
classe, la méthode surface faisant partie de la classe Rectangle,
elle a l'accès aux attributs hauteur et largeur de la classe Rectangle.
C'est ce que l'on appelle techniquement une portée de classe,
c'est-à-dire que tous les attributs d'une classe sont connus de l'entièreté de
cette classe et en particulier de chacune de ces méthodes.
Donc, par exemple,
toutes les méthodes de la classe Rectangle ont accès à la hauteur et à la largeur.
Il n'est donc pas nécessaire de passer les attributs comme arguments aux méthodes.
Donc pour résumer, une méthode c'est simplement une fonction
qui est propre à une classe, on va donc la mettre dans les classes, mais qui en plus,
de ce fait, a accès aux différents attributs de la classe.
Et donc, il est très important et c'est une erreur de débutant,
des premiers écritures de méthode,
il est très important de ne pas passer les attributs à une méthode de classe.
Donc pour revenir encore une fois sur l'exemple, l'exemple est tout à fait
correct ici, on a bien une méthode surface qui ne prend pas du tout ici
de paramètres et qui peut accéder à la hauteur et à la largeur de Rectangle,
qui ont été déclarées comme précédemment dans la classe.
Ceci dit ce n'est pas parce que l'on n'a pas besoin de passer les attributs d'une
classe comme arguments à ces méthodes, que les méthodes n'ont jamais de paramètres.
Bien sûr si une méthode a besoin de recevoir des paramètres,
de l'extérieur de la classe, pour pouvoir fonctionner,
alors il faudra bien sûr déclarer les paramètres à la méthode.
Donc par exemple, ici, supposons qu'on imagine qu'on ait une classe de figure
colorée, et dans cette classe, on aurait différents attributs et en particulier
aussi une méthode qui permet de colorier la figure, laquelle méthode
pourrait donc recevoir typiquement une couleur et elle modifierait donc
les instances de la classe FigureColoree pour les colorier dans cette couleur,
couleur étant lui-même un autre type qu'on aurait défini par ailleurs.
On pourrait donc par exemple déclarer une instance une_figure
de la classe FigureColoree, une instance rouge de la classe Couleur,
et puis un tout petit peu plus tard en anticipant sur une syntaxe qui va vous
être présentée, colorier la figure avec la couleur rouge.
Ce qui m'intéresse ici c'est de vous montrer que la couleur rouge,
donc elle vient de l'extérieur de la classe FigureColoree,
elle ne fait pas partie de la classe FigureColoree, et donc c'est pour ceci
que l'on a besoin de la passer, ce n'est pas un attribut de FigureColoree,
on a besoin de la passer comme paramètres à la méthode colorie.
Voilà, vous savez donc maintenant déclarer et définir les méthodes d'une classe.
Mais comment les utiliser, c'est-à-dire comment y faire appel.
Nous allons pour cela utiliser une syntaxe très similaire à celle des attributs
et aussi similaire à ce que vous avez déjà fait dans d'autres cadres, par exemple
lorsque vous appeliez la méthode size d'un tableau, vous écriviez tableau.size,
c'est bien en fait un appel de la méthode size, ici, d'un tableau dynamique.
Donc, le schéma général, c'est le nom de l'instance, point, le nom de la méthode,
puis ensuite entre parenthèse rondes,
la liste des arguments que vous souhaitez passer à cet appel.
Donc, par exemple, si on veut appeler la méthode surface pour une instance rect1
de la classe Rectangle, ce que l'on va écrire, c'est rect1.surface,
et puis, ici, comme la méthode surface n'a pas besoin de recevoir des arguments,
on met simplement comme ça les 2 parenthèses, sans rien au milieu.
Si l'on revient donc à notre exemple complet,
nous avons donc comme précédemment la classe Exemple ici, qui va utiliser
donc la classe dans la méthode void main, une instance rest1 de la classe Rectangle.
Dans la classe Rectangle, on aura donc ajouté ici une méthode surface,
et puis donc, pour appeler cette méthode surface, sur l'instance
rect1 de cette classe Rectangle, on écrira simplement ici rect1.surface,
lequel rect1.surface retourne un double que l'on peut donc ici
afficher avec le message, par exemple surface deux-points.
Donc, dans ce cas-là, ça écrira, surface : et puis 12,
qui est le résultat de 3 fois 4.
Il faut bien comprendre que chaque instance a ses propres attributs,
donc si par exemple, je déclare 3 instances recto1, rect2,
recto3 de la classe Rectangle, et
que j'ai donné la valeur 3 à la hauteur de rect1, la valeur 4 à la largeur de rect1,
on aura des valeurs différentes, 11,5 par exemple, et 3,8 pour rect2,
et on aura dans un autre endroit de la mémoire, donc les valeurs par exemple
34,3 pour la largeur de rect3, et puis une autre valeur pour sa hauteur.
On n'a donc bien 3 variables différentes qui existent en mémoire.
Et quand on appelle donc rect1.surface, c'est la méthode surface globale de la
classe Rectangle qui va s'appliquer uniquement à l'instance rect1, ce qui
fait que dans cette méthode surface, dans cet appel à la méthode surface,
largeur désignera bien rect1.largeur et hauteur désignera rect1.hauteur.
Et si j'appelle à un autre endroit rect2.surface,
alors dans cet appel rect2.surface, ce sera hauteur qui vaudra là rect2.hauteur
et puis largeur vaudra rect2.largeur.
Notez qu'en toute rigueur,
les schémas pour les instances ici ne sont pas exactement corrects, puisqu'en fait
les variables sont des références vers les objets en mémoire,
mais le but était ici surtout d'insister sur le fait que chaque méthode,
chaque appel de méthode, avait accès à chacun des attributs, pour les détails de
représentation mémoire, nous y reviendrons plus tard dans ce cours.
Voilà, ce qui conclut cette séquence vidéo,
on a vu comment concrètement déclarer des objets en Java,
on a vu comment déclarer des attributs et comment déclarer des méthodes,
c'est-à-dire qu'essentiellement sur cette figure, on a vu cet axe-là,
reste maintenant à voir comment on va faire les différences entre l'interface et
les détails d'implémentation, c'est-à-dire cet autre axe sur cette figure,
ce qui est l'objet de la séquence vidéo suivante.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
