Newsgroup: it.comp.java
Titolo: Una banale questione di ereditarietà.

Buon giorno...
sto "migrando" dal fortran e c a java. Ho un manuale abbastanza
ben scritto, e sono riuscito a seguire bene tutti gli argomenti trattati
fino all'incapsulamento. All'ereditarietà mi sono bloccato. C'e' una cosa
che mi sfugge: anche i metodi vengono ereditati, giusto?
Allora non capisco perche' se chiamo
[CUT]
        quadrato poli = new quadrato(lati);
        poli.perimetro();
...mi da zero (nel debug, sembra che numerolai sia nullo)
mentre se chiamo 
        poli.perimetro2();
...mi da il risultato corretto.
Infine non capisco perche', se chiamo:
       quadrato poli = new quadrato(lati);
        poli.numerolati=4;
        poli.perimetro();
funziona. Mentre non è necessario farlo per l'array lati?
Cioe' nel costruttore quadrato, laddove definisco
this.numerolati=4
this.lati=lati
lati lo accetta, e numerolati no?
Dove sbaglio?
Grazie e buona settimana.....
Ale
 class poligono {
    int numerolati;
    double[] lati;
    public int getnum() 
    {
        return numerolati;
    }
 
    public double perimetro(){
        double sum=0;
        for (int i=0; i<numerolati; i++){
            sum=sum+lati[i];   
        }
        return sum;
    }
}
//------------------------------------------
class quadrato extends poligono{
    int numerolati = 4;
    public quadrato (double lati[])
    {
        this.numerolati=4;
        this.lati=lati;
        System.out.println("allora::"+this.numerolati);
    }
    public double perimetro2(){
        double sum=0;
        for (int i=0; i<numerolati; i++){
            sum=sum+lati[i];   
        }
        return sum;
    }
}
//------------------------------------------
//------------------------------------------

 
-- 
chi sono e soprattutto chi non sono:
http://www.ilnomedeldominio.it
un piccolo programma per studenti universitari:
http://inutility.ilnomedeldominio.it

 funziona.
questo non lo so.
probabilmente con poli.numerolati=4 ridefinisci entrambi i membri, sia 
quello della classe estesa che quello della classe base.

Non potevi aspettarti diversamente.
Nella classe poligono ridefinisci la variabile numerolati e la inizializzi
nel suo costruttore
poi fai riferimento a this.lati??? ma questa non è definita in quadrato
questo dovrebbe funzionare
  class poligono {
     int numerolati;  // gli attributi è consigliabile renderli private
     double[] lati;
     public poligono(double[] lati) {
       this.lati = lati;
       this.numerolati = lati.length;
     }
     public int getnum()
     {
         return numerolati;
     }
     public double perimetro(){
         double sum=0;
         for (int i=0; i<numerolati; i++){
             sum=sum+lati[i];
         }
         return sum;
     }
 }
class quadrato extends poligono{
     public quadrato (double lati[])
// quando si ridefinisce un costruttore è sempre
// buona norma chiamare come prima istruzione super(...);
// per evitare che ci siano attributi null
     {
       super(lati);
     }
     public double perimetro(){
         return super.lati[0] * 4;  // interrompe l'incapsulamento,
sconsigliato
     }
}
la soluzione che ti ho scritto è un esempio di cattiva programmazione
1) i membri di una classe è consigliabili renderli privati;
tu addirittura nel main hai scritto "poli.numerolati = 4;" stai
interrompendo l'incapsulamento
2) la super classe o classe padre deve racchiudere tutte le caratteristiche
comuni, le classi derivate devono specializzare la classe padre.
Comunque l'esempio preso da te in considerazione non calza molto bene per
spiegare l'ereditarietà; perchè il perimetro di un poligono è sempre la
somma dei lati, io l'ho ridefinito nel quadrato giusto per efficienza ma non
era indispensabile.
Sarebbe stato meglio dichiarare poligono astratta ed aggiungerci un metodo
astratto come calcoloArea che almeno cambia da poligono a poligono
o soluzione migliore
potresti definire un interfaccia poligono ed elencare i metodi che questa
deve contenere ad es.
calcoloPerimetro
getLati
calcoloArea
disegna
setLati
e poi dichiarare classi che implementano tale interfaccia e definiscono i
metodi di sopra
morale della favola
l'ereditarietà è uno strumento potentissimo e indispensabile, ma allo stesso
tempo nasconde molte insidie e richiede uno studio meticoloso non solo dei
costrutti e delle regole, ma anche di riuscire a capire quando è il momento
giusto di raccogliere aspetti comuni di un insieme di classi e creare una
classe padre che li definisce una volta per tutte
ciao gigabyte
"sandrokan" <mu...@Xifsi.Xrm.Xcnr.Xit> ha scritto nel messaggio
news:c5g6rg$f3i$1...@canarie.caspur.it...


 
Grazie tante, era quello. 
Ciao
ale

 Nella classe poligono ridefinisci la variabile numerolati e la inizializzi
[CUT]
Grazie, cerchero' di farne tesoro. Per il momento, la soluzione proposta da
Matish non è in contrasto con quello che dici tu, giusto?
Ciao, 
Ale

 Ale
no, non lo č, solo che ti consiglio di tenere a mente le regole che ti ho
riportato in futuro per una programmazione migliore
ciao gigabyte