Kus kasutasite generikke oma arendus kogemuses…

Kasutades generikke:

Tüüpide ohutute kogumite rakendamiseks. Näiteks ArrayList<MyObject> asemel toor-ArrayList, mis takistab jooksuaegseid tüüpi vigu.

// Tüübiturv lähenemine (toor-tüüp)
List list = new ArrayList();
list.add("Rida");
list.add(123); // Lisame int

// Tüübiturv lähenemine generike kasutades
List<String> stringList = new ArrayList<>();
stringList.add("Rida");
// stringList.add(123); // Kompilaator annab vea

Universaalseid adaptereid RecyclerView jaoks. Annab võimaluse taaskasutada adapteri loogikat erinevat tüüpi andmete jaoks.

// Näide universaalsest ViewHolderist
class GenericViewHolder<T>(itemView: View) : RecyclerView.ViewHolder(itemView) {
    fun bind(item: T) {
        // Andmete sidumise loogika vastavalt T tüübile
    }
}

// Näide universaalsest adapterist
class GenericAdapter<T>(private val items: List<T>) : RecyclerView.Adapter<GenericViewHolder<T>>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): GenericViewHolder<T> {
        // ViewHolderi loomine
    }

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

    override fun getItemCount() = items.size
}

Objektide tehase loomine. Saada konkreetne tüüp ilma otsese teisenduseta.

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

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

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

Factory<String> stringFactory = new StringFactory();
String myString = stringFactory.create(); // Saad Stringi ilma teisenduseta

Tüüpide piirangud meetodites ja klassides. Kasutades piiratud generikke (<T extends MyInterface> või <T super MyClass>) tagatakse, et generik-tüüp realiseerib teatud liidese või pärib teatud klassist.
```
// Meetod, mis võtab vastu objekti nimekirja, mis realiseerivad Serializable
public <T extends Serializable> void saveObjectList(List<T> list) {
    // Salvestusloogika
}
```

Arhitektuurikomponentides. Näiteks töötades LiveData või ViewModel-iga, kasutatakse sageli generikke andmetüübi määratlemiseks.

// LiveData konkreetse tüüpi objektide nimekirja jaoks
val myData: LiveData<List<MyItem>> = // initsialiseerimine

// ViewModel konkreetse tüüpi andmetega
class MyViewModel : ViewModel() {
    val data: MutableLiveData<MyStateType> by lazy {
        MutableLiveData<MyStateType>()
    }
}

Võrgu klientide arendamiseks. Automaatne vastuste deserialiseerimine serveri vastustest konkreetse tüübi objektideks.

// Retrofit teenuse näide generikuga vastuses
interface ApiService {
    @GET("users")
    Call<List<User>> getUsers();

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

Generikud on oluliselt tõstnud tüübiohutust, loetavust ja koodi taaskasutusvõimalusi.

Kus kasutasite generikke oma arendus kogemuses?