Classi in java

[samlu]

Non so eseguire questo esercizio
public class A1 {
private int x;

public A1 (int k){
x=k;
}
public int getX(){
returnx;
}
public int m(A1 a) {
if (this.x>a.x)
return1;
else
return 2;
}
}

Public class B1 extends A1 {
private int y;

public B1 (int k,int r);{
super (k);
y=r;
}
public int getY(){
return y;
}
public int m(A1 a) {
return super.m(a)*y;
}
}


DAti i seguenti oggetti:
A1 a1=new A1(3);
B1 b1=new B1(2,4);
A1 a2=new B1(1,3);
det.qual è il valore restituito dalle seguenti chiamate di metodo:
a1.m(a1)
a1.m(b1)
b1m(a1)
po c sono alti ma se riuscite a farmi capire come fare,forse riesco a fare anke gli altri... la cosa ke nn comprendo sono proprio i simboli usati...penso ke per risolverlo devo inserire i dati ke mki da nel programma...ma nn capisco se ad esempio la lettera A1 e B 1prima dlla def dei primi due oggetti mi dice la classe in cui devo inserirli?poi M(A1 a) sono gli interi ke immetto io nel programma?e quando in B1 con super(k) mi rikiama k a quale k faccio riferimento?scusate la lunghezza ma ci sono stata un pom intero e nn sono riuscita a svolgerlo...se potetet aiutarmi ve ne sarei grata...

[Rggb1]

(Non si capisce un granché...)
1. Scusa, puoi evitare le sigle "essemmesse"? Hai tutto il tempo per battere su una comoda tastiera, e diventa molto più leggibile.
2. Quando metti un codice inseriscilo all'interno del corrispondente tag "code" - ci sono le istruzioni.

Poi dalle tue domande sembra tu stia chiedendo "come fare X" senza aver capito minimamente da dove iniziare (urca!), oppure sono io che non ho capito: spiegati meglio.

[apatriarca]

Usa il tag Code per inserire il codice e cerca di scrivere in italiano corretto (senza tutte quelle abbreviazioni da sms). È infatti molto difficile leggere e capire quello che hai scritto.

Si tratta comunque di un semplice esercizio per verificare la comprensione della teoria. Se non riesci a capire le poche righe di codice dell'esercizio vuol dire che devi andare a rileggerti con attenzione i libri/dispense/appunti di teoria cercando di capire che cosa stia succedendo in questo esempio specifico. Puoi inoltre provare a compilare il codice e vedere che numeri vengono restituiti da quelle righe di codice e cercare di capire il perché. Una volta che hai provato a fare tutte queste cose e hai fallito, allora possiamo riparlarne.

[edge1]

public class A1 {
private int x;

public A1 (int k){
x=k;
}
public int getX(){
returnx;
}
public int m(A1 a) {
if (this.x>a.x)
return1;
else
return 2;
}
}

Public class B1 extends A1 {
private int y;

public B1 (int k,int r);{
super (k);
y=r;
}
public int getY(){
return y;
}
public int m(A1 a) {
return super.m(a)*y;
}
}


DAti i seguenti oggetti:
A1 a1=new A1(3);
B1 b1=new B1(2,4);
A1 a2=new B1(1,3);
det.qual è il valore restituito dalle seguenti chiamate di metodo:
a1.m(a1)
a1.m(b1)
b1m(a1) 

Adesso posta quali sono i tuoi problemi

[xsl]

Nel codice ho piazzato qualche commento che potrebbe chiarirti meglio le idee riguardo la disposizione del codice.

public class A1 {
  private int x; //campo di istanza privato

  //costruttore
  public A1 (int k){
     x=k;
  }

  //metodo che restituisce il valore del campo di istanza x
  public int getX(){
    return x;
  }
  
  public int m(A1 a) {
    if (this.x>a.x) return1;
    else return 2;
  }
}

//B1 è una classe figlia della classe A1
public class B1 extends A1 {
   private int y;

   public B1 (int k,int r);{
     super (k);
     y=r;
   }
   
   public int getY(){
     return y;
  }

  public int m(A1 a) {
    return super.m(a)*y;
  }
}


//in genere le righe di seguito vengono eseguite nel metodo MAIN (della classe stessa in cui si opera o di un'altra)
A1 a1=new A1(3);
B1 b1=new B1(2,4);
A1 a2=new B1(1,3);
a1.m(a1);
a1.m(b1);
b1.m(a1);

"A1 a" è la dichiarazione del parametro formale a di tipo A1; cioè la dichiarazione di un parametro formale in java (per un metodo e/o un costruttore di classe) ha questa forma:


dove il tipo indica di quale classe deve essere istanza il parametro effettivo (cioè l'oggetto che gli viene passato a run-time).

Un altro esempio di parametro formale ce l'hai nel costruttore stesso della classe A1: int k
int sta ad indicare che un valore k passato al costruttore (in fase di esecuzione) deve essere assolutamente di tipo int!
Considera i due esempi qui sotto:

int n=100;
new A1(n); //il compilatore accetta questa chiamata

Se invece scrivi

double n=100;
new A1(n); //il compilatore non te la da per buona 

- Il costrutto super():
premesso che la classe B1 è una classe Figlia della classe A1 in quanto ne eredita metodi e proprietà; infatti la classe B1 come proprietà oltre ad avere y avrà anche x, in quanto la eredita direttamente dalla classe A1.
Questo è accertato dal fatto che nella dichiarazione della classe B1 viene utilizzata la parola chiave EXTENDS, che viene riferita alla classe A1.
Dunque B1 extends A1 significa che B1 deriva A1 e quindi B1 e A1 sono in relazione di ereditarietà.

Il costrutto super() viene chiamato giustamente nel costruttore di B1 e la sua funzione è quella di eseguire il costruttore della classe padre, cioè quello della classe A1.
Mentre invece, nel metodo m della classe B1 la chiamata super.m(a) sta a significare che la funzione che si vuole eseguire è quella della classe padre A1 (e dunque il suo risultato verrà moltiplicato ad y).

Ora provo a spiegarti passo dopo passo quello che dovrebbe accadere nel momento in cui esegui queste righe di codice:

A1 a1=new A1(3);
B1 b1=new B1(2,4);
A1 a2=new B1(1,3);

Intanto puntualizzo che 1, 2, 3 e 4 sono per definizione parametri effettivi (come già detto, essi devono rispettare la dichiarazione del rispettivo parametro formale altrimenti il compilatore da errore al 100%).

A1 a1=new A1(3); ---> x=3 (istanzia la classe A1 ed assegna 3 al suo campo di istanza privato x)
B1 b1=new B1(2,4); ---> x=2, y=4 (2 viene assegnato ad x per via della chiamata di super(k) all'interno del costruttore)
A1 a2=new B1(1,3); (NB: il viceversa non è ammesso) ---> puoi assegnare una istanza della classe figlia (B1) ad una variabile d'oggetto di classe padre (A1) poichè è ammesso il Polimorfismo di Inclusione, il quale è basato su questo principio: http://it.wikipedia.org/wiki/Sostituibilit%C3%A0

A questo punto dovresti essere in grado di stabilire i valori forniti in output dalle seguenti chiamate:

a1.m(a1)
a1.m(b1)
b1.m(a1)

P.S. Se qualcosa non ti è ancora chiaro non esitare a farlo sapere.