Utilizzare interfacce o classi astratte

[Ironmax]

Salve.
Mi sono appena imbattuto nello studio degli oggetti in php, volevo capire se quando si costruisce un'applicazione in OOP e meglio utilizzare le classi astratte oppure le interfacce come classi base per poi estederle alla classi "normali" cioè a quelle instanziabili.
Grazie.

[k.b]

Interfacce e classi astratte hanno punti in comune, ma non sono la stessa cosa, quindi l'unica vera risposta alla tua domanda e' "dipende".

[_debo]

Risposta alla tua domanda: dipende dal contesto in cui ti trovi e che cosa stai modellando e descrivendo, generalmente è sempre bene prediligere composition (interface) ad inheritance (abstract class) ma dipende dalla situazione.

Puntualizzazione sulla tua domanda: Le abstract class si estendono le interface si implementano il che determina un enorme differenza sostanziale.

[Ironmax]

Ho seguito la guida che c'è su questo medesimo sito:
http://php.html.it/guide/leggi/167/g...oggetti-php-5/
Dal capitolo 27 al capitolo 30 che modella un controllo sul form.
Praticamente parte da un'interfaccia che viene implementata nella classe astratta e che questa classe astratta viene data in eredità alla classe finale per poi essere istanziata.
Ho provato a cancellare l'implementazione dell'interfaccia nella classe astratta, ho fatto eseguire lo script ma funziona ugualmente.
Cioè mi domando allora cosa serve questa interfaccia se non dal punto di vista di un appunto di come dovrà essere modellata la classe finale.

[_debo]

Non so l'esempio nello specifico ma ti dico brevemente le differenze.

Una classe può estendere al massimo una sola altra classe o abstract class mentre una classe può implementare più interfaces.

Se definisci un metodo in un'abstract class non sei obbligato ad implementare tale metodo nella classe che la estende perché per inheritance la classe figlia può accedere al metodo del parent se opportunamente definito. In altre parole usando un abstract class il polimorfismo non è garantito. Se invece una classe implementa un interfaccia la classe che la implementa DEVE obbligatoriamente definire ed implementare i metodi descritti nell'interfaccia.

Chiaro? Se non è chiaro ti posso fare un breve esempio.

[Ironmax]

Chiaro? Se non è chiaro ti posso fare un breve esempio.

Si prova a farmi un esempio, almeno lo vedo in pratica.

[_debo]

Se il codice da solo non spiega abbastanza bene salva il tutto in un file tipo foobar.php e da riga di comando eseguilo: "php foobar.php" e vedi che cosa succede, tutto ti sarà in teoria più chiaro.

<?php
abstract class Animal {
    public function run()
    {
        echo "This animal is running...\n";
    }
}

class Horse extends Animal
{

}

class Bird extends Animal
{
    public function fly()
    {
        echo "This animal is flying\n";
    }
}

class Fish extends Animal
{
    public function run()
    {
        echo "This animal cannot run\n";
    }
}

$horse = new Horse();
$horse->run(); // Run is not defined but can be accessed for inheritance

$bird = new Bird();
$bird->fly();
$bird->run(); // Run is not defined but can be accessed for inheritance

$fish = new Fish();
$fish->run(); // the method has been overridden

interface running
{
    function run();
}

interface flying
{
    function fly();
}

interface swimming
{
    function swim();
}

class iHorse implements running
{
    public function run()
    {

    }
}

class iBird implements flying
{
    public function fly()
    {

    }
}

class iFish implements swimming
{
    public function swim()
    {

    }
}

class chimera implements running, flying, swimming
{
    public function run()
    {

    }

    public function fly()
    {

    }
}

$iHorse = new iHorse();
$iBird = new iBird();
$iFish = new iFish();
$chimera = new chimera();

[Ironmax]

Hai costruito una classe Animal abstract
con metodo run()
Poi l'hai estesa ad Horse, Bird, Fish.
Horse e senza metodo proprio ma accesso
al metodo della classe astratta.

