OOP - INTERFACE - Chiarimenti

[hypertextPro]

Ciao a tutti, avrei bisogno di qualcuno che mi aiuti a capire l'utilizzo di 'interface' nella creazione di una classe in php.

Io, ad esempio, ho dichiarato una classe interfaccia con questi metodi, che a quanto ho capito devono esse dichiarati o quanto meno implementati nella classe che dichiaro implementata:

interface testInterface{

public function getMese();
public function getIdUtenteSessione();        
public function getTemporanyUserTable();        
public function getTemporanyUserTimeJobTable();       
 public function getTemporanyUserErrorTable();

} 

In seguito dichiaro una classe così:

class strumentoRiepilogo implements testInterface{#-----------------------------------------------------------------------------PROPERTY-----------------------------------------------------------------------------------------------------------------    
    private static $nomeClasse = "strumentoRiepilogo";        
protected static $IdUtenteSessione = "No";       
 protected static $Mese = 0;                    
protected static $temporanyUserTable = "temporany_table_";       
 protected static $temporanyUserTimeJobTable = "temporany_timejob_";            
protected static $temporanyUserErrorTable = "temporany_error_";                
        private $globalError = "??";
#-----------------------------------------------------------------------------END PROPERTY-------------------------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------get METHOD--------------------------------------------------------------------------------------------------------------

    public function getMese(){        return self::$Mese;    }       
 public function getIdUtenteSessione(){        return self::$IdUtenteSessione;    }       
 public function getTemporanyUserTable(){        return self::$temporanyUserTable;    }      
  public function getTemporanyUserTimeJobTable(){        return self::$temporanyUserTimeJobTable;    }       
 public function getTemporanyUserErrorTable(){        return self::$temporanyUserErrorTable;    }  


  #------------------------------------------------------------------------------END get METHOD----------------------------------------------------------------------------------------------------------


ecc ecc ecc.... 

In questo caso io ho dichiarato i metodi get PUBBLICI nella classe interfaccia. Se poi dopo nella classe implementata cerco di cambiare il tipo di accesso al metodo, ad esempio lo dichiaro PRIVATE, ,mi restituisce un errore fatale.

Ho notato, inoltre, che se dichiaro, nella classe interfaccia, direttamente i metodi come privati o protetti mi restituisce l'errore fatale nella classe interfaccia.

A questo punto mi viene da chiedere qual'è utilizzo ottimale per utilizzare INTERFACE di php.

[Alhazred]

L'utilizzo è quello di dichiarare pubblici i metodi della classe interfaccia e della classe che la implementa.
I metodi dell'interfaccia sono metodi che devono essere disponibili dall'istanza della classe che la implementa.

[Santino83_02]

l'interfaccia è un contratto con l'utente/programmatore e tutte le classi, che implementano tale interfaccia, garantiscono di rispettare, quindi tutti i metodi di una interfaccia sono public, anzi il modificatore di visibilità dei metodi è opzionale (mi pare anche in php, ma di certo è solo public). Le classi che implementano l'interfaccia non possono alterare il contratto stipulato, quindi non possono modificare la segnatura dei metodi che implementano nè la visibilità di tali metodi, al limite possono dichiararne l'implementazione "abstract", diventando quindi classi astratte che devono essere estese da altre classi che concretizzino l'astrazione

L'uso di un'interfaccia consente di disaccopiare l'uso della medesima dall'effettiva implementazione di tale interfaccia. Ad esempio, mettiamo di avere un'interfaccia "UserRepository" con metodo "getUsers()" che torna una lista di utenti, potremmo quindi avere due implementazioni di tale interfaccia, una DatabaseUserRepository che utilizza un database, e una XmlUserRepository che legge da un file xml. A questo punto potremmo creare una classe UserManager che utilizza una "UserRepository" per caricare gli utenti: in fase di configurazione della classe UserManager si può passare da un'implementazione all'altra di UserRepository senza constringere UserManager a dipendere dalla concreta implementazione nè a fare assunzioni di alcun tipo.