{"id":82,"date":"2021-05-29T14:05:51","date_gmt":"2021-05-29T14:05:51","guid":{"rendered":"https:\/\/www.louismarchand.me\/?page_id=82"},"modified":"2021-05-29T14:28:07","modified_gmt":"2021-05-29T14:28:07","slug":"redefinition-de-methode","status":"publish","type":"page","link":"https:\/\/www.louismarchand.me\/index.php\/redefinition-de-methode\/","title":{"rendered":"Red\u00e9finition de m\u00e9thode"},"content":{"rendered":"

Introduction<\/h2>\n

Comme nous l’avons vu dans une th\u00e9orie pr\u00e9c\u00e9dente, il est possible de pr\u00e9ciser dans une classe qu’une m\u00e9thode existera dans un objet, mais de laisser aux descendants de cette classe la t\u00e2che de pr\u00e9ciser l’impl\u00e9mentation de la m\u00e9thode en question. C’est ce que nous appelons une m\u00e9thode abstraite. Par contre, un autre cas de figure est possible. Il s’agit du cas ou la classe a une impl\u00e9mentation d’une m\u00e9thode pr\u00e9cise, mais qu’un des descendants de cette classe n\u00e9cessite une autre impl\u00e9mentation. Cette m\u00e9canique est possible et se nomme red\u00e9finition.<\/p>\n

Les red\u00e9finitions<\/h2>\n

Supposons que vous avez une structure d’h\u00e9ritage contenant une classe parent et plusieurs classes enfants. Initialement, toutes les classes enfants ont une m\u00e9thode en commun (m\u00eame impl\u00e9mentation). Il est donc tout \u00e0 fait logique de placer cette m\u00e9thode dans la classe parent. Par contre, imaginez qu’on ajoute une nouvelle classe enfant et que, contrairement aux autres enfants, la m\u00e9thode ait une impl\u00e9mentation diff\u00e9rente.<\/p>\n

Une solution pourrait \u00eatre de replacer la m\u00e9thode dans tous les enfants; mais cette solution implique beaucoup de duplication de code inutile. Une autre solution consisterait \u00e0 laisser la m\u00e9thode dans la classe parent et pr\u00e9ciser, dans la nouvelle classe enfant, que la m\u00e9thode est diff\u00e9rente que celle du parent. C’est ce que nous appelons une red\u00e9finition<\/strong>.<\/p>\n

Prendre note qu’une autre solution aurait pu \u00eatre de cr\u00e9er une classe interm\u00e9diaire entre le parent et les classes enfants d’origines. Cette technique fonctionnerait bien, mais je ne vais pas en tenir compte ici et me concentrer sur la red\u00e9finition.<\/p>\n

Pour red\u00e9finir une m\u00e9thode, il suffit de la d\u00e9finir \u00e0 nouveau dans la classe enfant. Voici un exemple. Je pars encore une fois de la structure d’h\u00e9ritage que nous avons d\u00e9velopp\u00e9 dans les derni\u00e8res th\u00e9ories:<\/p>\n

\"\"<\/p>\n

Supposons que je veux ajouter une m\u00e9thode \u00ab\u00a0deplacement\u00a0\u00bb dans la classe Animal. Je peux l’impl\u00e9ment\u00e9 comme ceci:<\/p>\n

\n
\/**<\/span>\n * Repr\u00e9sente tous les sp\u00e9cimens animal.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 16:58:57 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> abstract<\/span> class<\/span> Animal<\/span> {<\/span>\n\n    ...\n\n    \/**<\/span>\n     * Effectue un d\u00e9placement de l'Animal.<\/span>\n     *\/<\/span>\n    public<\/span> void<\/span> deplacement<\/span>(){<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"L'animal commence \u00e0 marcher.\"<\/span>);<\/span>\n    }<\/span>\n\n    ...\n\n}<\/span>\n<\/pre>\n<\/div>\n
On voit que cette m\u00e9thode s’applique tr\u00e8s bien aux animaux que j’ai d\u00e9j\u00e0 dans mon syst\u00e8me. D’ailleur, les classes Chat et Chien resteront inchang\u00e9e. Par contre, disons que je doivent ajouter un nouvel animal dans ma structure d’h\u00e9ritage: Poisson. On voit ici qu’un Poisson ne marche pas. Il nage. Nous allons donc devoir red\u00e9finir la m\u00e9thode \u00ab\u00a0deplacement\u00a0\u00bb. Voici la classe Poisson avec cette red\u00e9finition.<\/p>\n
\n
\/**<\/span>\n * Animal qui vie dans l'eau.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 17:03:49 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Poisson<\/span> extends<\/span> Animal<\/span>{<\/span>\n\t\n    \/**<\/span>\n     * Le son qu'\u00e9met l'Animal<\/span>\n     *\/<\/span>\n    public<\/span> void<\/span> cri<\/span>()<\/span> {<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Bloup!\"<\/span>);<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Effectue un d\u00e9placement de l'Animal.<\/span>\n     *\/<\/span>\n    public<\/span> void<\/span> deplacement<\/span>(){<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"L'animal commence \u00e0 nager.\"<\/span>);<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Constructeur du Poisson<\/span>\n     *<\/span>\n     * @param aNom Valeur de nom<\/span>\n     * @param aAge Valeur de age<\/span>\n     *\/<\/span>\n    public<\/span> Poisson<\/span>(<\/span>String<\/span> aNom<\/span>,<\/span> int<\/span> aAge<\/span>)<\/span> {<\/span>\n        super<\/span>(<\/span>aNom<\/span>,<\/span> aAge<\/span>);<\/span>\n    }<\/span>\n\n}<\/span>\n<\/pre>\n<\/div>\n
Si nous utilisons le programme suivant:<\/p>\n
\n
\/**<\/span>\n * Programme principal de l'exemple des animaux.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 17:14:16 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Programme<\/span> {<\/span>\n\n    \/**<\/span>\n     * Ex\u00e9cution du programme.<\/span>\n     *<\/span>\n     * @param aArguments Les param\u00eatres du programme.<\/span>\n     *\/<\/span>\n    public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> aArguments<\/span>)<\/span> {<\/span>\n        Chien<\/span> lChien<\/span> =<\/span> new<\/span> Chien<\/span>(<\/span>\"Rex\"<\/span>,<\/span> 10<\/span>);<\/span>\n        Chat<\/span> lChat<\/span> =<\/span> new<\/span> Chat<\/span>(<\/span>\"Minou\"<\/span>,<\/span> 3<\/span>);<\/span>\n        Poisson<\/span> lPoisson<\/span> =<\/span> new<\/span> Poisson<\/span>(<\/span>\"Pachon\"<\/span>,<\/span> 1<\/span>);<\/span>\n\n        lChien<\/span>.<\/span>deplacement<\/span>();<\/span>\n        lChat<\/span>.<\/span>deplacement<\/span>();<\/span>\n        lPoisson<\/span>.<\/span>deplacement<\/span>();<\/span>\n\n    }<\/span>\n}<\/span>\n<\/pre>\n<\/div>\n
Nous obtiendrons le r\u00e9sultat suivant:<\/p>\n
L'animal commence \u00e0 marcher.\nL'animal commence \u00e0 marcher.\nL'animal commence \u00e0 nager.<\/pre>\n
On voit tout de suite que la red\u00e9finition a fonctionn\u00e9 pour le poisson.<\/p>\n
Un petit probl\u00e8me<\/h3>\n
Il est important de remarquer ici que, malgr\u00e9 la m\u00e9canique assez facile de la red\u00e9finition en java, c’est une m\u00e9canique qui peut facilement g\u00e9n\u00e9rer des erreurs qui seront difficiles \u00e0 d\u00e9boguer par apr\u00e8s.<\/p>\n
L\u00e0 o\u00f9 la red\u00e9finition peut-\u00eatre dangereuse est dans le cas o\u00f9 la classe parent ferait une modification \u00e0 la signature de la m\u00e9thode. Si par exemple je d\u00e9cidais de renommer ma m\u00e9thode \u00ab\u00a0deplacement\u00a0\u00bb pour \u00ab\u00a0avancer\u00a0\u00bb comme ceci:<\/p>\n
\n
\/**<\/span>\n * Repr\u00e9sente tous les sp\u00e9cimens animal.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 16:58:57 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> abstract<\/span> class<\/span> Animal<\/span> {<\/span>\n\n    ...\n\n    \/**<\/span>\n     * Effectue un d\u00e9placement de l'Animal.<\/span>\n     *\/<\/span>\n    public<\/span> void<\/span> avancer<\/span>(){<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"L'animal commence \u00e0 marcher.\"<\/span>);<\/span>\n    }<\/span>\n\n    ...\n\n}<\/span>\n<\/pre>\n<\/div>\n
Le lien client\/fournisseur que la classe Programme (le main) a avec Animal ne causerait aucun probl\u00e8me puisque lors de la compilation, une erreur m’indiquerait que je dois modifier mes appels \u00e0 \u00ab\u00a0deplacement\u00a0\u00bb pour les remplacer par des appels \u00e0 \u00ab\u00a0avancer\u00a0\u00bb (en fait, la compilation donnerait des erreurs de type \u00ab\u00a0cannot find symbol\u00a0\u00bb en sp\u00e9cifiant que le symbole manquant est \u00ab\u00a0deplacement\u00a0\u00bb).<\/p>\n
Par contre, si j’oublie de modifier ma m\u00e9thode \u00ab\u00a0deplacement\u00a0\u00bb dans Poisson, je me retrouverai avec une classe Poisson contenant deux m\u00e9thodes diff\u00e9rentes \u00ab\u00a0deplacement\u00a0\u00bb (d\u00e9clar\u00e9e dans Poisson) et \u00ab\u00a0avancer\u00a0\u00bb (d\u00e9clar\u00e9e dans Animal). Puisqu’il s’agit d’une syntaxe tout \u00e0 fait valide, le compilateur de Java ne m’informera jamais de l’oublie et mon programme n’effectuera le bon travail. Par exemple, si je ne modifie pas ma classe poisson et que je lance le programme suivant:<\/p>\n
\n
\/**<\/span>\n * Programme principal de l'exemple des animaux.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 17:14:16 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Programme<\/span> {<\/span>\n\n    \/**<\/span>\n     * Ex\u00e9cution du programme.<\/span>\n     *<\/span>\n     * @param aArguments Les param\u00eatres du programme.<\/span>\n     *\/<\/span>\n    public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> aArguments<\/span>)<\/span> {<\/span>\n        Chien<\/span> lChien<\/span> =<\/span> new<\/span> Chien<\/span>(<\/span>\"Rex\"<\/span>,<\/span> 10<\/span>);<\/span>\n        Chat<\/span> lChat<\/span> =<\/span> new<\/span> Chat<\/span>(<\/span>\"Minou\"<\/span>,<\/span> 3<\/span>);<\/span>\n        Poisson<\/span> lPoisson<\/span> =<\/span> new<\/span> Poisson<\/span>(<\/span>\"Pachon\"<\/span>,<\/span> 1<\/span>);<\/span>\n\n        lChien<\/span>.<\/span>avancer<\/span>();<\/span>\n        lChat<\/span>.<\/span>avancer<\/span>();<\/span>\n        lPoisson<\/span>.<\/span>avancer<\/span>();<\/span>\n\n    }<\/span>\n}<\/span>\n<\/pre>\n<\/div>\n
J’obtiendrai le r\u00e9sultat:<\/p>\n
L'animal commence \u00e0 marcher.\nL'animal commence \u00e0 marcher.\nL'animal commence \u00e0 marcher.<\/pre>\n
On voit tout de suite que le Poisson s’est mis \u00e0 marcher, ce qui n’est pas correct dans mon syst\u00e8me.<\/p>\n
Pour nous assurer d’\u00e9viter ce type d’oublie qui m\u00e8ne \u00e0 des erreurs, nous allons utiliser la syntaxe \u00ab\u00a0@Override\u00a0\u00bb avant la signature de la red\u00e9finition. Par exemple, si j’avais cr\u00e9\u00e9 ma classe Poisson de cette mani\u00e8re:<\/p>\n
\n
\/**<\/span>\n * Animal qui vie dans l'eau.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 17:03:49 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Poisson<\/span> extends<\/span> Animal<\/span>{<\/span>\n\n    \/**<\/span>\n     * Le son qu'\u00e9met l'Animal<\/span>\n     *\/<\/span>\n    public<\/span> void<\/span> cri<\/span>()<\/span> {<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Bloup!\"<\/span>);<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Effectue un d\u00e9placement de l'Animal.<\/span>\n     *\/<\/span>\n    @Override<\/span>\n    public<\/span> void<\/span> deplacement<\/span>(){<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"L'animal commence \u00e0 nager.\"<\/span>);<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Constructeur du Poisson<\/span>\n     *<\/span>\n     * @param aNom Valeur de nom<\/span>\n     * @param aAge Valeur de age<\/span>\n     *\/<\/span>\n    public<\/span> Poisson<\/span>(<\/span>String<\/span> aNom<\/span>,<\/span> int<\/span> aAge<\/span>)<\/span> {<\/span>\n        super<\/span>(<\/span>aNom<\/span>,<\/span> aAge<\/span>);<\/span>\n    }<\/span>\n\n}<\/span>\n<\/pre>\n<\/div>\n
Le compilateur m’aurait inform\u00e9 \u00e0 l’instant que la m\u00e9thode red\u00e9finie n’est plus pr\u00e9sente dans le parent. Le programme recompilera seulement si je renomme la m\u00e9thode \u00ab\u00a0deplacement\u00a0\u00bb dans Poisson (ou si je remets la m\u00e9thode \u00ab\u00a0deplacement\u00a0\u00bb dans le parent). Voici la classe Poisson apr\u00e8s avoir renomm\u00e9 la m\u00e9thode red\u00e9finie:<\/p>\n
\n
\/**<\/span>\n * Animal qui vie dans l'eau.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 17:03:49 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Poisson<\/span> extends<\/span> Animal<\/span>{<\/span>\n\n    \/**<\/span>\n     * Le son qu'\u00e9met l'Animal<\/span>\n     *\/<\/span>\n    public<\/span> void<\/span> cri<\/span>()<\/span> {<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Bloup!\"<\/span>);<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Effectue un d\u00e9placement de l'Animal.<\/span>\n     *\/<\/span>\n    public<\/span> void<\/span> avancer<\/span>(){<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"L'animal commence \u00e0 nager.\"<\/span>);<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Constructeur du Poisson<\/span>\n     *<\/span>\n     * @param aNom Valeur de nom<\/span>\n     * @param aAge Valeur de age<\/span>\n     *\/<\/span>\n    public<\/span> Poisson<\/span>(<\/span>String<\/span> aNom<\/span>,<\/span> int<\/span> aAge<\/span>)<\/span> {<\/span>\n        super<\/span>(<\/span>aNom<\/span>,<\/span> aAge<\/span>);<\/span>\n    }<\/span>\n\n}<\/span>\n<\/pre>\n<\/div>\n
Il est \u00e0 noter que l’indicateur \u00ab\u00a0@Override\u00a0\u00bb doit toujours \u00eatre inscrit lors d’une red\u00e9finition de m\u00e9thode.<\/p>\n
Utilisation de la m\u00e9thode red\u00e9finie du parent<\/h2>\n
De mani\u00e8re similaire \u00e0 l’utilisation du \u00ab\u00a0super\u00a0\u00bb pour lancer les constructeurs du parent \u00e0 partir des constructeurs de l’enfant, il est possible de lancer la m\u00e9thode red\u00e9finie du parent \u00e0 partir de la m\u00e9thode de l’enfant. Pour se faire, nous utilisons encore le mot cl\u00e9 \u00ab\u00a0super\u00a0\u00bb, mais en sp\u00e9cifiant quelle m\u00e9thode du parent doit \u00eatre lanc\u00e9e.<\/p>\n
Voici un exemple, si je consid\u00e8re qu’apr\u00e8s avoir commencer \u00e0 marcher, je veux que le Chien renifle tout ce qu’il croise. Je pourrais donc red\u00e9finir la m\u00e9thode \u00ab\u00a0avancer\u00a0\u00bb dans Chien.java de cette mani\u00e8re:<\/p>\n
\n
\/**<\/span>\n * Animal de race canine.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 17:03:49 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Chien<\/span> extends<\/span> Animal<\/span>{<\/span>\n\n    \/**<\/span>\n     * Le son qu'\u00e9met l'Animal<\/span>\n     *\/<\/span>\n    public<\/span> void<\/span> cri<\/span>()<\/span> {<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Wouf Wouf!\"<\/span>);<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Constructeur du Chien<\/span>\n     *<\/span>\n     * @param aNom Valeur de nom<\/span>\n     * @param aAge Valeur de age<\/span>\n     *\/<\/span>\n    public<\/span> Chien<\/span>(<\/span>String<\/span> aNom<\/span>,<\/span> int<\/span> aAge<\/span>)<\/span> {<\/span>\n        super<\/span>(<\/span>aNom<\/span>,<\/span> aAge<\/span>);<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Effectue un d\u00e9placement de l'Animal.<\/span>\n     *\/<\/span>\n    @Override<\/span>\n    public<\/span> void<\/span> avancer<\/span>(){<\/span>\n        super<\/span>.<\/span>avancer<\/span>();<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"L'animal renifle partout o\u00f9 il passe.\"<\/span>);<\/span>\n    }<\/span>\n\n}<\/span>\n<\/pre>\n<\/div>\n
Si j’ex\u00e9cute le code suivant:<\/p>\n
\n
Chien<\/span> lChien<\/span> =<\/span> new<\/span> Chien<\/span>(<\/span>\"Rex\"<\/span>,<\/span> 10<\/span>);<\/span>\nlChien<\/span>.<\/span>avancer<\/span>();<\/span>\n<\/pre>\n<\/div>\n
J’obtiens donc le r\u00e9sultat:<\/p>\n
L'animal commence \u00e0 marcher.\nL'animal renifle partout o\u00f9 il passe.<\/pre>\n
Je peux mettre le \u00ab\u00a0super\u00a0\u00bb n’importe o\u00f9 dans le code de la m\u00e9thode red\u00e9finie. Par exemple, si je veux que le Chat s’\u00e9tire avant de commencer \u00e0 marcher, je pourrais mettre la m\u00e9thode red\u00e9finie suivante dans Chat.java:<\/p>\n
\n
    \/**<\/span>\n     * Effectue un d\u00e9placement de l'Animal.<\/span>\n     *\/<\/span>\n    @Override<\/span>\n    public<\/span> void<\/span> avancer<\/span>(){<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"L'animal s'\u00e9tire.\"<\/span>);<\/span>\n        super<\/span>.<\/span>avancer<\/span>();<\/span>\n    }<\/span>\n<\/pre>\n<\/div>\n
Si j’ex\u00e9cute le code suivant:<\/p>\n
\n
Chat<\/span> lChat<\/span> =<\/span> new<\/span> Chat<\/span>(<\/span>\"Minou\"<\/span>,<\/span> 10<\/span>);<\/span>\nlChat<\/span>.<\/span>avancer<\/span>();<\/span>\n<\/pre>\n<\/div>\n
J’obtiens le r\u00e9sultat:<\/p>\n
L'animal s'\u00e9tire.\nL'animal commence \u00e0 marcher.<\/pre>\n
Red\u00e9finir les m\u00e9thodes de la classe Object<\/h2>\n
Comme nous l’avons indiqu\u00e9 pr\u00e9c\u00e9demment, toutes les classes, peu importe qu’on leur sp\u00e9cifie un lien d’h\u00e9ritage ou non, h\u00e9ritent de la classe Object<\/a>. D’ailleurs, il est facile de s’en rendre compte avec un petit exemple comme ceci:<\/p>\n
\n
public<\/span> void<\/span> compareAnimaux<\/span>(<\/span>Animal<\/span> aAnimal1<\/span>,<\/span> Animal<\/span> aAnimal2<\/span>)<\/span> {<\/span>\n    if<\/span> (<\/span>aAnimal1<\/span>.<\/span>equals<\/span>(<\/span>aAnimal2<\/span>)){<\/span>\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Il s'agit du m\u00eame animal.\"<\/span>);<\/span>\n    }<\/span>\n}<\/span>\n<\/pre>\n<\/div>\n
Cette m\u00e9thode compile sans probl\u00e8me malgr\u00e9 que la classe Animal ne contient pas de m\u00e9thode \u00ab\u00a0equals\u00a0\u00bb. Par contre, puisque Animal h\u00e9rite de Object<\/a> et que la classe Object<\/a> contient une m\u00e9thode \u00ab\u00a0equals<\/a>\u00ab\u00a0, il est possible d’utiliser cette m\u00e9thode sur un objet de type Animal.<\/p>\n
Il peut \u00eatre utile de red\u00e9finir les m\u00e9thodes de la classe Object<\/a> afin de les rendre plus utiles et plus conformes \u00e0 la r\u00e9alit\u00e9. Les m\u00e9thodes qui sont souvent utiles \u00e0 red\u00e9finir sont les m\u00e9thodes \u00ab\u00a0equals<\/a>\u00a0\u00bb , \u00ab\u00a0clone<\/a>\u00a0\u00bb et \u00ab\u00a0toString<\/a>\u00a0\u00bb .<\/p>\n
Je vais donner des exemples de red\u00e9finition de ces m\u00e9thodes dans les sections suivantes.<\/p>\n
Red\u00e9finir \u00ab\u00a0equals<\/a>\u00a0\u00bb  <\/h3>\n
La m\u00e9thode de \u00ab\u00a0equals<\/a>\u00a0\u00bb permet de savoir si deux objets sont logiquement \u00e9quivalents. Par d\u00e9faut, cette m\u00e9thode retourne la m\u00eame valeur que l’instruction \u00ab\u00a0==\u00a0\u00bb. Par contre, en red\u00e9finissant \u00ab\u00a0equals<\/a>\u00a0\u00bb , nous pouvons pr\u00e9ciser les conditions qui font que logiquement deux objets sont logiquement \u00e9quivalents.<\/p>\n
C’est la raison pour laquelle dans le code suivant:<\/p>\n
\n
String<\/span> lChaine1<\/span> =<\/span> new<\/span> String<\/span>(<\/span>\"Allo\"<\/span>);<\/span>\nString<\/span> lChaine2<\/span> =<\/span> new<\/span> String<\/span>(<\/span>\"Allo\"<\/span>);<\/span>\nSystem<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>lChaine1<\/span> ==<\/span> lChaine2<\/span>);<\/span>\nSystem<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>lChaine1<\/span>.<\/span>equals<\/span>(<\/span>lChaine2<\/span>));<\/span>\n<\/pre>\n<\/div>\n
Le premier \u00ab\u00a0println\u00a0\u00bb retourne \u00ab\u00a0False\u00a0\u00bb et le second \u00ab\u00a0println\u00a0\u00bb retourne \u00ab\u00a0True\u00a0\u00bb. La classe String a red\u00e9fini la m\u00e9thode \u00ab\u00a0equals\u00a0\u00bb afin de retourner \u00ab\u00a0True\u00a0\u00bb si les caract\u00e8res contenus dans la cha\u00eene sont les m\u00eames.<\/p>\n
Supposons la classe suivante:<\/p>\n
\n
\/**<\/span>\n * Le r\u00e9sultat d'un achat.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, vendredi avr 09, 2021 10:45:11 EDT<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Facture<\/span> {<\/span>\n\n    \/**<\/span>\n     * Le num\u00e9ro unique de la Facture.<\/span>\n     *\/<\/span>\n    private<\/span> int<\/span> numero<\/span>;<\/span>\n\n    \/**<\/span>\n     * Le nom du client ayant fait l'achat.<\/span>\n     *\/<\/span>\n    private<\/span> String<\/span> client<\/span>;<\/span>\n\n    \/**<\/span>\n     * Ce que l'achat a cout\u00e9 au client (en sous).<\/span>\n     *\/<\/span>\n    private<\/span> int<\/span> montant<\/span>;<\/span>\n\n    \/**<\/span>\n     * Constructeur de Facture<\/span>\n     *<\/span>\n     * @param aNumero Valeur de numero.<\/span>\n     * @param aClient Valeur de client.<\/span>\n     * @param aMontant Valeur de montant.<\/span>\n     *\/<\/span>\n    public<\/span> Facture<\/span>(<\/span>int<\/span> aNumero<\/span>,<\/span> String<\/span> aClient<\/span>,<\/span> int<\/span> aMontant<\/span>)<\/span> {<\/span>\n        numero<\/span> =<\/span> aNumero<\/span>;<\/span>\n        client<\/span> =<\/span> aClient<\/span>;<\/span>\n        montant<\/span> =<\/span> aMontant<\/span>;<\/span>\n    }<\/span>\n\n}<\/span>\n<\/pre>\n<\/div>\n
On obtient que le code suivant retourne \u00ab\u00a0False\u00a0\u00bb:<\/p>\n
Facture lFacture1 = new Facture(1, \"Louis\", 1000);\nFacture lFacture2 = new Facture(1, \"Louis\", 1000);\nSystem.out.println(lFacture1.equals(lFacture2));<\/pre>\n
Ce r\u00e9sultat est normal parce que \u00ab\u00a0lFacture1\u00a0\u00bb et \u00ab\u00a0lFacture2\u00a0\u00bb sont deux objets distincts. Par contre, supposons que nous voudrions que ce code retourne \u00ab\u00a0True\u00a0\u00bb puisque les valeurs des objets sont identiques, je pourrais red\u00e9finir la m\u00e9thode \u00ab\u00a0equals<\/a>\u00a0\u00bb comme ceci:<\/p>\n
\n
\/**<\/span>\n * Le r\u00e9sultat d'un achat.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, vendredi avr 09, 2021 10:45:11 EDT<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Facture<\/span> {<\/span>\n\t\n    \/**<\/span>\n     * Le num\u00e9ro unique de la Facture.<\/span>\n     *\/<\/span>\n    private<\/span> int<\/span> numero<\/span>;<\/span>\n\n    \/**<\/span>\n     * Le nom du client ayant fait l'achat.<\/span>\n     *\/<\/span>\n    private<\/span> String<\/span> client<\/span>;<\/span>\n\n    \/**<\/span>\n     * Ce que l'achat a cout\u00e9 au client (en sous).<\/span>\n     *\/<\/span>\n    private<\/span> int<\/span> montant<\/span>;<\/span>\n\n    \/**<\/span>\n     * Retourne vrai si aAutre est \u00e9quivalent \u00e0 la Facture.<\/span>\n     *<\/span>\n     * @param aAutre La facture \u00e0 comparer.<\/span>\n     * @return Vrai si la aAutre est \u00e9quivalent \u00e0 la Facture.<\/span>\n     *\/<\/span>\n    @Override<\/span>\n    public<\/span> boolean<\/span> equals<\/span>(<\/span>Object<\/span> aAutre<\/span>)<\/span> {<\/span>\n        boolean<\/span> lResultat<\/span> =<\/span> false<\/span>;<\/span>\n        if<\/span> (<\/span>aAutre<\/span> instanceof<\/span> Facture<\/span>)<\/span> {<\/span>\n            Facture<\/span> lAutre<\/span> =<\/span> (<\/span>Facture<\/span>)<\/span>aAutre<\/span>;<\/span>\n            lResultat<\/span> =<\/span> \n                numero<\/span> ==<\/span> lAutre<\/span>.<\/span>numero<\/span> &&<\/span>\n                client<\/span>.<\/span>equals<\/span>(<\/span>lAutre<\/span>.<\/span>client<\/span>)<\/span> &&<\/span>\n                montant<\/span> ==<\/span> lAutre<\/span>.<\/span>montant<\/span>;<\/span>\n        }<\/span>\n        return<\/span> lResultat<\/span>;<\/span>\n    }<\/span>\n\n    \/**<\/span>\n     * Constructeur de Facture<\/span>\n     *<\/span>\n     * @param aNumero Valeur de numero.<\/span>\n     * @param aClient Valeur de client.<\/span>\n     * @param aMontant Valeur de montant.<\/span>\n     *\/<\/span>\n    public<\/span> Facture<\/span>(<\/span>int<\/span> aNumero<\/span>,<\/span> String<\/span> aClient<\/span>,<\/span> int<\/span> aMontant<\/span>)<\/span> {<\/span>\n        numero<\/span> =<\/span> aNumero<\/span>;<\/span>\n        client<\/span> =<\/span> aClient<\/span>;<\/span>\n        montant<\/span> =<\/span> aMontant<\/span>;<\/span>\n    }<\/span>\n\n}<\/span>\n<\/pre>\n<\/div>\n
En effet, si nous ex\u00e9cutons \u00e0 nouveau ce code:<\/p>\n
Facture lFacture1 = new Facture(1, \"Louis\", 1000);\nFacture lFacture2 = new Facture(1, \"Louis\", 1000);\nSystem.out.println(lFacture1.equals(lFacture2));<\/pre>\n
Pour que la m\u00e9thode soit bel et bien une red\u00e9finition, il faut \u00e9galement s’assurer que l’argument re\u00e7u est de type \u00ab\u00a0Object\u00a0\u00bb et non du m\u00eame type que la classe qui red\u00e9finit le \u00ab\u00a0equals\u00a0\u00bb (dans mon cas, Facture). Donc, en g\u00e9n\u00e9ral, la premi\u00e8re chose que nous faisons est de s’assurer que l’objet re\u00e7u en argument est du bon type (avec un test de type) et d’utiliser un \u00ab\u00a0cast\u00a0\u00bb pour acc\u00e9der aux attributs de l’argument (voir la th\u00e9orie sur le Polymorphisme pour plus de d\u00e9tails).<\/p>\n
Note: Il est \u00e0 noter que normalement, lorsque la m\u00e9thode \u00ab\u00a0equals<\/a>\u00a0\u00bb est red\u00e9finie, il faudrait \u00e9galement red\u00e9finir la m\u00e9thode \u00ab\u00a0hashCode<\/a>\u00a0\u00bb (puisque deux objets \u00e9gaux devraient avoir le m\u00eame \u00ab\u00a0hashCode\u00a0\u00bb). Mais, nous garderons la th\u00e9orie sur les \u00ab\u00a0hashCode\u00a0\u00bb pour un autre cours du programme.<\/p>\n
Nous obtenons maintenant \u00ab\u00a0True\u00a0\u00bb.<\/p>\n
Red\u00e9finir \u00ab\u00a0clone<\/a>\u00a0\u00bb <\/h3>\n
La m\u00e9thode \u00ab\u00a0clone<\/a>\u00a0\u00bb permet de faire une copie d’un objet. Prenons par exemple le code suivant:<\/p>\n
\n
ArrayList<\/span><<\/span>String<\/span>><\/span> lListe1<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>String<\/span>><\/span> (<\/span>5<\/span>);<\/span>\nlListe1<\/span>.<\/span>add<\/span>(<\/span>\"1\"<\/span>);<\/span>\nlListe1<\/span>.<\/span>add<\/span>(<\/span>\"2\"<\/span>);<\/span>\nlListe1<\/span>.<\/span>add<\/span>(<\/span>\"3\"<\/span>);<\/span>\nlListe1<\/span>.<\/span>add<\/span>(<\/span>\"4\"<\/span>);<\/span>\nlListe1<\/span>.<\/span>add<\/span>(<\/span>\"5\"<\/span>);<\/span>\nList<\/span><<\/span>String<\/span>><\/span> lListe2<\/span> =<\/span> (<\/span>List<\/span><<\/span>String<\/span>>)<\/span>lListe1<\/span>.<\/span>clone<\/span>();<\/span>\nSystem<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>lListe1<\/span> ==<\/span> lListe2<\/span>);<\/span>\nSystem<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>lListe1<\/span>.<\/span>equals<\/span>(<\/span>lListe2<\/span>));<\/span>\n<\/pre>\n<\/div>\n
Le premier \u00ab\u00a0println\u00a0\u00bb retourne \u00ab\u00a0False\u00a0\u00bb puisqu’il s’agit de deux objets distincts. Le second \u00ab\u00a0println\u00a0\u00bb montre que les deux listes contiennent les m\u00eames \u00e9l\u00e9ments. On voit donc que le \u00ab\u00a0clone\u00a0\u00bb a effectivement cr\u00e9\u00e9 une nouvelle liste \u00ab\u00a0lListe2\u00a0\u00bb contenant les m\u00eames \u00e9l\u00e9ments que la liste \u00ab\u00a0lListe1\u00a0\u00bb.<\/p>\n
Pour bien comprendre ce code, il est important de comprendre que la m\u00e9thode \u00ab\u00a0clone<\/a>\u00a0\u00bb dans la classe Object<\/a> retourne une valeur de type Object et non du type de la variable ayant effectu\u00e9 le \u00ab\u00a0clone\u00a0\u00bb (ArrayList dans mon exemple). Il est donc n\u00e9cessaire d’effectuer un \u00ab\u00a0cast\u00a0\u00bb de type pour pr\u00e9ciser au langage de quel type l’objet est en r\u00e9alit\u00e9 (voir la th\u00e9orie sur le polymorphisme pour plus de d\u00e9tails).<\/p>\n
Voici la m\u00e9thode \u00ab\u00a0clone<\/a>\u00a0\u00bb red\u00e9finie dans la classe Facture:<\/p>\n
\n
    \/**<\/span>\n     * Retourne une copie de l'objet.<\/span>\n     *<\/span>\n     * @return Une copie de la facture.<\/span>\n     *\/<\/span>\n    @Override<\/span>\n    public<\/span> Object<\/span> clone<\/span>(){<\/span>\n        return<\/span> new<\/span> Facture<\/span>(<\/span>numero<\/span>,<\/span> client<\/span>,<\/span> montant<\/span>);<\/span>\n    }<\/span>\n<\/pre>\n<\/div>\n
Red\u00e9finition de la m\u00e9thode \u00ab\u00a0toString<\/a>\u00a0\u00bb <\/h3>\n
La m\u00e9thode \u00ab\u00a0toString<\/a>\u00a0\u00bb permet de retourner une repr\u00e9sentation texte de l’objet. Par exemple, prenons le code suivant:<\/p>\n
\n
Facture<\/span> lFacture1<\/span> =<\/span> new<\/span> Facture<\/span>(<\/span>1<\/span>,<\/span> \"Louis\"<\/span>,<\/span> 1023<\/span>);<\/span>\nSystem<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>lFacture1<\/span>);<\/span>\n<\/pre>\n<\/div>\n
En ex\u00e9cutant le programme, j’obtiens le r\u00e9sultat:<\/p>\n
Facture@3764951d<\/pre>\n
On voit que \u00e7a ne repr\u00e9sente rien du tout. En fait, \u00e7a repr\u00e9sente le type de l’objet ainsi que son pointeur m\u00e9moire.<\/p>\n
En red\u00e9finissant la m\u00e9thode \u00ab\u00a0toString<\/a>\u00a0\u00bb , je peux pr\u00e9ciser la forme que prendra la repr\u00e9sentation texte de l’objet. Si par exemple, j’ajoute cette m\u00e9thode dans la classe Facture:<\/p>\n
\n
\/**<\/span>\n * Retourne une cha\u00eene repr\u00e9sentant la Facture.<\/span>\n *<\/span>\n * @return Cha\u00eene repr\u00e9sentant la Facture.<\/span>\n *\/<\/span>\n@Override<\/span>\npublic<\/span> String<\/span> toString<\/span>()<\/span> {<\/span>\n    return<\/span>\n        \"Facture \"<\/span> +<\/span> numero<\/span> +<\/span> \" pour le client \"<\/span> +<\/span> client<\/span> +<\/span>\n        \" au montant de \"<\/span> +<\/span> (<\/span>montant<\/span> \/<\/span> 100<\/span>)<\/span> +<\/span> \".\"<\/span> +<\/span>\n        (<\/span>montant<\/span> %<\/span> 100<\/span>)<\/span> +<\/span> \"$\"<\/span>;<\/span>\n}<\/span>\n<\/pre>\n<\/div>\n
et que je r\u00e9-ex\u00e9cute le programme pr\u00e9sent\u00e9 plus haut:<\/p>\n
\n
Facture<\/span> lFacture1<\/span> =<\/span> new<\/span> Facture<\/span>(<\/span>1<\/span>,<\/span> \"Louis\"<\/span>,<\/span> 1023<\/span>);<\/span>\nSystem<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>lFacture1<\/span>);<\/span>\n<\/pre>\n<\/div>\n
j’obtiens donc le r\u00e9sultat suivant:<\/p>\n
Facture 1 pour le client Louis au montant de 10.23$<\/pre>\n
Retour<\/a><\/p>\n
 <\/p>\n
\n
Auteur: Louis Marchand
\n\"Creative<\/a>
\nSauf pour les sections sp\u00e9cifi\u00e9es autrement, ce travail est sous licence Creative Commons Attribution 4.0 International<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
Introduction Comme nous l’avons vu dans une th\u00e9orie pr\u00e9c\u00e9dente, il est possible de pr\u00e9ciser dans une classe qu’une m\u00e9thode existera dans un objet, mais de laisser aux descendants de cette classe la t\u00e2che de pr\u00e9ciser l’impl\u00e9mentation de la m\u00e9thode en question. C’est ce que nous appelons une m\u00e9thode abstraite. Par contre, un autre cas de… Continue reading Red\u00e9finition de m\u00e9thode<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-82","page","type-page","status-publish","hentry","entry"],"_links":{"self":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/82","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/comments?post=82"}],"version-history":[{"count":4,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/82\/revisions"}],"predecessor-version":[{"id":108,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/82\/revisions\/108"}],"wp:attachment":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/media?parent=82"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}