Java domanda semplice

ecco questo....grazie!

Errore scusate

Scusate non riesco a scrivere da ipad

errore di scrittura

errore di scrittura

public void print(List <? extends Number> list) {
for (Iterator<? extends Number> i = list.iterator(); i.hasNext( ); ) {
System.out.println(i.next());
}

public static void riempiLista(List<? super Integer> list) {
int size = list.size();
for (int i = 1; i <= size; i++) {
list.add(i);
}
System.out.println(list);
}

Inviato dal mio iPad utilizzando Tapatalk

Domanda il testo dice sul tema generics queste cose

Partendo dal fatto che i parametri di un metodo possono essere di tre tipi:
1.parametro che contiene dati da usare (“IN” parameter): esempio del metodo print();
2.parametro che deve essere aggiornato (“OUT” parameter): esempio riempilista

usare upper bounded wildcard per parametri di tipo 1;
usare lower bounded wildcard per parametri di tipo 2;

Perché? sopra troverete l'esempio di upper bound e lower bound. non capisco perchè se devo usare/riempire una list devo usare super invece se devo leggerla/print extends. in particolare avevo letto che i wildcard rendevano di sola lettura i tipi parametrici e quindi come lo si fa a riempire nel riempiLista? grazieee

Chiedo scusa ai moderatori e a tutti voi dei post duplicati....scusate

[tagan]

Originariamente inviato da vittorio130881

Domanda il testo dice sul tema generics queste cose

Partendo dal fatto che i parametri di un metodo possono essere di tre tipi:
1.parametro che contiene dati da usare (“IN” parameter): esempio del metodo print();
2.parametro che deve essere aggiornato (“OUT” parameter): esempio riempilista

usare upper bounded wildcard per parametri di tipo 1;
usare lower bounded wildcard per parametri di tipo 2;

Perché? sopra troverete l'esempio di upper bound e lower bound. non capisco perchè se devo usare una list devo usare super invece se devo leggerla extends. in particolare avevo letto che i wildcard rendevano di lettura il LISTarray e quindi come lo si riempie? grazieee

boooooooooh!!!!!!!!!
provo a risponderti, ma non ho capito molto cosa intendi

l'upper bounded wildcard cioè la wildcard limitata verso l'alto, significa che posso passare un parametro che è sottoclasse della classe dichiarata.
nell'esempio : print(List <? extends Number> list), accetta solo tipi che sono sottoclassi di Number (Float, Integer, Double, Short)
quindi posso usare un solo metodo per diverse Liste, senza necessariamente crearne una per ogni tipo.

il lower bounded wildcard funziona al contrario. accetta le superclassi di quella dichiarata. nell'esempio che hai riportato, riempiLista(List<? super Integer> list) il parametro che passi deve essere una lista di Integer, oppure una superclasse di Integer, quindi Number..... però genera errore se passi una lista di Float.

sinceramente ho sempre usato extends, mai super.

se dovessi inizializzare una lista con un metodo (modifichiamo il tuo), lo farei in questo modo:

public static void riempiLista(List<? super Integer> list) {
    int size = 10;
    for (int i = 1; i <= size; i++) {
        list.add(i);
    }
    System.out.println(list);
}

//per chiamare il metodo
List<Integer> li = new ArrayList<>();
riempiLista(li);

ho cambiato int size = list.size() perché se passo una lista vuota, size = 0 e non verrebbe mai riempita.
anche questo modo, può essere usato per riempire liste di oggetto che sono superclassi di classi definite da te (non considerare Integer, ma pensa a Dipendente , sottoclasse di Persona)

public class Persona {
    public String nome;
    public Persona(String nome){
        this.nome=nome;
    }
}

public class Dipendente extends Persona{
    public String ruolo;
    public Dipendente(String nome, String ruolo){
        super(nome);
        this.ruolo=ruolo;
    }
    
    public String toString(){
        return nome+"-"+ruolo;
    }
}

public static void riempiLista(List<? super Dipendente> list) {
    int size = 10;
    for (int i = 1; i <= size; i++) {
        list.add(new Dipendente("pippo",""+i));
    }
    System.out.println(list);
}



List<Persona> lp = new ArrayList<>();
riempiLista(lp);

altra cosa...... se scrivi :
public static void riempiLista(List<Dipendente> list)
il codice
List<Persona> lp = new ArrayList<>();
riempiLista(lp);

genera errore.


comunque, aspettiamo qualche esperto, perché oltre a dirti la differenza tra upper e lower, non capisco il metodo riempiLista scritto in quel modo!

una cosa però si puo dire. nel metodo riempiLista non ci puoi mettere:
riempiLista(List<? extends Number> list)
cosi scritta, il compilatore non riuscirebbe a capire che tipo verrà aggiunto e l'istruzione list.add(i) restituirà un errore.

PS: ma che libro stai studiando?

grazie a tagan! e grazie a tutti voi della pazienza

domanda finale sui generics
mi potete dire se ho capito bene?

i generics permettono di evitare i casting ovvero.....

ArrayList <Number> list = new ArrayList <Number>();
 list.add(1); list.add(2.0F); list.add(2.0D); list.add(2L); 
Iterator<Number> i = list.iterator(); while(i.hasNext()) 
{ Number n = i.next(); }

non serve fare il cast perchè il compilatore capisce da solo che è number.
invece quest altro codice

ArrayList list = new ArrayList();
list.add(1);
list.add(false);
list.add(‘c’);
int intero = (Integer) list.elementAt(0); boolean booleano = (Boolean) list.elementAt(1); character c = (Character) list.elementAt(2);

qui devo usare il cast perchè non cè il generics ma row types.

qualora usassi le wildcard cmq sia devo utilizzare uno stratagemma ovvero il metodo helper perchè il compilatore non capisce che sto usando una lista di stringhe :

public class WildCardTest {
void test(List<?> list) {
testHelper(list);
}
//Metodo helper
private <T> void testHelper (List<T> list) { list.set(0, list.get(0)); } }


List<String> param = getArrayListCompleto();
 WildCardTest wct = new WildCardTest();
 wct.test(param);