Hol használt generikusokat a fejlesztési…

Általános típusokat használt:

A típusbiztos gyűjtemények megvalósításához. Például, ArrayList<MyObject> a nyers ArrayList helyett, ami megakadályozza a típuskonverziós hibákat futás közben.

// Nem típusbiztos megközelítés (nyers típus)
List list = new ArrayList();
list.add("Sor");
list.add(123); // int hozzáadása

// Típusbiztos megközelítés generikusokkal
List<String> stringList = new ArrayList<>();
stringList.add("Sor");
// stringList.add(123); // A fordító hibát jelez

Az általános RecyclerView adapterek létrehozásához. Lehetővé teszi az adapter logikájának újrahasznosítását különböző adat típusokra.

// Általános ViewHolder példa
class GenericViewHolder<T>(itemView: View) : RecyclerView.ViewHolder(itemView) {
    fun bind(item: T) {
        // Adatok kötése a T típus szerint
    }
}

// Általános adapter példa
class GenericAdapter<T>(private val items: List<T>) : RecyclerView.Adapter<GenericViewHolder<T>>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): GenericViewHolder<T> {
        // ViewHolder létrehozása
    }

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

    override fun getItemCount() = items.size
}

Objektumgyárak létrehozásához. A konkrét típusú objektum eléréséhez anélkül, hogy explicit típuskonverziót kellene végezni.

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

class StringFactory : Factory<String> {
    override fun create(): String {
        return "Új sor";
    }
}

class IntegerFactory : Factory<Int> {
    override fun create(): Int {
        return 100;
    }
}

Factory<String> stringFactory = StringFactory();
val myString: String = stringFactory.create(); // String típusú érték, konverzió nélkül

A típusok korlátozásához metódusokban és osztályokban. Korlátozott generikusok használata (<T extends MyInterface> vagy <T super MyClass>) annak biztosítására, hogy a generikus típus egy adott interfészt valósít meg vagy egy adott osztályból öröklődik.
```
// Metódus, amely egy Serializable-t megvalósító elemek listáját fogadja
public <T extends Serializable> void saveObjectList(List<T> list) {
    // Mentési logika
}
```

Az architekturális komponensekben. Például, amikor LiveData vagy ViewModel használatával dolgozik, gyakran generikusokat használnak az általuk kezelt adatok típusának meghatározására.

// LiveData egy adott típusú objektumok listájához
val myData: LiveData<List<MyItem>> = // inicializálás

// ViewModel egy adott típusú adatokkal
class MyViewModel : ViewModel() {
    val data: MutableLiveData<MyStateType> by lazy {
        MutableLiveData<MyStateType>()
    }
}

Hálózati kliens fejlesztésekor. Az automatikus deserializáció a szerver válaszainak adott típusú objektumokra.

// Retrofit szolgáltatás példa generikus válasszal
interface ApiService {
    @GET("users")
    Call<List<User>> getUsers();

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

A generikusok jelentősen növelték a típusbiztonságot, olvashatóságot és a kód újrahasznosíthatóságát.

Hol használt generikusokat a fejlesztési tapasztalatod során?