[Domanda teorica OO] Regole di covarianza e controvarianza

[D4rkAng3l]

Ragazzi sono un po' disperato...la proff durante il corso di Linguaggi di Programmazione ha parlato delle regole di covarianza e di controvarianza...argomento trattato l'ultima lezione...forse l'unico su cui proprio non c'ho capito una mazza...ho provato a documentarmi ma niente...non m'entra....mi date una manina?

1) A che servono tali regole? (da quello che ho capito vengono usate per forzare i metodi...nel senso ho un metodo nella classe padre...lo ridefinisco con la stessa signature in una classe figlio....o qualcosa del genere)

2) Come si fà questo esercizio? (sono totalmente impallato...non saprei minimamente che risponderle su questo...)

Si consideri un generico linguagio polimorfico, la cui sintassi coincide con quella del linguaggio Java e che utilizza le regole della covarianza e della controvarianza per la forzatura dei metodi. Siano, in tale linguaggio, T1, T2 e T3 tre tipi di dato ed S1, S2 ed S3, rispettivamente, un sottotipo di T1, un sottotipo di T2 ed un sottotipo di T3.
In T1 sia definito il metodo di prototipo: T2 calcola(S3) ed in S1 sia definito il metodo di prototipo: S2 calcola(T3).
Mostrare perchè il metodo calcola definito in S1 è una forzatura (overriding) del metodo calcola definito in T1

Please save me

Ciao
Andrea

[banryu79]

Originariamente inviato da D4rkAng3l

Ragazzi sono un po' disperato...la proff durante il corso di Linguaggi di Programmazione ha parlato delle regole di covarianza e di controvarianza...argomento trattato l'ultima lezione...forse l'unico su cui proprio non c'ho capito una mazza...ho provato a documentarmi ma niente...non m'entra....mi date una manina?

Sulla covarianza e contravarianza c'è un ottimo tutorial dell'ancor più ottimo PGI (ei fu, non bazzica più da queste parti).

Eccotelo: link

[D4rkAng3l]

mmm bel casotto...quel tutorial lo leggerò bene nel pomeriggio (per ora gli ho dato una rapida occhiata ma mi sembra di un livello un po' altino per il mio esame...)

Sul Programming Language Concepts (Ghezzi\Jazayeri) fà degli esempi in simil C++ che capisco poco perchè non sò una pippa ne di C++ ne di cosa sia una funzione virtuale (che non abbiamo trattato nel corso)...

Leggendolo però ho capito che ci sono queste 2 regolette:

1) I parametri di input del metodo forzante (definito in una sottoclasse) devono essere supertipi dei corrispondenti parametri di input del metodo forzanto (definito nella superclasse).

2) Il parametro di ritorno del metodo forzante (definito in una sottoclasse) deve essere un sottotipo del parametro di ritorno del metodo forzato (definito nella sottoclasse).

Quindi in riferimento all'esercizio precedente posso dire che il metodo calcola() definito in S1 è una forzature (overriding) del metodo calcola definito in T1 perchè:

1) S1 è una sottoclasse di T1 dove stò ridefinendo il metodo calcola()

Da quì inizio a farmi le varie pippe mentali sui tipi dei parametri di input e di ritorno dei due metodi per vedere se rispettano le regole di varianza e covarianza:

2) Il parametro di input del metodo forzante (definito nella sottoclasse S1) è T3 che è SUPERTIPO del corrispondente parametro di input del metodo forzato definito nella superclasse T1 --> OK

3) Il parametro di ritorno del metodo forzante (definito nella sottoclasse S1) è S1 che è un sottotipo del parametro di ritorno del metodo forzato che ritornava T1 --> OK

da quì posso dire che vengono rispettate le regole di varianza e covarianza e che quindi il metodo calcola() definito nella sottoclasse S1 è una forzatura del metodo calcola definito nella superclasse T1.

E' corretta come risposta?

Tnx
Andrea

[banryu79]

