Pages: [1] 2   Go Down
Print
Author Topic: Dubbi esistenziali  (Read 2157 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« on: 03-03-2011, 18:17:13 »

Ragazzi ho iniziato da poco l'eredetarietà e non ho capito una cosa....La parola chiave super(ecc) serve per indicare ciò che ereditiamo da una classe.Dall'esempio che il prof ha fatto in aula se abbiamo per esempio:

Code:
classe A
{
private String s;

public A(string_s)
{
s=_s;
}
.
.
.
}

classe B
{
private char c;

public B(chat_c)
{
super(_s);
c=_c;
}
.
.
.
}

classe C
{
private int a;

public C(int_a)
{
super(_s,_c)
a=_a;
}
.
.
.
}


Ma allora non riesco a capire bene la logica di questi altri super:

Code:
/* esempio1 è una classe che utilizza una semplice gerarchia di oggetti
capostipite della gerarchia è il generico triangolo, assegnato mediante la misura dei suoi lati
da esso deriveremo i triangoli isosceli e da questi i triangoli equilateri.

Unico metodo che ci interessa è il colcolo del perimetro.
Per non incappare in problemi di visibilità tutte le variabili non saranno qualificate in accesso
(nè public nè private quindi visibili da tutti gli oggetti del package)
*/

//====================classe dimostrativa esempio1=============================
public class Ex01
{
 public static void main(String[] args)
 {
  triangolo T1  = new triangolo(12,10,8);
  isoscele I1   = new isoscele(10,20);
  equilatero E1 = new equilatero(9);

  System.out.println(T1.getInfo());
  System.out.println(I1.getInfo());
  System.out.println(E1.getInfo());

  System.exit(0);
  }
}

//===================classe triangolo, la capostipite! ========================
class triangolo
{
 double lato1, lato2, lato3;
 // un semplice costruttore, nessun test viene previsto per controllare se i dati forniti sono compatibili con il fatto
 // che essi rappresentino i lati di un VERO triangolo (aggiungerlo per esercizio!)
 public triangolo(double A, double B, double C)
 {
   lato1=A;
   lato2=B;
   lato3=C;
  }
  
  // calcolo del perimetro
  public double perimetro()
  {
   System.out.println("Perim. triangolo");  
   return lato1+lato2+lato3;
    
  }
  
  // informazioni da pubblicare
  public String getInfo()
  {
  String info="Il triangolo ha lati di dimensioni\n";
  info+="\t"+lato1+"\t"+lato2+"\t"+lato3+"\n";  
  info+="e perimetro\t"+perimetro();

   return info;
  }
  
}

//===================classe isoscele, prima generazione! ========================
class isoscele extends triangolo // notare la parola chiave extends
{
 // nessun bisogno di ripetere di nuovo la dichiarazione delle variabili dinistanza... esse sono ereditate da triangolo
 
 //il costruttore si limita a richiamare il costruttore del progenitore con la parola chiave "super"
 //(SE INTENDIAMO USARLO DEVE ESSERE LA PRIMA PAROLA DEL NUOVO COSTRUTTORE)
 public isoscele(double A, double B)
 {
   super(A,A,B); // finito!
  }
  
  // calcolo del perimetro, in questo caso sovrascriviamo il metodo ereditato: ne abbiamo uno più efficiente
  public double perimetro()
  {
   System.out.println("Perim. isoscele");  
   return 2*lato1+lato3;
  }
  
  // non ci serve riscrivere getInfo()!
}

//===================classe equilatero, seconda generazione! ========================
class equilatero extends isoscele // notare la parola chiave extends
{
 // nessun bisogno di ripetere di nuovo la dichiarazione delle variabili dinistanza... esse sono ereditate da isoscele
 
 //il costruttore si limita a richiamare il costruttore del progenitore con la parola chiave "super"
 //(SE INTENDIAMO USARLO DEVE ESSERE LA PRIMA PAROLA DEL NUOVO COSTRUTTORE)
 public equilatero(double A)
 {
   super(A,A); // finito! ho chiamato il costruttore di isoscele che richiama il costruttore di triangolo
  }
  
  // calcolo del perimetro, in questo caso sovrascriviamo il metodo ereditato: ne abbiamo uno più efficiente
  public double perimetro()
  {
   System.out.println("Perim. equilatero");  
   return 3*lato1;
  }
  
  // non ci serve riscrivere getInfo()!
}

« Last Edit: 03-03-2011, 18:19:36 by salvopuglisi » Logged
denote
Apprendista Forumista
**
Offline Offline

Posts: 136


« Reply #1 on: 03-03-2011, 19:49:20 »

super() non fa altro che chiamare il costruttore della superclasse. Quale' il dubbio?
Logged

Con la concorrenza di Java hanno ucciso 40 anni di computer science
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #2 on: 03-03-2011, 19:54:41 »

forse è meglio spiegare tutto il discorso.
partiamo ad esempio dall'avere una classe triangolo.
supponiamo che essa si costruisce dando al costruttore i tre lati, che saranno assegnati alle 3 variabili lato1,2,3 che sono gli attributi della classe. noi sappiamo che triangolo è troppo generico è che esistono quello scaleno, quello isoscele e quello equilatero.
quello equilatero ha i 3 lati uguali, l'isoscele due uguali e il terzo diverso, lo scaleno tutti diversi.
quindi costruendo le 3 classi "figlie" o ereditarie da triangolo, esse dovranno pur costruirsi. ma prendiamo ad esempio l'equilatero. c'è bisogno di mandare in input al costruttore 3 lati? no! ne basta uno! ma siccome già esiste il costruttore della superclasse, mandi tramite il super() questo solo lato scritto 3 volte al costruttore della superclasse. l'isoscele invece ha bisogno di due misure per essere costruito. quindi manda due misure con super() al costruttore della superclasse,una ripetuta due volte. lo scaleno invece manda tutti e 3 i lati diversi sempre con super() al costruttore della superclasse.
ti è chiaro?
poi per questione di sintassi e di utilizzo nel codice, il super() è il primo comando da scrivere nel costruttore di una classe figlia se lo vuoi utilizzare. dopo di esso è possibile poi scrivere tutto quello che vuoi per costruire l'oggetto "figlio".
in realtà poi sappiamo che la parola chiave "super" è usata anche per altre cose...
Logged

"Che la Forza sia con Te"
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« Reply #3 on: 03-03-2011, 20:08:33 »

e quindi in equilatero non si dovrebbe mettere super(A,A,A) invece di super(A,A) ?
Logged
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #4 on: 03-03-2011, 20:50:12 »

certo, sempre tre sono i parametri in input nel costruttore della madre, solo che è sempre lo stesso ripetuto 3 volte, mentre per l'isoscele scrivi super(A,A,B);
Logged

"Che la Forza sia con Te"
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« Reply #5 on: 06-03-2011, 23:37:38 »

Grazie l'ho capito ti ringrazio per essere stato chiaro ! 
Logged
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« Reply #6 on: 06-03-2011, 23:42:17 »

Ho finito da poco tutta la teoria di java (ovvero le slide del prof) ...Ma osservando gli esercizi della seconda prova  ho notato che oltre alle classi in basso si inizia sempre con Random r=new Random(ecc)....Non mi sembra che nelle slide sia spiegato ciò...Potreste spiegarmi con parole vostre che cosa sia questa random, io conosco solo Math.random() ma non questo tipo di random....E vorrei capire magari con degli esempi che cosa sia nextInt,nextDouble..Grazie 
Logged
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #7 on: 06-03-2011, 23:54:28 »

Random è una classe di java, ti rimando al sito stesso per le spiegazioni approfondite. a primo impatto, ti posso dire che questa random è una classe che, istanziato un oggetto appunto di classe Random, consente di generare numeri casuali a partire da dei valori in input o meno. ovviamente ci sn anche altre funzioni ma vabè, x quello che ci interessa x ora in programmazione 1, viene utilizzata soltanto per questo scopo. c'è una cosa xò da notare. x come è programmato il metodo random della Math, vengono generati veramente dei valori casuali, nn so in base a cosa, forse si basa sull'orario della bios del pc o altro. mentre i metodi della classe Random generano sempre gli stessi numeri a partire dallo stesso valore. x questo il prof li usa come inizio del main, xkè già sa quale sarà il ritorno di ogni metodo. c'ho fatto caso facendo delle prove....sicuramente ognuno di questi metodi sarà una sorta di funzione ricorsiva che a partire dallo stesso valore,in base a dei calcoli, poi ritorna sempre gli stessi risultati.


questo è ciò che ti so dire in base alla mia esperienza con i metodi ed una velocissima e poco e niente approfondita visione della classe sul sito java. ti rimando li per tutto il resto. ciò che ti serve sapere x fare le seconde prove te l'ho già scritto cmq
Logged

"Che la Forza sia con Te"
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« Reply #8 on: 07-03-2011, 12:30:45 »

Ti ringrazio mille !!!! 6 stato chiaro   
Logged
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« Reply #9 on: 07-03-2011, 12:43:52 »

ho trovato in internet la definizione di nextint,nextdouble che è:

1)oggetto.nextDouble() restituisce sotto forma di dato double il
numero reale fornito in ingresso
2)oggetto.nextInt() restituisce sotto forma di dato int il numero
intero fornito in ingresso

