[java]ereditare da interfacce

[diadhuit]

Ciao!
In un esame passato il docente aveva fatto questa domanda:
Si considerino le classi sotto riportate, tra le quali Controllo causa un errore in compilazione.
Apportare al codice indicato la minor quantità di modifiche in grado di permettere al metodo main()
di produrre in uscita i valori: 1 e -1 .
Vincolo: l’interfaccia Costante non deve essere modificata.

interface Costante { static int VAL = 0; }

class ClsA implements Costante {
private int k = VAL;
public void modifica() {
k++;
System.out.println (k);
}
}

class Controllo {
private Costante handle;
Controllo (Costante cls) { handle = cls; }
void go() { handle.modifica(); }
}

class ClsB implements Costante {
private int k = VAL;
public void modifica() {
k--;
System.out.println (k);
}
}

public class Callback {
public static void main (String[] args) {
ClsA clsA = new ClsA();
ClsB clsB = new ClsB();
Controllo ctr1 = new Controllo (clsA);
ctr1.go();
Controllo ctr2 = new Controllo (clsB);
ctr2.go();
}
}


Ora, io sto provando a dare una risposta, ma l'unica che riesco a trovare è modificare la classe controllo nel modo seguente:


class Controllo {
private ClsA handleA;
private ClsB handleB;
Controllo (ClsA cls) {
handleA=cls;
}
Controllo (ClsB cls) {
handleB=cls;
}
void go() {
if (handleA!=null){
handleA.modifica();
}else if (handleB!=null){
handleB.modifica();
}
}
}

Ma mi sembra un po' macchinosa. Sto forse tralasciando qualcosa?
Se non ci fosse il vincolo imposto, potrei inserire un semplice metodo astratto modifica() senza modificare nient'altro?
Grazie mille!

[andbin]

Ma mi sembra un po' macchinosa. Sto forse tralasciando qualcosa? Sì, è macchinosa e stai tralasciando un dettaglio importante.

Una classe non eredita da una interfaccia .... una classe (non astratta), se implementa una interfaccia, deve implementare tutti i metodi dichiarati nella interfaccia.

Nel punto in cui fai:
void go() { handle.modifica(); }

handle è un reference di tipo Costante. 'handle' quindi deve contenere un riferimento ad una classe che implementa l'interfaccia Costante.

il metodo modifica() è effettivamente implementato dalle classi ClsA e ClsB ma non è dichiarato nella interfaccia Costante.

Quindi la cosa più semplice e valida è quella di dichiarare il metodo modifica() nella interfaccia. ;)

Facendo così, quindi l'interfaccia Costante dice: "chi mi implementa, deve implementare il metodo modifica()". Le due classi ClsA e ClsB implementano l'interfaccia Costante (e implementano il metodo) e quindi chi ha un reference di tipo Costante, può chiamare legittimamente il metodo modifica().

[andbin]

Oops.... chiedo scusa ... mi è venuto il dubbio ed ho riletto meglio:

"Vincolo: l’interfaccia Costante non deve essere modificata."

Sono partito in quarta leggendo solo il codice e non ho fatto attenzione a questa nota. :D :muro:

Però c'è comunque una soluzione migliore della tua (senza toccare l'interfaccia). Nella classe Controllo, prima di usare 'handle' fai un test con instanceof per verificare se l'oggetto referenziato da 'handle' è di tipo ClsA oppure ClsB e poi fai il cast e la chiamata a modifica().

Una cosa del tipo:
void go() {
if (handle instanceof ClsA)
((ClsA) handle).modifica();
else if (handle instanceof ClsB)
((ClsB) handle).modifica();
}
A quest'ora della sera è l'unica cosa che mi è venuta in mente. :p
Daltronde, se non si può toccare l'interfaccia Costante (che sarebbe la cosa più logica e corretta), non è che ci si può inventare molto altro!