astrarre due classi fondendole in una

[oronze]

Ciao ragazzi, scusate per il titolo ma non riesco a trovarne uno migliore...in pratica io ho due classi con gli stessi metodi ma funzionalità diverse....un esempio banale?

class A implements Lettera{
public function stampa(){ echo "A"; }
}
class B implements Lettera{
public function stampa(){ echo "B"; }
}

e vorrei creare una classe "genitore" di queste due che in base a che figlio io scelga mi richiami il metodo stampa() corretto...qualcosa tipo

class Alfabeto{
public function Alfabeto(Lettera $nomeLettera){
return new $nomeLettera();
}
}

$letteraScelta = new Alfabeto('A');
$letteraScelta->stampa();

Potrebbe andar bene oppure esiste un design pattern che strutturi meglio questa mia esigenza?

[philbert]

usa l'ereditarietà attraverso EXTENDS (http://it.php.net/manual/en/keyword.extends.php)
qualcosa tipo:

abstract class Alfabeto
{
    abstract protected function getLettera();//la dichiari abstract per forzarne la istanziazione
   
    public function stampa() {
        echo $this->getLettera();
    }
}

class Lettera_A extends Alfabeto
{
    protected function getLettera() {
        return "A";
    }
}

class Lettera_B extends Alfabeto
{
    public function getLettera() {
        return "B";
    }


} 

Esempio di utilizzo:

$class1 = new Lettera_A;
$class2 = new Lettera_B;

$class1->stampa();
$class2->stampa();
//output:
//AB 

[oronze]

ti ringrazio moltissimo per l'aiuto anche se è la soluzione che avrei da sempre adottato...sto lavorando per farmi dare l'autorizzazione alla modifica di A e B ma senza molto successo
il problema è che se non posso modificare A e B, il mio sistema farebbe tanto schifo?

[philbert]

Originariamente inviato da oronze
ti ringrazio moltissimo per l'aiuto anche se è la soluzione che avrei da sempre adottato...sto lavorando per farmi dare l'autorizzazione alla modifica di A e B ma senza molto successo
il problema è che se non posso modificare A e B, il mio sistema farebbe tanto schifo?

scusa ma non capisco neppure di cosa stai parlando..... "farmi dare l'autorizzazione alla modifica di A e B"....."se non posso modificare A e B"....

sei per caso dei servizi segreti??
io credevo si trattasse di un esempio di programma che stavi scrivendo!

[oronze]

Originariamente inviato da philbert
scusa ma non capisco neppure di cosa stai parlando..... "farmi dare l'autorizzazione alla modifica di A e B"....."se non posso modificare A e B"....

sei per caso dei servizi segreti??
io credevo si trattasse di un esempio di programma che stavi scrivendo!

ahahaha ma magari! stavo aiutando un mezzo amico con un framework che sta creando con altri e di cui non è proprietario e ha detto che certe cose le deve ottimizzare ma non ha le "autorizzazioni" per modificare le classi...gli ho detto che se entro domani non si fa avere tali autorizzazioni non posso ottimizzare nulla e mando tutti a quel paese....vabbè ma ora andiamo OT e discuteremmo dell'incompetenza di certa gente

[satifal]

<?php
interface Lettera {
    public function stampa();
}

class A implements Lettera {
    public function stampa() {
        echo "A";
    }
}

class B implements Lettera {
    public function stampa() {
        echo "B";
    }
}

class L {
    private $l;

    function __construct(Lettera $l) {
        $this->l = $l;
    }

    public function stampa() {
        $this->l->stampa();
    }
}

$a = new A();
$b = new B();
$lettera = new L($a);
$lettera->stampa();
$lettera = new L($b);
$lettera->stampa();
?>

[Santino83_02]

l'idea di oronze era giusta ma scritta male, quella di philbert direi che sia scritta giusta ma logicamente errata, nel senso:

si può pensare che l'alfabeto sia un insieme di lettere, quindi le lettere non sono una estensione dell'alfabeto, ma un oggetto che alfabeto possiede per comporsi. Quindi la soluzione sarebbe stata

class Alfabeto{

private $data = array();

public function __construct(){
$this->data[] = new A();
$this->data[] = new B();
//etc...
}

public function elenco(){
foreach($this->data as $lettera)
echo $lettera->stampa();
}

public function add(Lettera $lettera){
$this->data[] = $lettera;
}

}


interface Lettera { 
    public function stampa(); 
} 

class A implements Lettera { 
    public function stampa() { 
        echo "A"; 
    } 
} 

class B implements Lettera { 
    public function stampa() { 
        echo "B"; 
    } 
} 

notare la funzione Alfabeto::add : l'uso dell'interfaccia delle lettera permette di essere sicuri che l'oggetto passato ad alfabeto sia conosciuto come tipo, ma non specificato nel sottotipo, che non interessa al programma..altrimenti per ogni A,B,..Z avresti dovuto fare un metodo addX col tipo di classe specifico (questo a far i pignoli in oop)

dire che una lettera è un'estensione dell'alfabeto... sinceramente non l'ho capita, non riesco a farne un esempio. E' cmq buona norma evitare, se non strettamente necessario, di far estendere classi se si può utilizzare invece un'interfaccia: se tu estendi una classe, non potrai estenderne un'altra, se tu implementi un'interfaccia, ne potrai sempre implementare altre e volendo estendere una classe

puoi pure pensare ad una soluzione:

abstract class Lettera{

  abstract protected function getLettera();

  public function stampa(){
   echo $this->getLettera();
}

}

class A extends Lettera{
protected function getLettera(){ return 'A'; }
}

class B extends Lettera{
protected function getLettera(){ return 'B'; }
}


class Alfabeto{

private $lettere = array();

public function add(Lettera $lettera){
$this->lettere[] = $lettera;
}

public function elenco(){
foreach($this->$lettere as $lettera)
echo $lettera->stampa();
}

}

$alfabeto = new Alfabeto();
$alfabeto->add(new A());
$alfabeto->add(new B());
$alfabeto->elenco(); 

tutto sta nel capire Lettera,A,B,Alfabeto cosa debbano effettivamente essere e cosa debbano effettivamente fare, visto che non c'è il pattern giusto a priori