Covarianza del tipo restituito:
In Java, prima della versione 1.5, la ridefinizione di un metodo (override) definito in una classe A, da parte di un'altra classe B sottotipo di A, veniva ottenuta solo modificando il tipo dei parametri in ingresso per quel metodo, mentre il tipo del valore di ritorno non poteva essere modificato (invarianza del tipo restituito).

Da Java 1.5 in poi è presente la covarianza del tipo riestituito:

class Supertype
{
    Number getValue()
    {
        return 10.2;
    }
}

class Subtype extends Supertype
{
    Integer getValue()
    {
        return 2;
    }
}

In pratica, in Java, il tipo restituito da un metodo è passato da invariante a covariante.

La parte un po' più complicata nella pagina che ti ho linkato è il discorso sulla contravarianza limitata all'ambito d'uso dei Generics come tipo restituito (se conosci i Generics e la leggi con calma la capirai facilmente: le spiegazioni di PGI sono lampanti e lui ha il dono di sintesi e chiarezza che invece a me spesso manca).

[D4rkAng3l]

Il fatto è che noi non l'abbiamo fatto riferito a Java (tra l'altro la proff, forse facendo riferimento ad una vecchia versione, ci ha detto che Java non supporta le regole della varianza e della covarianza.

Il testo dell'esercizio dice di considerare un linguaggio polimorfico la cui sintassi cincide con quella di Java...non Java...in Java probabilmente lo vedremo nel successivo corso del prossimo semestre...

Alla luce di ciò...ti chiedo se la soluzione postata dell'esercizio del primo post può essere corretta.

Grazie
Andrea

[mad_hhatter]

scusate ma... poiché il metodo calcola di S1 riceve un parametro di tipo T3, mentre il metodo calcola di T1 riceve un parametro di tipo S3, non si ha overriding, ma overloading. No?

[D4rkAng3l]

Originariamente inviato da mad_hhatter

scusate ma... poiché il metodo calcola di S1 riceve un parametro di tipo T3, mentre il metodo calcola di T1 riceve un parametro di tipo S3, non si ha overriding, ma overloading. No?

doh non ti seguo....

Io ho 3 classi padre: T1, T2, T3
e le rispettive 3 classi figlie S1, S2, S3

dove:

S1 è sottoclasse di T1
S2 è sottoclasse di T2
S3 è sottoclasse di T3

e due metodi:

Nella classe padre T1 viene definito: T2 calcola(S3)
Nella classe figlia S1 viene definito: S2 calcola(T3)

Leggendo sul libro dice che nei linguaggi OO posso rilassare la regola per cui si ha ovverriding dei metodi solo quando questi hanno la stessa identica signature ma che alcuni linguaggi permettono di rilassare tale regola (ed avere comunque overriding) utilizzando le regole di varianza e di covarianza, che dicono (testuali parole del libro tradotte dall'inglese):

1) I parametri di input del metodo forzante (definito in una sottoclasse) devono essere supertipi dei corrispondenti parametri di input del metodo forzanto (definito nella superclasse).

2) Il parametro di ritorno del metodo forzante (definito in una sottoclasse) deve essere un sottotipo del parametro di ritorno del metodo forzato (definito nella sottoclasse).

Quindi considerando i 2 metodi:

1) Il parametro di input del metodo forzante ridefinito nella classe figlia è T3: T3 è supertipo di S3? SI...allora la prima regola è stata rispettata

2) Il parametro di ritorno del metodo forzante ridefinito nella classe figlia è S2: S2 è sottotipo di T2? Si....allora anche la seconda regola è stata rispettata.

--> E' un corretto overriding del metodo.

Credo sia così...

[mad_hhatter]

Ok, continuavo a pansare a Java... scusa

Però il primo criterio mi rende perplesso... non riesco bene a intuirne la semantica e il modello di utilizzo...

[D4rkAng3l]

Originariamente inviato da mad_hhatter

Ok, continuavo a pansare a Java... scusa

Però il primo criterio mi rende perplesso... non riesco bene a intuirne la semantica e il modello di utilizzo...

è solo un esercizio d'esame per vedere se uno ha studiato le regolette...cmq ho chiesto anche nella sezione di Informatica teorica in scienze e tecnica e mi hanno dato conferma

Ciao
Andrea