quindi se r vale come tu mi dici un valore che parte in questo caso da 1772882

r.nextInt(10); e r.nextDouble(100) quanto valgono ? e quei 10 e 100 cosa rappresentano ?  
Logged
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #10 on: 07-03-2011, 13:04:14 »

allora quando si fa:
Random r= new Random(numero);
si sta costruendo un oggetto Random generatori di numeri pseudoRandom.
ora il metodo nextInt(int x) cioè con parametro in entrata come hai fatto te (r.nextInt(10)) genera un numero random che sta nell'intervallo [0;x[  (nel tuo caso [0;10[ )
nextDouble() nn esiste come metodo con parametro in entrata ma solo senza, a differenza di nextInt che esiste sia senza che con parametro in input)...
nextDouble() genera un valore compreso tra 0.0 e 1.0, dipendente dal numero messo x costruire l'oggetto r.
nextInt() (parlo di quello senza input) genera un numero di tipo int a partire sempre dal generatore usato x costruire l'oggetto r. ( parentesi: il numero generato da questo metodo quindi è un qualunque int, quindi un qualunque numero codificabile con 32 bit in complemento a 2, valore fisso per java, cioè compreso nell'intervallo [-(2^31); 2^31 -1] )

questo è ciò che si evince dalle spiegazioni date li..
Logged

