[Programmazione OO] Chiarimento su uso di Interfaccie e Classi Astratte

[e-commerce84]

Ciao,
vorrei chiedervi un chiarimento circa l'uso combinato di interfaccie e classi astratte e della relativa buona progettazione di un'applicazione in una situazione tipo questa.

Allora...ho un interfaccia che mi rappresenta i metodi pubblici comuni a 2 classi che la implementano (appunto l'interfaccia con l'esterno di tali classi) e poi ho le due classi Classe1 e Classe2 che implementano tale interfaccia, implementando in modo diverso i metodi pubblici dichiarati nell'interfaccia.

Una cosa del genere (l'esempio è scritto in pseudo PHP ma credo che il linguaggio sia indifferente...):

<?php

interface Interfaccia{
    public function metodoPubblico1();
    public function metodoPubblico2();
    public function metodoPubblico3();
}

class Classe1 implements Interfaccia{
    
    // PROPRIETÀ COMUNI A TUTTE LE IMPLEMENTAZIONI DI Interfaccia:
    private $a = 10;
    private $b = 20;
    
    // PROPRIETÀ SPECIFICA PER L'IMPLEMENTAZIONE Classe1:
    private $c = "classe1";
    
    private metodoAusiliario1(){
        // CORPO METODO
    }
    
    private metodoAusiliario2(){
        // CORPO METODO
    }
    
    /* IMPLEMENTAZIONE DEI METODI PUBBLICI PER Classe1 
     * DICHIARATI NELL'INTERFACCIA: */
     public function metodoPubblico1(){
         // CORPO METODO
     }
     
     public function metodoPubblico2(){
         // CORPO METODO
     }
     
     public function metodoPubblico3(){
         // CORPO METODO
     }
       
}

class Classe2 implements Interfaccia{
    
    // PROPRIETÀ COMUNI A TUTTE LE IMPLEMENTAZIONI DI Interfaccia:
    private $a = 10;
    private $b = 20;
    
    // PROPRIETÀ SPECIFICA PER L'IMPLEMENTAZIONE Classe2:
    private $c = "classe2";
    
    private metodoAusiliario1(){
        // CORPO METODO
    }
    
    private metodoAusiliario2(){
        // CORPO METODO
    }
    
    /* IMPLEMENTAZIONE DEI METODI PUBBLICI PER Classe2 
     * DICHIARATI NELL'INTERFACCIA: */
     public function metodoPubblico1(){
         // CORPO METODO
     }
     
     public function metodoPubblico2(){
         // CORPO METODO
     }
     
     public function metodoPubblico3(){
         // CORPO METODO
     }
       
}

?>

Bene...se ora le 2 implementazioni dell'interfaccia Classe1 e Classe2 contengono al loro interno 2 proprietà comuni ($a e $b) e 2 metodi privati esattamente uguali come implementazione (metodoAusiliario1() e metodoAusiliario2() che magari sono usati nel corpo dei metodi pubblici)

Può essere una cosa intelligente (di buona progettazione fare una cosa del genere).

Mantengo l'interfaccia, creo una nuova classe astratta che chiamo ComportamentoComune che contiene semplicemente le 2 proprietà comuni ($a e $b) ed i vecchi metodi privati che hanno la stessa implementazione in Classe1 e Classe2...solo che...ora invece di essere privati li dichiaro come protected. Tale classe astratta implementa l'interfaccia.
Infine creo Classe1 e Classe2 che estendono la classe astratta ComportamentoComune implementando di fatto solo i metodi pubblici dichiarati nell'interfaccia, le proprietà specifiche ed eventuali specifici metodi private per quella particolare implementazione...
L'esempio di prima diventerebbe una cosa del genere insomma:

<?php

interface Interfaccia{
    public function metodoPubblico1();
    public function metodoPubblico2();
    public function metodoPubblico3();
}

abstract class ComportamentoComune implements Interfaccia{
    
    // PROPRIETÀ COMUNI A TUTTE LE IMPLEMENTAZIONI DELL'INTERFACCIA:
    protected $a = 10;
    protected $b = 10;
    
    // METODI AUSILIARI COMUNI A TUTTE LE IMPLEMENTAZIONI DELL'INTERFACCIA:
    private metodoAusiliario1(){
        // CORPO METODO
    }
    
    private metodoAusiliario2(){
        // CORPO METODO
    }
}

class Classe1 extends CompostamentoComune{
    // PROPRIETÀ SPECIFICA PER L'IMPLEMENTAZIONE Classe1:
    private $c = "classe1";
    
    /* IMPLEMENTAZIONE DEI METODI PUBBLICI PER Classe1 
     * DICHIARATI NELL'INTERFACCIA: */
     public function metodoPubblico1(){
         // CORPO METODO
     }
     
     public function metodoPubblico2(){
         // CORPO METODO
     }
     
     public function metodoPubblico3(){
         // CORPO METODO
     }
}

class Classe2 extends CompostamentoComune{
    // PROPRIETÀ SPECIFICA PER L'IMPLEMENTAZIONE Classe2:
    private $c = "classe2";
    
    /* IMPLEMENTAZIONE DEI METODI PUBBLICI PER Classe2 
     * DICHIARATI NELL'INTERFACCIA: */
     public function metodoPubblico1(){
         // CORPO METODO
     }
     
     public function metodoPubblico2(){
         // CORPO METODO
     }
     
     public function metodoPubblico3(){
         // CORPO METODO
     }
}

?>

In pratica ho aggiunto un nodo nella gerarchia delle classi che mi rappresenta i comportamenti comuni a tutte le possibili implementazioni dell'interfaccia così da non dover ridichiarare tutte le volte delle proprietà sicuramente comuni ed alcuni metodi aventi la stessa implementazione in tutte le classi che implementano l'interfaccia...può essere una cosa intelligente tale metodologia?

Grazie

[PGI-Bis]

Qui la questione non è tanto di orientamento agli oggetti quanto di comunicazione.

In generale evitare ripetizioni nel codice di un programma è corretto nello stesso senso in cui è corretto farlo nella comunicazione in linguaggi naturali.

La ripetizione è un errore, evitarla non è "intelligente" o "buona progettazione" ma semplicemente corretto.

Dunque la prima implementazione è sbagliata - perchè conduce ad una ripetizione - la seconda è corretta - perchè non comporta quella ripetizione.

[banryu79]

Beh, direi di sì: certo sei tu che giudichi se il gioco vale la candela, nel contesto della soluzione che stai implementando.

Nel forum c'è una vecchia discussione circa le classi astratte e la loro semantica nel contesto della programmazione orientata agli oggetti; non so se l'hai già letta, te la linko: [C++] Quando usare una classe astratta ?