Genéricos do Android Kotlin: poderosa ferramenta de abstração e reutilização de tipos

1. O que são genéricos?

Genéricos é um mecanismo de tipo parametrizado que nos permite usar parâmetros de tipo ao definir classes, interfaces e métodos, conseguindo assim a reutilização de código e segurança de tipo. Usando genéricos, podemos passar tipos como parâmetros para classes ou métodos para obter adaptação flexível de tipos e operações em diferentes cenários.

2. Cenários de uso genérico

1. Aulas de coleção

No desenvolvimento Android, muitas vezes precisamos lidar com diversas coletas de dados, como listas, mapeamentos, etc. O uso de genéricos permite parametrizar os tipos de elementos de uma classe de coleção, melhorando assim a legibilidade do código e a segurança de tipo.

class MyList<T> {
    
    
    private val list: MutableList<T> = mutableListOf()

    fun add(item: T) {
    
    
        list.add(item)
    }

    fun get(index: Int): T {
    
    
        return list[index]
    }
}

// 使用示例
val myList = MyList<String>()
myList.add("Hello")
myList.add("World")
val item = myList.get(0)

2. Retornos de chamada de interface

Quando precisamos definir uma interface e passar diferentes tipos de parâmetros em métodos de interface, podemos usar genéricos para obter flexibilidade de tipo. Isso é muito comum no tratamento de eventos e nos mecanismos de retorno de chamada do Android.

interface OnItemClickListener<T> {
    
    
    fun onItemClick(item: T)
}

// 使用示例
val listener = object : OnItemClickListener<String> {
    
    
    override fun onItemClick(item: String) {
    
    
        // 处理点击事件
    }
}

3. Tarefas Assíncronas

No desenvolvimento, muitas vezes precisamos realizar tarefas assíncronas, como solicitações de rede, operações de banco de dados, etc. O uso de genéricos pode tornar nossas tarefas assíncronas mais flexíveis e lidar com diferentes tipos de entrada e saída.

class NetworkTask<T> {
    
    
    fun execute(url: String, callback: (result: T) -> Unit) {
    
    
        // 执行网络请求，并返回结果
        val result: T = ...
        callback(result)
    }
}

// 使用示例
val task = NetworkTask<String>()
task.execute("https://example.com") {
    
     result ->
    // 处理网络请求结果
}

3. Vantagens e precauções dos genéricos

1. Reutilização de código: os genéricos podem melhorar a reutilização do código, reduzir a redundância do código e alcançar a versatilidade de classes e métodos por meio de tipos parametrizados.
2. Segurança de tipo: o uso de genéricos pode detectar erros de tipo em tempo de compilação e evitar exceções de conversão de tipo em tempo de execução.
3. Erasure (Type Erasure): Em Java e Kotlin, as informações de tipo dos genéricos são apagadas em tempo de execução, o que significa que não podemos obter os parâmetros de tipo reais dos genéricos em tempo de execução. Observe que o apagamento pode ser restrito em alguns cenários.

Obrigado pela leitura, Atenciosamente!