Waar hebt u generieke types gebruikt in uw…

Gebruik van generics:

Voor het implementeren van type-veilige collecties. Bijvoorbeeld, ArrayList<MyObject> in plaats van ruwe ArrayList, wat runtime-fouten gerelateerd aan typecasting voorkomt.

// Onveilige aanpak (ruwe type)
List list = new ArrayList();
list.add("String");
list.add(123); // Voegt int toe

// Type-veilige aanpak met generics
List<String> stringList = new ArrayList<>();
stringList.add("String");
// stringList.add(123); // Compiler geeft fout

Voor het maken van universele adapters voor RecyclerView. Hiermee kan de adapterlogica worden hergebruikt voor verschillende gegevenstypen.

// Voorbeeld van een universele ViewHolder
class GenericViewHolder<T>(itemView: View) : RecyclerView.ViewHolder(itemView) {
    fun bind(item: T) {
        // Logica voor het binden van gegevens afhankelijk van het type T
    }
}

// Voorbeeld van een universele adapter
class GenericAdapter<T>(private val items: List<T>) : RecyclerView.Adapter<GenericViewHolder<T>>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): GenericViewHolder<T> {
        // ViewHolder maken
    }

    override fun onBindViewHolder(holder: GenericViewHolder<T>, position: Int) {
        holder.bind(items[position])
    }

    override fun getItemCount() = items.size
}

Voor het maken van objectfabrieken. Om een specifiek type object te verkrijgen zonder expliciete conversie.

interface Factory<T> {
    T create();
}

class StringFactory implements Factory<String> {
    @Override
    public String create() {
        return "Nieuwe string";
    }
}

class IntegerFactory implements Factory<Integer> {
    @Override
    public Integer create() {
        return 100;
    }
}

Factory<String> stringFactory = new StringFactory();
String myString = stringFactory.create(); // Krijg een String zonder conversie

Om typen in methoden en klassen te beperken. Gebruik van beperkte generics (<T extends MyInterface> of <T super MyClass>) om te garanderen dat de generieke type een bepaalde interface implementeert of van een bepaalde klasse erft.
```
// Methode die een lijst accepteert van elementen die Serializable implementeren
public <T extends Serializable> void saveObjectList(List<T> list) {
    // Opslaglogica
}
```

In architectonische componenten. Bijvoorbeeld bij het werken met LiveData of ViewModel, waar generics vaak worden gebruikt om het gegevens type te definiëren dat ze beheren.

// LiveData voor een lijst van objecten van een bepaald type
val myData: LiveData<List<MyItem>> = // initialisatie

// ViewModel met gegevens van een bepaald type
class MyViewModel : ViewModel() {
    val data: MutableLiveData<MyStateType> by lazy {
        MutableLiveData<MyStateType>()
    }
}

Bij het ontwikkelen van netwerkcliënten. Voor automatische deserialisatie van serverantwoorden naar objecten van een bepaald type.

// Voorbeeld van een Retrofit-service met generiek in de response
interface ApiService {
    @GET("users")
    Call<List<User>> getUsers();

    @GET("products/{id}")
    Call<Product> getProduct(@Path("id") String productId);
}

Generics hebben de typeveiligheid, leesbaarheid en hergebruikbaarheid van code aanzienlijk verbeterd.

Waar hebt u generieke types gebruikt in uw ontwikkelervaring?