Poi hai fatto un overridding sulla classe Fish
sempre sul metodo run() ridefinendolo.
Poi hai creato le interfacce con i loro metodi
però non ancora definiti, quindi solo dichiarati.

Poi hai costruito delle classi per ogni tipo
di animale implementando l'interfaccia per quel
tipo di animale con possibilità di definire il metodo
all'interno della classe.

Poi nella classe chimera hai implementato le
interfacce ridefinendo all'interno ogni loro metodo,
ma mancando di un metodo swim() che da fatal error.

Quindi necessita dell'implementazione del metodo
definito nell'interfaccia swimming che dovrà essere
ridefinito nella classe chimera.

Se poi ho capito bene hai creato la classe
chimera avendo un'eredità multipla di metodi che
dovranno obbligatoriamente essere implementati nella stessa.

Quindi l'interfaccia serve come guida alla costruzione di una
classe che deve obbligatoriamente implementare il metodo
della stessa interfaccia.

Ho solo ridefinito le classi per esempio:

<?php
abstract class Animal {
    public function run()
    {
        echo "This animal is running...1\n";
    }
}

class Horse extends Animal
{

}

class Bird extends Animal
{
    public function fly()
    {
        echo "This animal is flying...2\n";
    }
}

class Fish extends Animal
{
    public function run()
    {
        echo "This animal cannot run...3\n";
    }
}

$horse = new Horse();
$horse->run(); // Run is not defined but can be accessed for inheritance
echo "Horse";
echo"
";

$bird = new Bird();
$bird->fly();
$bird->run(); // Run is not defined but can be accessed for inheritance
echo "Bird";
echo"
";

$fish = new Fish();
$fish->run(); // the method has been overridden
echo "Fish";

interface running
{
    function run();
}

interface flying
{
    function fly();
}

interface swimming
{
    function swim();
}

class iHorse implements running
{
    public function run()
    {

    }
}

class iBird implements flying
{
    public function fly()
    {
	echo "vola poco ma vola, class iBird";
    }
}

class iFish implements swimming
{
    public function swim()
    {
	echo "Fish nuota, class iFish";
    }
}

class chimera implements running, flying, swimming
{
    public function run()
    {

    }

    public function fly()
    {
	
    }
	
	public function swim()
	{
		echo "Chimera nuota, class chimera";
	}
	
}

$iHorse = new iHorse();
$iBird = new iBird();
$iFish = new iFish();
$chimera = new chimera(); 

echo "
";
$iBird->fly();

echo "
";
$iFish->swim();

echo "
";
$chimera->swim();

Più o meno ci siamo?

Grazie.

[_debo]

Non mi è chiaro cosa tu abbia cambiato a parte i
il che mi fa pensare che non usi la command line per testare il tuo codice... mooooooooolto male... comunque si hai beccato il punto.

Per riassumere in poche parole un interface definisce uno specifico behaviour per la classe che la implementa. Se una classe implementa un interfaccia, la classe DEVE implementare il metodo. In PHP il polimorfismo è garantito solo con le interface proprio per questo motivo.

Con l'esempio di prima siccome sai che uno user DEVE per forza avere un metodo login usando un interface garantisci solidità e consistenza nel codice perché obblighi il developer ad implementare tale metodo senza via di fuga e maggior flessibilità per via della possibilità di implementare interfacce multiple.

Come però ti ho già detto l'utilizzo di interfaces potrebbe non essere la soluzione ideale specie inizialmente se non si ha tempo per fare un design adeguato, cosa già sbagliata di suo, perché se modifichi una sola interfaccia potresti ritrovarti a dover riscrivere discreti pezzi di applicazione.

[Ironmax]

Non mi è chiaro cosa tu abbia cambiato a parte i
il che mi fa pensare che non usi la command line per testare il tuo codice...

Scusa credo che non so cosa sia la command line , o almeno per questo caso se ha un significato in particolare.
Potresti darmi una definizione.
Grazie.