Reificazione

Reificazione, si è una parola Italiana …

PREV Evoluzione, non rivoluzione

Processo mentale mediante il quale a concetti astratti viene assegnata consistenza di cose concrete

Nella flosofa di Marx, processo secondo cui nell'economia capitalistica l'uomo e il suo lavoro sono ridotti al valore della merce che producono

La reifcazione è una fallacia o un'ambiguità quando un'astrazione (una credenza astratta o un costrutto ipotetico) viene trattata come se fosse un concreto evento reale o un'entità fsica

Nell'ambito dell'Ingegneria della conoscenza, e in particolare della defnizione di ontologie, la reifcazione è una rappresentazione indiretta che prevede l'utilizzo di determinate espressioni del linguaggio per descrivere entità del mondo reale intuitivamente associate a espressioni di tipo diverso. L'esempio tipico di reifcazione è costituito dall'utilizzo di individui per rappresentare classi.

Nel contesto della programmazione orientata agli oggetti si defnisce reifcazione il procedimento di creazione di un modello di dati basato su un concetto astratto predefnito. Mediante la reifcazione, un computer può compiere elaborazioni riguardanti un'entità astratta come se si trattasse di un insieme qualsiasi di dati di altro tipo

Non sempre il compilatore è in grado di capire se un cast verso un tipo non reifcabile avrà successo I sistemi di tipi (dei linguaggi di programmazione orientati agli oggetti) non sono perfetti e non possono individuare situazioni di successo come può fare un (buon) programmatore Per questo motivo un cast verso un tipo non reifcabile non genera un errore ma un warning

In java un tipo è reifcabile se il tipo è completamente identifcabile a runtime, ovvero se la type erasure non rimuove informazioni utili

• Primitivi es: int
• Classi o interfacce non parametriche es: String, Comparable
• Tipi parametrici in cui tutti gli argomenti di tipo sono wildcard non limitati es: List<?> o Map<?,?>
• Raw type es: List, Map Array di elementi di tipo reifcabile es: int[] , List<?>[]

• Variabili di tipo es: T in Xxxx<T>
• Tipi parametrici con parametri attuali es: List<String>, Comparable<Integer>
• Tipi parametrici con un limite es: List<? extends String> , Comparable <? super Number>

In java il tipo di un array viene reifcato con il tipo dei suoi componenti Un tipo parametrico non viene reifcato con il suo parametro di tipo List<?> è equivalente a List<? extends Object> (nel senso di passaggio di parametri) ma il primo è reifcabile il secondo no

I test instanceof ed i cast dipendono dall'esame a runtime dei tipi degli oggetti coinvolti e quindi dalla reifcazione Test di istanza verso un tipo non reifcabile → errore (di compilazione) Cast ad un tipo non reifcabile → genera (di norma) un warning

public class Myinteger {
  private final int value; public boolean equals(Object o) {
 
Myinteger è reificabile → il cast non genere warning
if (o instanceof Myinteger){  // ynteger è reificabile → compila
 
return this.value ==
((Myinteger)o).value; } else return false; // Myinteger è reificabile → il cast non genere warning
} ...
}
</code java>
 
===== Equals su liste =====
<code>
public abstract class MiaLista<E> extends AbstractCollection<E> implements List<E>{
public boolean equals(Object o){ if ( o instanceof List<E>){
Iterator<E> it1 = iterator(); Iterator<E> it2 = ((List<E>)o ).iterator(); while (it1.hasNext() && it2.hasNext()){
E e1 = it1.next(); E e2 = it2.next(); if (! ( e1 == null ? e2== null: e1.equals(e2) ) ){
return false; }
}
} }
return !it1.hasNext() && !it2.hasNext(); } else return false;