"Che la Forza sia con Te"
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« Reply #11 on: 07-03-2011, 13:20:10 »

ok grazie .... è sempre meglio saperle certe cose 
Logged
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« Reply #12 on: 07-03-2011, 16:54:56 »

ragazzi ho svolto il mio primo esercizio di lab , ma ci sono degli errori sicuramente ,potreste correggermelo e magari dirmi dove sbaglio ?  

Code:

abstract class A
{
private int x;

public A (int x)
{
this.x=x;
}

abstract public int f();

}

abstract class B extends A
{
protected int totaleC;
private int w;
private E e;

public B(int x,int w,double d)
{
super(x);
this.w=w;
E e = new E(d);
}

public int getw()
{
return w;
}
public float getCoeff()
{
return E.getCoeff();

}

public int getTotaleC()
{
return totaleC;
}

abstract public int f();
}

class C extends B
{
private int z;

public C(int x,int w,double d,int z)
{
super(x,w,d);
this.z=z;
}

public int f()
{
return w+z;
}
}

class D extends B
{
public D(int x,int w,double d)
{
super(x,w,d);
}
public int f()
{
return w*w;
}
}

class E
{
private float coeff;

public E (double c)
{
coeff=c;
}

public double getCoeff()
{
return coeff;
}

}

non ho fatto il main per adesso...
« Last Edit: 07-03-2011, 17:06:58 by salvopuglisi » Logged
StephCT
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 417



« Reply #13 on: 07-03-2011, 18:38:50 »

attento al nome del metodo getw()...sarò pignolo ma penso che, onde evitare spiacevoli sorprese, è meglio attenersi perfettamente al diagramma fornito dal prof e scrivere getW(). e sempre per attenersi al diagramma uml di questo insieme di classi, ti faccio notare che totaleC e getTotaleC() sono rispettivamente un parametro e un metodo static (sono sottolineati nel diagramma). su questo ti volevo far notare anche che,a questo punto dopo aver dichiarato entrambi static, dovrai incrementare totaleC nel costruttore della classe C (scrivendo proprio totaleC++)....tutto ciò serve xkè nel main sarà richiesto contare quanti sono gli oggetti di classe C istanziati e dovrai usare quel metodo, e non il solito contatore che sale se l'elemento di vett è istanza di C.
Logged

"Che la Forza sia con Te"
Jack&Daxter
Apprendista Forumista
**
Offline Offline

Gender: Male
Posts: 398



« Reply #14 on: 07-03-2011, 20:12:39 »

è meglio essere pignoli   non sapevo ad esempio che sottolineare le parole per il prof significasse static....Ho corretto queste piccole cose ,però il codice ha dei problemi...l'ho riposto con le tue osservazioni

Code:

abstract class A
{
private int x;

public A (int x)
{
this.x=x;
}

abstract public int f();

}

abstract class B extends A
{
static protected int totaleC;
private int w;
private E e;

public B(int x,int w,double d)
{
super(x);
this.w=w;
E e = new E(d);
}

public int getW()
{
return w;
}
public float getCoeff()
{
return E.getCoeff();

}

static public int getTotaleC()
{
return totaleC;
}

abstract public int f();
}

class C extends B
{
private int z;

public C(int x,int w,double d,int z)
{
totaleC++;
super(x,w,d);
this.z=z;
}

public int f()
{
return w+z;
}
}

class D extends B
{
public D(int x,int w,double d)
{
super(x,w,d);
}
public int f()
{
return w*w;
}
}

class E
{
private float coeff;

public E (double c)
{
coeff=c;
}

public double getCoeff()
{
return coeff;
}

}


ecco gli errori:

Code:

>javac A.java
A.java:34: non-static method getCoeff() cannot be referenced from a static context
return E.getCoeff();
        ^
A.java:34: possible loss of precision
found   : double
required: float
return E.getCoeff();
                 ^
A.java:81: possible loss of precision
found   : double
required: float
coeff=c;
      ^
A.java:51: cannot find symbol
symbol  : constructor B()
location: class B
{
^
A.java:53: call to super must be first statement in constructor
super(x,w,d);
     ^
A.java:59: w has private access in B
return w+z;
       ^
A.java:71: w has private access in B
return w*w;
       ^
A.java:71: w has private access in B
return w*w;
         ^
8 errors
>Exit code: 1

Logged
Pages: [1] 2   Go Up
Print
Jump to: