[JAVA] Realizzare astrazioni polimorfiche, help me per capire quello che dice la prof

[D4rkAng3l]

mmm,
stò studiando le astrazioni polimorfiche in Java ma purtroppo mi sono accorto che quelle due pagine di appunti sono più o meno incomprensibili anche per me che le ho scritte perchè ho scritto un casino...quello che sono riuscito a decriptare dalla mia calligrafia è questo...

Praticamente si vuole realizzare un algoritmo di ordinamento su array e si vuole che tale algoritmo funzioni per ogni tipo di dato.

Per fare ciò viene definito un nuovo tipo di dato Confrontabile mediante un'interface che rappresenta appunto tipi confrontabili (così l'algoritmo funzionerà allo stesso modo su un array di interi così come su un array di double, etcetc)

Quindi:

public interface Confrontabile(){
public boolean minoreDi(Confrontabile);
}


Poi alla pagina dopo trovo questo codice che dovrebbe essere il codice del metodo di ordinamento in loco, che però non c'è scritto il nome del metodo ne in quale classe deve essere messo :muro: :muro: :muro: :muro: :cry: :cry: :cry:


public static void(Confrontabile[] x){ // METODO DI ORDINAMENTO ?!?!

Confrontabile c; // Dichiaro una variabile c di tipo Confrontabile (tipo generico per confrontare tutte le implementazioni di Confrontabile?)
int i,j,n; // Dichiaro 3 variabili intere che uso come indici e contatori

for(i=0; i<x.length; i++){ // Scorri l'array x di tipo Confrontabile dal primo all'ultimo elemento
c = x[i]; // E ad ogni iterazione metti in c il riferimento all'i-esimo oggetto presente nell'array

for(j=i+1; j<x.length; j++){ // Ciclo interno che scorre l'array x a partire dall'(i+1)-esimo elemento
if(x[j].minoreDi[c]{ // Se l'(i+1)-esimo elemento dell'array è minore del precedente puntato da c
c = x[j]; // Metti in c il riferimento all'(i+1)-esimo elemento
n = j; // Metti in n l'indice dell'(i+1)-esimo elemento
}

x[n] = x[i]; // Scambia in loco il valore contenuto nell'i-esimo elemento e mettilo alla posizione (i+1)-esima
x[i] = c; // Scambia in loco e metti il riferimento al vecchio (i+1)-esimo elemento in posizione i
}
} // Così alla fine l'array di Confrontabili è stato ordinato in loco a prescindere da qual'è il tipo effettivo di x


Ed infine ho la definizione del tipo IntConfrontabile che implementa l'interfaccia e contiene l'implementazione del metodo minoreDi() per confrontare tra loro gli elementi di un array di interi (poi ad esempio potrei implementare altri tipi di dato come StringConfrontabile che a sua volta conterà la relativa implementazione di minoreDi() per confrontare le stringhe in base a qualche criterio)


/* Ha delle funzionalità in più rispetto ad Integer: le funzionalità dell'interface */
public class IntConfrontabili extends Integer implements Confrontabile{

/* REQUIRES: y deve essere di tipo IntConf */
public boolean minoreDi(Confrontabile y){
boolean b = false;

if(intValue() < ((IntConf).intValue())
b = true

return b;
}
}


Il ragionamento l'ho capito: dichiaro un tipo di dato Confrontabile il più generico possibile mediante un'interface che contiene un metodo minoreDi(), poi implemento l'interface per ogni sottotipo di array confrontabili tra di loro ed in tali implementazioni ci caccio dentro il codice del metodo che sa confrontare gli elementi di un array omogeneo per quel tipo di collezione.
Nell'algoritmo di ordinamento opero sul tipo generico Confrontabile e verrà richiamato il codice del metodo corretto...ok...ma in pratica da questi appunti non sò come metere insieme il tutto:

1) L'algoritmo di ordinamento in che classe dovrebbe stare? e che nome dovrebbe avere? booo

2) In IntConfrontabile chi cavolo è intValue() ?

3) Confrontabile è solo un'interface e non ha rappresentazione, allora in IntConfrontabile non ci dovrebbe essere anche un array di istanza di tipo int ed il relativo costruttore?

4) Perchè oltre ad implementare Confrontabile gli fa estendere Integer?

Per favore aiutatemi che stò un po' disperato....

Grazie
Andrea

[banryu79]

1) L'algoritmo di ordinamento in che classe dovrebbe stare? e che nome dovrebbe avere? booo

L'arlgoritmo di ordinamento starà in un'altra classe perchè potrebbe implementare un qualsiasi algoritmo di ordinamento (probabilmente mergesort).
L'algoritmo farà i confronti tra due elementi dell'insieme dei valori da ordinare considerandoli come oggetti Confrontabili.


2) In IntConfrontabile chi cavolo è intValue() ?

IntConfrontabile estende java.lang.Integer (http://java.sun.com/javase/6/docs/api/java/lang/Integer.html): intValue() è un metodo ereditato dalla superclasse.
Comunque in questo spezzone di codice postato forse c'è un errore, penso si intendesse fare questo:

public class IntConfrontabili extends Integer implements Confrontabile{

/* REQUIRES: y deve essere di tipo IntConf */
public boolean minoreDi(Confrontabile y){
boolean b = false;

// --> if(intValue() < ((IntConf).intValue())
if(intValue() < ((IntConfrontabili)y).intValue())
b = true

return b;
}
}




3) Confrontabile è solo un'interface e non ha rappresentazione, allora in IntConfrontabile non ci dovrebbe essere anche un array di istanza di tipo int ed il relativo costruttore?

No: IntConfrontabile oltre a implementare l'interfaccia Confrontabili, estende una classe concreta: java.lang.Integer, e quindi eredita metodi e membri di quella classe. Vatti a dare un'occhiata alla classe Integer nei javadoc (in pratica è una semplice classe per wrappare il tipo primitivo int in un oggetto)

Il vostro IntConfrontabile non è altro che un Integer che in più soddisfa il contratto definito dalla vostra interfaccia Comparabili.


4) Perchè oltre ad implementare Confrontabile gli fa estendere Integer?

Perchè lo scopo sembrerebbe quello di rappresentare come oggetto Java il tipo primito int (grazie a Integer) E dotare questi oggetti della capacità di confrontarsi tra loro (grazie alla interface Comparabili) in modo da poterne creare una collezione (per esempio un array) da passare poi a qualche altro metodo di qualche altra classe che implementa un algoritmo di ordinamento che si aspetta di operare su oggetti di tipo Comparabili.

Esempio:

final int QUANTITY = 10;

IntComparabile[] numbers = new IntComparabile[QUANTITY];
for (int i = 0; i < QUANTITY; i++)
{
numbers[i] = new IntComparabile(i);
}

Alla fine di questo codice hai un array di 10 oggetti IntComparabile, che rappresentano gli interi da 0 a 9 inclusi (ammesso che esista nella classe IntComaprabile la definizione di un costruttore che prende un parametro di tipo int, cosa che per il momento non c'è nel codice che hai postato).

[D4rkAng3l]

Bene,
inizio a farmi girare le palline perchè si vabbè che avevo preso malegli appunti io ma temo che anche quello che è stato detto in classe sia concettualmente errato almeno in parte...

Allora ho realizzato le seguenti 3 classi, che credo ora siano OK:

1) Confrontabile:

public interface Confrontabile{
public boolean minoreDi(Confrontabile x);
}


2) IntConfrontabile:

public class IntConfrontabile extends Integer implements Confrontabile{

/* REQUIRES: y deve essere di tipo IntConf */
public boolean minoreDi(Confrontabile y){
boolean b = false;

// --> if(intValue() < ((IntConf).intValue())
if(intValue() < ((IntConfrontabile)y).intValue())
b = true;

return b;
}
}


3) Utility:

public class utility{

public static void ordina(Confrontabile[] x){ // METODO DI ORDINAMENTO ?!?!

Confrontabile c; // Dichiaro una variabile c di tipo Confrontabile (tipo generico per confrontare tutte le implementazioni di Confrontabile?)
int i,j,n; // Dichiaro 3 variabili intere che uso come indici e contatori

for(i=0; i<x.length; i++){ // Scorri l'array x di tipo Confrontabile dal primo all'ultimo elemento
c = x[i]; // E ad ogni iterazione metti in c il riferimento all'i-esimo oggetto presente nell'array

for(j=i+1; j<x.length; j++){ // Ciclo interno che scorre l'array x a partire dall'(i+1)-esimo elemento
if(x[j].minoreDi[c]){ // Se l'(i+1)-esimo elemento dell'array è minore del precedente puntato da c
c = x[j]; // Metti in c il riferimento all'(i+1)-esimo elemento
n = j; // Metti in n l'indice dell'(i+1)-esimo elemento
}

x[n] = x[i]; // Scambia in loco il valore contenuto nell'i-esimo elemento e mettilo alla posizione (i+1)-esima
x[i] = c; // Scambia in loco e metti il riferimento al vecchio (i+1)-esimo elemento in posizione i
}
} // Così alla fine l'array di Confrontabili è stato ordinato in loco a prescindere da qual'è il tipo effettivo di x
}
}


La prima si compila senza problemi...le altre 2 no...tutto dipende dal fatto si prova a dire che IntConfrontabile estende Integer ma....il compilatore da questo messaggio di errore:

C:\Programmi\Crimson Editor\template\esercizi\AstrazioniPolimorfiche>javac IntConfrontabile.java
IntConfrontabile.java:1: cannot inherit from final java.lang.Integer
public class IntConfrontabile extends Integer implements Confrontabile{
^
IntConfrontabile.java:1: cannot find symbol
symbol : constructor Integer()
location: class java.lang.Integer
public class IntConfrontabile extends Integer implements Confrontabile{
^
2 errors


Da quello che ho capito Integer è dichiarato come final e non posso estendere le classi final...quindi? come fare?
Cos'è di preciso una classe dichiarata come final?

Grazie
Andrea

[banryu79]

O sì, che lollo che sono; le classi wrapper per i tipi primitivi nel JDK sono final: ergo non le puoi estendere.
Ho dato per scontato che quell'extends Integer si riferisse alla classe java.lang.Integer.
Magari non è così e Integer è una classe custom che vie siete definiti (o vi dovete definire) voi/il professore... Il fatto è che nello spezzone di codice postato non si vedono import...


Cos'è di preciso una classe dichiarata come final?

Una classe la cui definizione è completa e di cui non si desiderano (o non sono neccessarie) uteriori sotto-classi.
Se si prova a estendere una classe dichiarata come final, si ottiene l'errore in compilazione che hai già sperimentato.
Curiosità: non si può dichiarare una classe final e abstract assieme, perchè l'implementazione di una tale classe non potrà mai essere compiuta/completata.

Inoltre dato che una classe final non potrà mai venire estesa, i suoi metodi non possono essere soggetti a override (sono implicitamente final anch'essi).

[D4rkAng3l]

O sì, che lollo che sono; le classi wrapper per i tipi primitivi nel JDK sono final: ergo non le puoi estendere.
Ho dato per scontato che quell'extends Integer si riferisse alla classe java.lang.Integer.
Magari non è così e Integer è una classe custom che vie siete definiti (o vi dovete definire) voi/il professore... Il fatto è che nello spezzone di codice postato non si vedono import...

No è proprio la classe Integer...che palle...vabbè parlerò con la proff...

[banryu79]

No è proprio la classe Integer...che palle...vabbè parlerò con la proff...
Ma è la proff che via 'suggerito' di estendere Integer?
Avrà preso una svista anche lei :D

[D4rkAng3l]

Ma è la proff che via 'suggerito' di estendere Integer?
Avrà preso una svista anche lei :D

Mah diciamo che questo è il classico esempio fatto di getto alla lavagna per far capire il concetto...nel senso che lo scopo era far capire che cos'è l'astrazione polimorfica e quali sono i possibili motivi per cui usarla....però inizia a rodermi perchè questo esempio è sbagliato...quelli del libro sono deliranti e privi di logica...ed io c'avrei altri 4 esami a cui pensare invece che stare appresso a cose strane...hahah mo tanto inizio a tormentarvi anche con questioni di ottimizzazione di database appena rimonto mysql :D TREMATEEEE

[banryu79]

Implementazione custom stupida e minimale della classe Integer, da usare appunto solo per fini di esempio (alla fine vogliamo solo avere il nostro int primitivo wrappato in un oggetto):

public class MyInteger
{
/** il valore di tipo int wrappato */
int value;

public MyInteger(int value) {this.value = value;}

public int getValue() {return value;}

@Override
public int hashCode() {return value;}

@Override
public boolean equals(Object o)
{return o instanceof MyInteger && (value == ((MyInteger)o).getValue());}
}