b'\n_START_ARTICLE_\nComposizione al posto dell\'ereditariet\xc3\xa0\n_START_SECTION_\nLe basi\n_START_PARAGRAPH_\nUn\'implementazione di composizione al posto dell\'ereditariet\xc3\xa0 di solito inizia con la creazione di diverse interfacce che rappresentano i comportamenti che il sistema deve esibire. L\'uso di interfacce permette a questa tecnica di supportare il comportamento polimorfico che \xc3\xa8 cos\xc3\xac importante nella programmazione orientata agli oggetti. Le classi che implementano le interfacce identificate sono sviluppate e aggiunte alle classi del dominio di applicazione secondo necessit\xc3\xa0. Cos\xc3\xac, i comportamenti del sistema sono realizzati senza l\'ereditariet\xc3\xa0. In realt\xc3\xa0, le classi del dominio di applicazione possono essere tutte classi base, senza alcuna ereditariet\xc3\xa0. L\'implementazione alternativa dei comportamenti del sistema si realizza fornendo un\'altra classe che implementa l\'interfaccia col comportamento desiderato. Ogni classe del dominio di applicazione che contiene un riferimento all\'interfaccia pu\xc3\xb2 supportare facilmente qualsiasi implementazione di tale interfaccia e la scelta pu\xc3\xb2 anche essere ritardata fino al tempo di esecuzione.\n_START_SECTION_\nEreditariet\xc3\xa0\n_START_PARAGRAPH_\nQuello che segue \xc3\xa8 un esempio in C++11:_NEWLINE_class GameObject {_NEWLINE_    public:_NEWLINE_        virtual ~GameObject() {}_NEWLINE_        virtual void update() {}_NEWLINE_        virtual void draw() {}_NEWLINE_        virtual void collide(GameObject objects[]) {}};class Visible : public GameObject {_NEWLINE_    public:_NEWLINE_        void draw() override { /* draw model at position of this object */ };_NEWLINE_    private:_NEWLINE_        Model* model;};class Solid : public GameObject {_NEWLINE_    public:_NEWLINE_        void collide(GameObject objects[]) override { /* check and react to collisions with objects */ };};class Movable : public GameObject {_NEWLINE_    public:_NEWLINE_        void update() override { /* update position */ };};\n_START_SECTION_\nVantaggi\n_START_PARAGRAPH_\nFavorire la composizione al posto dell\'ereditariet\xc3\xa0 \xc3\xa8 un principio di progettazione che offre al progettista maggiore flessibilit\xc3\xa0, realizzando nel lungo termine le classi del dominio di applicazione e un dominio di applicazione pi\xc3\xb9 stabile. In altre parole, una relazione del tipo "HA-UN" pu\xc3\xb2 essere migliore di una del tipo "\xc3\x88-UN"._NEWLINE_La progettazione iniziale \xc3\xa8 semplificata identificando i comportamenti del sistema nelle interfacce separate invece di creare una relazione gerarchica per distribuire i comportamenti tra le classi del dominio di applicazione con l\'ereditariet\xc3\xa0. Questo approccio pu\xc3\xb2 ospitare pi\xc3\xb9 facilmente futuri cambiamenti dei requisiti che altrimenti richiederebbero una ristrutturazione completa delle classi del dominio di applicazione nel modello di ereditariet\xc3\xa0. Inoltre, evita problemi spesso associati con modifiche relativamente minori ad un modello basato dell\'ereditariet\xc3\xa0 che comprende diverse generazioni di classi.\n_START_SECTION_\nSvantaggi\n_START_PARAGRAPH_\nUno svantaggio nell\'uso della composizione al posto dell\'ereditariet\xc3\xa0 \xc3\xa8 che tutti i metodi essendo forniti dalle classi composte devono essere implementati nella classe derivata, anche se ci sono solo metodi di inoltro. Al contrario, l\'ereditariet\xc3\xa0 non richiede che tutti i metodi di una classe base devono essere ri-implementati all\'interno della classe derivata. Piuttosto, la classe derivata necessita solo di implementare (override) i metodi che hanno un comportamento differente rispetto ai metodi della classe base. Questo pu\xc3\xb2 richiedere significativamente meno sforzo di programmazione se la classe base contiene molti metodi che forniscono un comportamento predefinito e solo pochi di loro necessitano di essere sovrascritti all\'interno della classe derivata._NEWLINE_Questo inconveniente pu\xc3\xb2 essere evitato utilizzando trait o mixin. Alcuni linguaggi, come Perl 6, forniscono una parola chiave di gestione per facilitare l\'inoltro dei metodi. In Java, il progetto Lombok consente di implementare la delega utilizzando un\'unica annotazione @Delegate sul campo invece di copiare e mantenere i nomi ed i tipi di tutti i metodi dal campo delegato.'