{"id":158,"date":"2021-08-20T15:47:20","date_gmt":"2021-08-20T15:47:20","guid":{"rendered":"https:\/\/www.louismarchand.me\/?page_id=158"},"modified":"2021-08-20T15:47:20","modified_gmt":"2021-08-20T15:47:20","slug":"objet2-les-bases","status":"publish","type":"page","link":"https:\/\/www.louismarchand.me\/index.php\/objet2-les-bases\/","title":{"rendered":"Les bases"},"content":{"rendered":"

Les attributs<\/h2>\n

On appelle attribut<\/strong> d’un objet une information qui sp\u00e9cifie une caract\u00e9ristique d’un objet. L’ensemble des attributs d’un objet permet de caract\u00e9riser pr\u00e9cis\u00e9ment l’\u00e9tat d’un objet<\/strong>.<\/p>\n

Les m\u00e9thodes<\/h2>\n

On appelle m\u00e9thode<\/strong> d’un objet une routine s’appliquant \u00e0 cet objet en particulier.<\/p>\n

Qu’est-ce qu’une classe<\/h2>\n

Une classe<\/strong> est une d\u00e9finition des caract\u00e9ristiques communes d’un ensemble d’objets. Elle contient, entre autres, l’ensemble des attributs et des d\u00e9clarations de m\u00e9thodes que ces objets ont en commun.<\/p>\n

Les constructeurs<\/h2>\n

M\u00e9thodes sp\u00e9ciales d’un objet permettant d’initialiser l’\u00e9tat initial de l’objet. En g\u00e9n\u00e9ral, le but d’un constructeur est d’assigner les attributs de l’objet.<\/p>\n

Plusieurs langages objets permettent la cr\u00e9ation de plusieurs constructeurs afin d’initialiser diff\u00e9remment l’\u00e9tat de l’objet. Si tel est le cas, il est \u00e9galement possible de lancer un autre constructeur \u00e0 partir d’un constructeur. Par exemple:<\/p>\n

Java:<\/p>\n

\n
public<\/span> class<\/span> Personne<\/span> {<\/span>\r\n\r\n    protected<\/span> String<\/span> nom<\/span>;<\/span>\r\n\r\n    protected<\/span> int<\/span> age<\/span>;<\/span>\r\n\r\n    public<\/span> Personne<\/span>(<\/span>String<\/span> aNom<\/span>,<\/span> int<\/span> aAge<\/span>)<\/span> {<\/span>\r\n        nom<\/span> =<\/span> aNom<\/span>;<\/span>\r\n        age<\/span> =<\/span> aAge<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> Personne<\/span>(<\/span>String<\/span> aNom<\/span>)<\/span> {<\/span>\r\n        this<\/span>(<\/span>aNom<\/span>,<\/span> 0<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
Eiffel:<\/p>\n
\n
class<\/span>\r\n\tPERSONNE<\/span>\r\n\r\ncreate<\/span>\r\n\tmake<\/span>,<\/span>\r\n\tmake_with_nom<\/span>\r\n\r\nfeature<\/span>\r\n\r\n\tnom<\/span>:<\/span> STRING<\/span>\r\n\r\n\tage<\/span>:<\/span> INTEGER<\/span>\r\n\r\n\tmake<\/span> (<\/span>a_nom<\/span>:<\/span> STRING<\/span>;<\/span> a_age<\/span>:<\/span> INTEGER<\/span>)<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tnom<\/span> :=<\/span> a_nom<\/span>\r\n\t\t\tage<\/span> :=<\/span> a_age<\/span>\r\n\t\tend<\/span>\r\n\r\n\tmake_with_nom<\/span> (<\/span>a_nom<\/span>:<\/span> STRING<\/span>)<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tmake<\/span> (<\/span>a_nom<\/span>,<\/span> 0<\/span>)<\/span>\r\n\t\tend<\/span>\r\n\r\nend<\/span>\r\n<\/pre>\n<\/div>\n
Les classes abstraites<\/h2>\n
Une classe abstraite<\/strong> permet la repr\u00e9sentation d’une classe dont l’impl\u00e9mentation est incompl\u00e8te. Une classe abstraite ne peut \u00eatre instanci\u00e9e.<\/p>\n
Il est \u00e0 noter que, m\u00eame les classes abstraites doivent avoir un constructeur afin d’initialiser les attributs de cette classe.<\/p>\n
Les m\u00e9thodes abstraites<\/h2>\n
On dit qu’une m\u00e9thode est abstraite<\/strong> si elle ne repr\u00e9sente que la d\u00e9claration (signature) de la routine, et non son impl\u00e9mentation.<\/p>\n
    \n
  • \n
      \n
    • \n
        \n
      • Notez que seules des classes abstraites peuvent poss\u00e9der des m\u00e9thodes abstraites<\/li>\n
      • Sers g\u00e9n\u00e9ralement \u00e0 permettre le polymorphisme<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
        H\u00e9ritage<\/h2>\n
        Un lien d’h\u00e9ritage<\/strong> est un lien qui permet une g\u00e9n\u00e9ralisation\/sp\u00e9cialisation d’une classe vers une autre. La classe plus sp\u00e9cifique poss\u00e8de tout ce que la classe g\u00e9n\u00e9rale poss\u00e8de, mais elle peut y ajouter de nouvelles m\u00e9thodes, de nouveaux attributs ou de nouvelle impl\u00e9mentation (impl\u00e9mentation de m\u00e9thode abstraite).<\/p>\n
        Par exemple, si on prend les classes Animal, Chien et Chat dans le diagramme suivant:<\/p>\n
        \"\"<\/p>\n
        Il faut comprendre qu’un Animal est une g\u00e9n\u00e9ralisation de Chat et de Chien. Inversement, Chat et Chien sont des sp\u00e9cialisations d’Animal.<\/p>\n
        Parfois, on appelle les liens d’h\u00e9ritage des liens parent\/enfant. Dans ce sens on appelle parents<\/strong> les g\u00e9n\u00e9ralisations directes et enfants<\/strong>, les sp\u00e9cialisations directes. Dans l’exemple pr\u00e9c\u00e9dent, Animal est un parent de Chat et Chien et ces derniers sont des enfants d\u2019Animal.<\/p>\n
        Dans le m\u00eame ordre d’id\u00e9e, on appelle anc\u00eatre<\/strong> les g\u00e9n\u00e9ralisations indirectes (plusieurs niveaux d’h\u00e9ritage) et descendant<\/strong> les sp\u00e9cialisations indirectes.<\/p>\n
        Il est \u00e0 noter que, sauf exception, les constructeurs des classes enfants ont comme responsabilit\u00e9 de lancer les constructeurs des classes parents. Par exemple:<\/p>\n
        Java:<\/p>\n
        \n
        public<\/span> class<\/span> Etudiant<\/span> extends<\/span> Personne<\/span> {<\/span>\r\n\r\n    protected<\/span> int<\/span> numeroDA<\/span>;<\/span>\r\n\r\n    public<\/span> Etudiant<\/span>(<\/span>String<\/span> aNom<\/span>,<\/span> int<\/span> aAge<\/span>,<\/span> int<\/span> aNumeroDA<\/span>)<\/span> {<\/span>\r\n        super<\/span>(<\/span>aNom<\/span>,<\/span> aAge<\/span>);<\/span>\r\n        numeroDA<\/span> =<\/span> aNumeroDA<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
        Eiffel:<\/p>\n
        \n
        class<\/span>\r\n\tETUDIANT<\/span>\r\n\r\ninherit<\/span>\r\n\r\n\tPERSONNE<\/span>\r\n\t\trename<\/span>\r\n\t\t\tmake<\/span> as<\/span> make_personne<\/span>\r\n\t\tend<\/span>\r\n\r\ncreate<\/span>\r\n\tmake<\/span>\r\n\r\nfeature<\/span>\r\n\r\n\tnumero_da<\/span>:<\/span> INTEGER<\/span>\r\n\r\n\tmake<\/span> (<\/span>a_nom<\/span>:<\/span> STRING<\/span>;<\/span> a_age<\/span>,<\/span> a_numero_da<\/span>:<\/span> INTEGER<\/span>)<\/span>\r\n\t\tdo<\/span>\r\n\t\t\tmake_personne<\/span> (<\/span>a_nom<\/span>,<\/span> a_age<\/span>)<\/span>\r\n\t\t\tnumero_da<\/span> :=<\/span> a_numero_da<\/span>\r\n\t\tend<\/span>\r\n\r\nend<\/span>\r\n<\/pre>\n<\/div>\n
        Le type d’un objet<\/h2>\n
        Le type d’un objet repr\u00e9sente la classe (ou le type primitif) utilis\u00e9e dans la d\u00e9claration de la variable contenant cet objet. Par exemple, dans les codes suivants:<\/p>\n
        Java:<\/p>\n
        \n
        Chat<\/span> mon_chat<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
        Eiffel:<\/p>\n
        \n
        mon_chat<\/span>:<\/span>CHAT<\/span>\r\n<\/pre>\n<\/div>\n
        L’objet (et la variable) mon_chat est de type Chat.<\/p>\n
        Le type g\u00e9n\u00e9rateur<\/h2>\n
        On appelle type g\u00e9n\u00e9rateur, la classe qui a permis d’instancier un objet. Par exemple, dans les codes suivants:<\/p>\n
        Java:<\/p>\n
        \n
        Animal<\/span> mon_animal<\/span> =<\/span> new<\/span> Chat<\/span>();<\/span>\r\n<\/pre>\n<\/div>\n
        Eiffel:<\/p>\n
        \n
        mon_animal<\/span>:<\/span>ANIMAL<\/span>\r\nmon_animal<\/span> :=<\/span> create<\/span> {<\/span>CHAT<\/span>}<\/span>\r\n<\/pre>\n<\/div>\n
        Le type g\u00e9n\u00e9rateur de mon_animal est Chat.<\/p>\n
        Conformisme<\/h2>\n
        On dit qu’un objet est conforme<\/strong> \u00e0 un type si ce type est un anc\u00eatre du type g\u00e9n\u00e9rateur de l’objet. Par exemple, dans les codes suivants:<\/p>\n
        Java:<\/p>\n
        \n
        Chat<\/span> mon_chat<\/span> =<\/span> new<\/span> Chat<\/span>();<\/span>\r\n<\/pre>\n<\/div>\n
        Eiffel:<\/p>\n
        \n
        mon_chat<\/span>:<\/span>CHAT<\/span>\r\ncreate<\/span> mon_chat<\/span>\r\n<\/pre>\n<\/div>\n
        On voit que le type g\u00e9n\u00e9rateur de mon_chat est la classe Chat. On peut donc dire que l’objet contenu dans mon_chat est conforme au type Animal puisque la classe Animal est un anc\u00eatre de la classe Chat.<\/p>\n
        Les clients d’une classe<\/h2>\n
        On dit qu’une classe A est client<\/strong> d’une classe B si un attribut ou une fonction de la classe A retourne un objet ou un ensemble d’objets de type B.<\/p>\n
        Il est \u00e0 noter que, par simplicit\u00e9, on \u00e9largit parfois cette d\u00e9finition afin d’y inclure tous les variables locales et arguments de m\u00e9thodes.<\/p>\n
        Les fournisseurs d’une classe<\/h2>\n
        On dit qu’une classe A est fournisseur<\/strong> d’une classe B si un attribut ou une fonction de la classe B retourne un objet ou un ensemble d’objets de type A. En d’autres mots, un lien fournisseur est l’inverse d’un lien client.<\/p>\n
        \"\"<\/p>\n
        L’interface d’une classe<\/h2>\n
        On appelle interface<\/strong> d’une classe, l’ensemble des m\u00e9thodes et attributs accessibles \u00e0 un client de cette classe.<\/p>\n
        Un petit truc<\/h2>\n
        Pour savoir s’il est pr\u00e9f\u00e9rable de faire un lien d’h\u00e9ritage ou un lien client\/fournisseur entre deux classes, on peut utiliser le petit truc suivant:<\/p>\n