[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?