{"id":230484,"date":"2022-11-23T19:45:00","date_gmt":"2022-11-23T16:45:00","guid":{"rendered":"https:\/\/wordpress.mediadoma.com\/?p=230484"},"modified":"2022-11-23T19:54:55","modified_gmt":"2022-11-23T16:54:55","slug":"guardando-in-profondita-il-polimorfismo","status":"publish","type":"post","link":"https:\/\/wordpress.mediadoma.com\/it\/guardando-in-profondita-il-polimorfismo\/","title":{"rendered":"Guardando in profondit\u00e0 il polimorfismo"},"content":{"rendered":"\n

Quando ho iniziato questa serie, ho parlato dei quattro pilastri della programmazione orientata agli oggetti. Ciascuno di questi argomenti \u00e8 elencato e collegato di seguito.<\/p>\n

    \n
  1. Astrazione<\/a><\/strong><\/li>\n
  2. Incapsulamento<\/a><\/strong><\/li>\n
  3. Eredit\u00e0<\/a><\/strong><\/li>\n
  4. Polimorfismo<\/a><\/strong><\/li>\n<\/ol>\n

    A questo punto, normalmente vorrei iniziare a passare al prossimo argomento. Prima di farlo, per\u00f2, vorrei dedicare un altro post all’esplorazione del concetto di polimorfismo.<\/p>\n

    Nella mia carriera, finora, ho visto pochi argomenti dare a coloro che si avvicinano alla programmazione orientata agli oggetti pi\u00f9 confusione e problemi rispetto al polimorfismo. Quindi vorrei discuterne un po’ pi\u00f9 in profondit\u00e0 nel contesto della programmazione orientata agli oggetti e al di fuori di qualsiasi framework o applicazione particolare (come WordPress).<\/p>\n

    In questo post, far\u00f2 una rapida rassegna di ci\u00f2 di cui abbiamo discusso finora, quindi torner\u00f2 al polimorfismo.<\/p>\n

    Approfondimento sul polimorfismo<\/h2>\n

    Innanzitutto, come accennato, voglio rivedere rapidamente ci\u00f2 che \u00e8 stato discusso finora, soprattutto se hai sorvolato su uno qualsiasi dei post precedenti.<\/p>\n

    Non preoccuparti: niente di seguito divaga nel codice. Invece, definisce semplicemente i termini che abbiamo usato in modo da avere un’idea di ci\u00f2 a cui mi riferisco ogni volta che vedi la parola spuntare in questa serie.<\/p>\n

    Astrazione<\/h3>\n
    \n

    Astraiamo l’idea di qualcosa in una classe. Invece, astrarremo le idee nelle loro classi. E qui c’\u00e8 un’idea chiave: una classe dovrebbe rappresentare un sostantivo.<\/p>\n<\/blockquote>\n

    Incapsulamento<\/h3>\n
    \n

    Incapsulamento \u00e8 in realt\u00e0 solo una parola "grande" che si riferisce all’idea di gestire le proprie responsabilit\u00e0 (o tenere traccia dei propri dati).<\/p>\n<\/blockquote>\n

    Eredit\u00e0<\/h3>\n
    \n

    L’ereditariet\u00e0 si riferisce all’idea che una classe, sebbene abbia una propria implementazione, eredita letteralmente propriet\u00e0, funzioni e implementazione generale da una classe padre.<\/p>\n<\/blockquote>\n

    Polimorfismo<\/h3>\n
    \n

    Il polimorfismo ci consente di fare riferimento a una classe di un tipo quando pu\u00f2 essere dichiarata come un altro tipo.<\/p>\n<\/blockquote>\n

    Detto questo, \u00e8 qui che penso che le cose possano diventare un po’ pi\u00f9 complicate. Nei post precedenti, ho fornito una serie di esempi di codice diversi (e ti esorto a guardarli indietro).<\/p>\n

    Ma nel post di oggi, cercher\u00f2 di esplorare un po’ pi\u00f9 a fondo l’idea sia nella spiegazione che nel codice.<\/p>\n

    Relativo all’eredit\u00e0<\/h2>\n

    Se non \u00e8 evidente a questo punto, il polimorfismo \u00e8 fortemente correlato all’ereditariet\u00e0. Pensala in questo modo: se una classe eredita propriet\u00e0 e metodi da un’altra classe, pu\u00f2 "stare al posto" della classe genitore.<\/p>\n

    Ci\u00f2 significa che se hai qualcosa come una\u00a0 classe Content<\/strong> e poi hai due sottoclassi, una che \u00e8 un Post<\/strong> e l’altra che \u00e8 una Pagina<\/strong>, puoi creare un’istanza della classe usando il\u00a0 tipo di riferimento del contenuto.t<\/strong><\/p>\n

    Ma in fase di esecuzione, sar\u00e0 effettivamente un’istanza del\u00a0 tipo Post<\/strong>. Ha senso? Ecco del codice come esempio.<\/p>\n

    Innanzitutto, inizieremo con la definizione di una\u00a0 classe Content<\/a> :<\/p>\n

    <?php\nclass Content {\n\n   protected $title;\n\n   protected $content;\n\n   protected $metadata;\n\n   public function __construct()\n   {\n     $this->title = \"Hello World!\";\n     $this->content = \"This is a sample piece of content.\";\n     $this->metadata = \"<This is the metadata of the post.>\";\n   }\n\n   public function getTitle()\n   {\n     return $this->title;\n   }\n\n   public function getContent()\n   {\n     return $this->content;\n   }\n\n   public function getMetadata()\n   {\n     return $this->metadata;\n   }\n }\n<\/code><\/pre>\n
    Ha le propriet\u00e0 generali che probabilmente ti aspetteresti: titolo, contenuto e metadati. Certo, queste propriet\u00e0 sono solo stringhe ma potrebbero essere strutture di dati pi\u00f9 elaborate in una situazione del mondo reale.<\/p>\n
    Ora diamo un’occhiata a un post<\/strong> :<\/p>\n
    <?php\n\nclass Post extends Content  {\n\n   private $author;\n\n   public function __construct() {\n     parent::__construct();\n     $this->author = \"Tom McFarlin\";\n   }\n\n   public function getAuthor()\n   {\n     return $this->author;\n   }\n }\n<\/code><\/pre>\n
    Cosa succede, quindi, se chiami un metodo sulla\u00a0 classe Post<\/strong>, come getTitle<\/strong>, che non esiste ma esiste nella\u00a0 classe Content<\/strong>? Quindi, a causa dell’ereditariet\u00e0, cercher\u00e0 il metodo in Post<\/strong>, non lo trover\u00e0, quindi inizier\u00e0 a cercarlo in Content<\/strong>.<\/p>\n
    Se viene trovato, lo eseguir\u00e0.<\/p>\n
    \"Guardando<\/a><\/p>\n
    Allo stesso modo, possiamo fare qualcosa del genere con la classe Page e i dati del contenuto.<\/a> Innanzitutto, istanziamo la classe base, quindi impostiamo propriet\u00e0 specifiche per Page<\/strong>. In questo caso, sar\u00e0 una categoria.<\/p>\n
    <?php\n\nclass Page extends Content  {\n\n   private $category;\n\n   public function __construct() {\n     parent::__construct();\n     $this->category = \"Articles\";\n   }\n\n   public function getCategory()\n   {\n     return $this->category;\n   }\n }\n<\/code><\/pre>\n
    Ora, quando eseguiamo il codice, possiamo iniziare con il contenuto:<\/strong><\/p>\n
    <?php\n\n$content = new Content();\necho $content->getTitle();<\/code><\/pre>\n
    Nota che questo sembra che ci aspetteremmo dal momento che abbiamo un titolo e abbiamo contenuto. Diamo un’occhiata anche al Post<\/strong> :<\/p>\n
    <?php\n\n\/\/ These will work because they reside in the Content base class.\n$post = new Post();\necho $post->getAuthor();\necho $post->getTitle();<\/code><\/pre>\n
    Funziona perch\u00e9 abbiamo un autore, ma abbiamo anche un titolo perch\u00e9 risiede in Contenuto<\/strong>. Ma se proviamo a chiamare getAuthor<\/strong> su un’istanza di Post?<\/strong><\/p>\n
    <?php\n\n\/\/ These will work because they reside in the Content base class.\n$post = new Post();\necho $post->getAuthor();\necho $post->getTitle();<\/code><\/pre>\n
    Otterremo un errore perch\u00e9 il metodo non risiede in quella classe.<\/p>\n
    \"Guardando<\/a><\/p>\n
    Allora cosa dobbiamo fare? Dal momento che non abbiamo tipi forti in PHP, non possiamo eseguirne il cast su un tipo diverso.<\/p>\n
    Ci sono modelli di progettazione per questo, di cui parler\u00f2 in una serie di post futuri, ma PHP non lo consente facilmente come alcuni altri linguaggi (come C# o Java).<\/p>\n
    Domande sul polimorfismo<\/h2>\n
    Si spera che il codice precedente ti dia un’idea di come un tipo concreto come un Post\u00a0<\/strong> o una Pagina<\/strong> pu\u00f2 avere implicitamente le propriet\u00e0 e i metodi della sua classe base, Content<\/strong>, usata in fase di esecuzione.<\/p>\n
    Ma solleva anche alcune domande, no? Per esempio:<\/p>\n