costruttori ed ereditarietà a + di un livello

[nik600]

ciao

se io ho delle classi di questo tipo:

class Modulo{

function __construct(){
echo "costruttore modulo";

}

}

class Anagrafica extends Modulo{

function __construct(){
echo "costruttore anagrafica";

}

}

class MiaAnagrafica extends Anagrafica{

function __construct(){
echo "costruttore mianagrafica";
}

} 

come posso dal costruttore di MiaAnagrafica chiamare il costruttore di Modulo, senza passare dal costruttore di Anagrafica?

è possibile?

ciao e grazie

[mark2x]

..ma non va contro i principi dell'ereditarietà?...

[nadras]

php non supporta l'eredità multipla, come in C++ o java. Non dovrebbe funzionare mai.

[andr3a]

Originariamente inviato da mark2x
..ma non va contro i principi dell'ereditarietà?...

no

Originariamente inviato da nadras
php non supporta l'eredità multipla, come in C++ o java. Non dovrebbe funzionare mai.

nemmeno Java supporta ereditarietà multipla ... passate tutti a Python



[edit]
m'ero dimenticato la soluzione

<?php
class Modulo{
	function __construct() {
		echo "costruttore modulo
";
	}
}

class Anagrafica extends Modulo {
	function __construct($parent = false) {
		if($parent)
			parent::__construct();
		else
			echo "costruttore anagrafica
";
	}
}

class MiaAnagrafica extends Anagrafica {
	function __construct(){
		parent::__construct(true);
		echo "costruttore mianagrafica";
	}
}

$a = new MiaAnagrafica();

// costruttore modulo
// costruttore mianagrafica
?>

[edit2] .. alternativa più "sicura" (evita di istanziare con booleani non desiderati anche nella classe "di mezzo")

class Modulo{
	protected $__parent = false;
	function __construct() {
		echo "costruttore modulo
";
	}
}

class Anagrafica extends Modulo {
	function __construct() {
		if($this->__parent)
			parent::__construct();
		else
			echo "costruttore anagrafica
";
	}
}

class MiaAnagrafica extends Anagrafica {
	function __construct(){
		$this->__parent = true;
		parent::__construct();
		echo "costruttore mianagrafica";
	}
}

$a = new MiaAnagrafica();

// costruttore modulo
// costruttore mianagrafica

[nik600]

ciao andr3a

grazie x le tue risposte

non avevo ancora visto la tua risposta e ho fatto una cosa di questo tipo:

class Modulo{
    function __construct() {
        echo "costruttore modulo
";
    }
    function __construct_manuale() {
        echo "costruttore modulo
";
    }
}

class Anagrafica extends Modulo {
    function __construct() {
            echo "costruttore anagrafica
";
    }
}

class MiaAnagrafica extends Anagrafica {
    function __construct(){
        parent::__construct_manuale();
    }
} 

cosa tene sembra di questa soluzione?

[andr3a]

Originariamente inviato da nik600
cosa tene sembra di questa soluzione?

non molto buona, per il semplice fatto che in quel modo usi semplicemente un metodo ereditato chiamato __construct_manuale della classe Anagrafica

in poche parole:

parent::__construct_manuale();
sulla terza classe richiama
Anagrafica::__construct_manuale();
ereditato da
Modulo


Il mio metodo invece ti fa usare il costruttore esatto della classe sopra l'ereditata ... per fare un esempio più completo e farti un'idea della portabilità della mia idea guarda questo codice:

<?php
class __A {
	protected $__parent = 0;
	function __construct() {
		echo "costruttore __A
";
	}
}

class __B extends __A {
	function __construct() {
		if(!(--$this->__parent)) {
			echo "costruttore __B
";
		}
		else
			parent::__construct();
	}
}

class __C extends __B {
	function __construct(){
		if(!(--$this->__parent)) {
			echo "costruttore __C
";
		}
		else
			parent::__construct();
	}
}

class __D extends __C {
	function __construct(){
		if(!(--$this->__parent)) {
			echo "costruttore __D
";
		}
		else
			parent::__construct();
		
	}
}

class __E extends __D {
	function __construct() {
		// quante classi sopra ?
                // 1 => __D, 2 => __C, 3 => __B, >= 4 => __A
		$this->__parent = 3;
		parent::__construct();
		echo "costruttore __E
";
	}
}

$e = new __E();
// costruttore __B
// costruttore __E
?>

come puoi notare, specificando quanti genitori sopra vai a usare proprio quel costruttore, senza intaccare o ereditare un metodo in più che rimarrebbe interno alla classe parent.


[edit]
ovviamente ha senso solo se vuoi poter gestire multi eredità dall' ultima classe, altrimenti non va bene per tutte le gerarchie e dovresti riadattare meglio l'idea


[edit2]
l'ereditarietà multipla è ritenuta abbastanza "rischiosa" ... non tanto per i linguaggi quanto per l'uso che ne fanno gli sviluppatori. Uno dei motivi principali per il quale non ha sempre senso è che potresti avere due genitori con metodi diversi ma con lo stesso nome e l'ambiguità di scelta potrebbe compromettere le funzionalità dell'erede ... questo ed altro hanno portato gli sviluppatori di tanti linguaggi, PHP compreso, a scegliere di non implementare una cosa tipo

class __C extends __B, __A

il discorso invece è diverso con le interfacce, sono sempre (o nella maggior parte) multiple poichè dichiarano un metodo, non il codice che tale metodo userà


[edit3] [a scanso di equivoci]
di solito l'eredità multipla si usa, nei linguaggi che lo permettono, con classi diverse, non con classi già eredi di super classi ... quindi tutto sommato questo caso non è nemmeno vera eredità multipla ma solo eredità "innestata"

[skidx]

io tendo sempre a pensare che se la struttura è troppo incasinata forse c'è qualcosa che non va, quindi valuta bene se quella gerarchia è la migliore per ciò che ti serve.

[nik600]

beh, non credo certo di spingermi oltre al terzo livello!

e comunque, come giustamente hai detto andr3a questa non è ereditarietà multipla

per farvi un esempio io ho adottato questa soluzione perchè dovevo gestire un modulo anagrafica con dei campi in +

facendo cosi ederito in automatico tutte le funzioni di ricerca, elenca, ecc ecc da anagrafica.. ho ridefinito ovviamente i metodi che inseriscono/modificano/eliminano considerando i campi differenti in MIAanagrafica ed il gioco è fatto!

[andr3a]

Originariamente inviato da skidx
io tendo sempre a pensare che se la struttura è troppo incasinata forse c'è qualcosa che non va, quindi valuta bene se quella gerarchia è la migliore per ciò che ti serve.

sono d'accordo ma l'ereditarietà a cascata (termine più idoneo per questo caso) non è sempre sinonimo di incasinato ... di sicuro il mio esempio è eccessivo

[skidx]

Originariamente inviato da andr3a
sono d'accordo ma l'ereditarietà a cascata (termine più idoneo per questo caso) non è sempre sinonimo di incasinato

no, certamente. Mi riferivo al fatto di dover saltare dei costruttori nella gerarchia. Magari esiste una gerarchizzazione un po' diversa che semplifica il tutto e rende inutile ricorrere a quell'espediente.