public abstract class MiaLista<E> extends AbstractCollection<E> implements List<E>{
public boolean equals(Object o){ if ( o instanceof List<E>){ Iterator<E> it1 = iterator();  // Errore di compilazione! List<E> non è reificabile
Iterator<E> it2 =
((List<E>)o ).iterator(); while (it1.hasNext() // Unchecked cast warning!
&& it2.hasNext()){ ...

public abstract class MiaListaOK<E> extends AbstractCollection<E> implements List<E>{
Iterator<E> it1 = iterator(); Iterator<?> it2 = ((List<?>)o ).iterator(); while (it1.hasNext() && it2.hasNext()){
return false; }
}
}
return !it1.hasNext() && !it2.hasNext(); } else return false;

public abstract class MiaListaOK<E> extends AbstractCollection<E> implements List<E>{ public boolean equals(Object o){
if ( o instanceof List<?>){ Iterator<E> it1 = iterator(); // OK List<?> è reificabile
 Iterator<?> it2 = (
(List<?>)o ).iterator(); // List<?> è reificbaile e non vengono generati warning
while (....
Object e2 = it2.next(); // Da una List<?> posso prelevare Object senza problemi

Test di istanza verso tipi non reifcabili generano sempre errore In alcune circostanze un cast ad un tipo non reifcabile può non generare warning

public static <T> List<T> asList(Collection<T> c )
throws IllegalArgumentException { 
 if ( c instanceof List<?>){ // List<?> è reificabile → compila
return (List<T>)c; } else throw new // Il cast non genera waring in quanto la sorgente del cast ha tipo Collection<T> 
                                    // e ogni oggetto di questo tipo che implementa List deve avere come tipo List<T>
 
IllegalArgumentException("Il parametro passato non e' un sottotipo di List<T>");

public static List<String> converti(List<?> oggetti){ for (Object obj: oggetti){ //Il cast “a logica” non fallirà mai
if (!( obj instanceof String)){ throw new IllegalArgumentException( ... // OK String è reificabile
}}
return
(List<String>)(List<?>)oggetti; } // Unchecked Cast ← il compilatore non è in grado di capire se il cast avrà successo o meno

Nota: è illegare “castare” una lista di oggetti ad una lista di stringhe, quindi serve il doppio cast

Gli array reifcano i loro componenti ovvero conservano a runtime i tipi dei loro componenti

Integer[] interi = new Integer[] {1,2,3}; // OK, gli array sono covarianti
Number[] numeri = interi;
numeri[2] = 3.14; // ArrayStoreException Double non è compatibile con il tipo reificato dell'array

public static <T> T[] toArray(Collection<T> c){
 
T[] ret= new T[c.size()];  // NO! errore di compilazione
int i = 0 ; for (T x :c){ret[i++] = x;} return ret;
}

Le variabili di tipo non sono reificabili → viene generato un generic array creation error

Cannot create a generic array of T 

Non poter creare array di generics è una limitazione di java Array generici sono problematici a causa della erasure (tuttavia) erasure facilita l'evoluzione

In generale … dire “no!” ad array ed utilizzare il Collection Framework

Tramite refection è possibile ovviare al problema della creazione di array generici

public static <T> T[]toArray(Collection<T> coll){
T[] ret = (T[]) new Object[coll.size()];  // Unchecked Cast!
int i = 0 ;
 for (T x :coll){ret[i++] = x;} 
return ret;
} --- 
List<String> stringhe = ... String[] a = toArray(stringhe); // Class Cast Exception

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
at generics.cap6.Ex1.main(Ex1.java:23)

Exception in thread "main" java.lang.ClassCastException: 
[Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
at generics.cap6.Ex1.main(Ex1.java:23)

• L signifca array di reference type
• [LObject signifca array di Object, Object è il component type dell'array
• L'errore non viene segnalato nel punto in cui viene generato (!) ma in un altro punto (!!!) ovvero nel main

public static Object[] toArray1( Collection coll){
Object[] ret = (Object[]) new Object[coll.size()]; // Unchecked Cast sparito! --> Erasure: converte il cast a T[] in un Cast a Object[]
int i = 0 ; 
for (Object x :coll){
ret[i++] = x;} 
return ret; }
 --- List<String> stringhe =
Arrays.asList("ciao","mondo"); 
String[] a = (String[])toArray(stringhe); //ClassCastError --> Erasure: inserisce il cast a String[]

Attenzione! Nonostante l'array contenga solamente stringhe, il suo tipo reifcato è un array di Object!

I cast inseriti dall'erasure non falliscono mai a parte quando viene generato un unchecked cast warning Quando viene generato un unchecked cast warning allora i cast inseriti dalla erasure

• Possono fallire
• Possono essere segnalati in parti del codice diferenti da quella che ha generato l'errore

A volte un modo per fare soldi è tramite altri soldi. Lo stesso si può applicare agli array: generare array tramite un altro array

public static <T>
 T[] toArray( Collection<T> coll, T[] arr){
 T[] ret = null; ret = (T[])java.lang.reflect.Array.newInstance
(arr.getClass().getComponentType(), // unchecked cast
coll.size());
int i = 0; for (T elem: coll) ret[i++] = elem; return ret; }
}

List<String> a= Arrays.asList("ciao","a");
String[] st = toArray(a, new String[0]);
for (String s: st) System.out.println(s);

• Ok! Funziona!
• Il metodo getCoponentType() restituisce un “Class Object” che rappresente il tipo dei componenti dell'Array T
• Class<?> ctype = arr.getClass().getComponentType(); Nel nostro caso è String

public static <T> T[] toArray( 
Collection<T> coll, Class<T> classse){
 T[] ret = null; 
 ret = (T[])java.lang.reflect.Array.newInstance (
   Classse, coll.size() ); 
 int i = 0; for (T elem: coll) ret[i++] = elem; 
return ret; }

List<String> a= Arrays.asList("ciao","a");
String[] st2 = toArray(a, String.class);