classi: eredità multipla

[andreamk]

Originariamente inviato da dogeht
AGGIUNGO QUESTO:

un commento sulla documentazione di php mi ha fatto riflettere. diceva piu' o meno "un linguaggio ha molti strumenti per farti raggiungere l'obiettivo. se non riesci a raggiungere un obiettivo con uno strumento, prova a cambiare strumento. se tenti di usare diversamente lo strumento, sei sulla strada sbagliata"

insomma: si vede che non devo usare due classi tipo. ma che posso fare allora?
per ora ho adottato questa soluzione:
1) ho creato le classi tipo
2) le istanze delle classi operative hanno delle proprietà che sono istanze delle classi tipo.

percui operativa 3 avrà due proprietà-istanza delle classi tipo1 e tipo2. ma ci sono delle complicazioni che vi lascio immaginare

Sperando di aver capito bene ho provato a implementare un approccio diverso al tuo problema.
Volevo fare un esempio semplice poi mi sono messo a leggere le funzioni di reflection e ho voluto provarle.
Il tuo esempio aveva un problema di fondo anche se ci fosse stata l'eritarieta' multipla hai chiamato due proprieta' con lo stesso nome nelle due classi tipo e come avresti gestito questa cosa nelle classi figlie di entrambi ?.

prima definisco in una clase astratta i metodi di gestione dei tipi

abstract class AbsTipo {
   private $numProp = 0;
   private $listProp = array();
   
   public function __construct ($str) {
          $reflect = new ReflectionClass($str);

          $list = $reflect->getProperties();
          $this->numProp = count ($list);
          foreach ($list as $prop) {
               $this->listProp[] = $prop->getName();
          }
   }
   public function issetTipo($str) {
       return isSet($this->$str);
   }
   public function getTipo($str) {
      if ($this->isSetTipo($str)) {
          return $this->$str;
      }  else {
          return null;
      }
   }
   public function numTipi() {
          return $this->numProp;
   }
   public function listaTipi() {
      return $this->listProp;
   }
} 

cosi estendendo questa classe posso implementare i tipi in modo molto semplice.

class tipo1 extends AbsTipo {
   public function __construct() {
          parent::__construct(__CLASS__);
   }
   protected $prop1 = 'pippo';
   protected $prop2 = 10;
}

class tipo2 extends AbsTipo {
   public function __construct () {
          parent::__construct(__CLASS__);
   }
   protected $prop1 = 'pippo2';
   protected $prop3 = 100;
} 

A questo punto posso implementare le classi logiche gestendo i tipi
come meglio credo

interface interOper {
          public function evalTipi();
}

class operativa1 implements interOper {
      private $tipo = null;
      public function __construct() {
             $this->tipo = new tipo1();
      }
      public function evalTipi() {
             $output = array();
             foreach ($this->tipo->listaTipi() as $key)   {
                     $output[$key] =  $this->tipo->getTipo($key);
             }
             return $output;
      }
}

class operativa2 implements interOper {
      private $tipi = array();
      public function __construct() {
             $this->tipi[] = new tipo1();
             $this->tipi[] = new tipo2();
      }
      public function evalTipi() {
             $output = array();
             foreach ($this->tipi as $tipo) {
                     foreach ($tipo->listaTipi() as $key)   {
                             if (!isset($output[$key]))  { // da notare che posso gestire il nome di proprieta' uguali come meglio credo
                             $output[$key] =  $tipo->getTipo($key);
                             }
                     }
             }
             return $output;
      }
} 

Per finire istanzio tutto

$operativa = new operativa1();
var_dump($operativa->evalTipi());

echo "

\n\n";
$operativa = new operativa2();
var_dump($operativa->evalTipi()); 

Spero di esserti stato utile.


Andrea