Olá novamente! Antecipando o início do curso básico de desenvolvimento para Android , compartilhamos a parte final do artigo "16 dicas de desenvolvimento para android na linguagem Kotlin".
Leia a primeira parteLeia a segunda parteLATEINIT
Um dos principais recursos do Kotlin é o seu compromisso com a segurança zero. A declaração lateinit fornece uma maneira fácil de garantir segurança zero e inicializar a variável conforme o Android exigir. Esse recurso é ótimo, no entanto, você deve se acostumar com ele depois de trabalhar em Java. Uma ideia é que o campo seja imediatamente declarado com a capacidade de ser nulo:
var total = 0 var toolbar: Toolbar? = null
Essa função de idioma pode causar dificuldades ao trabalhar com layouts do Android, porque não sabemos como declarar visualizações antes da declaração do layout, porque não está claro onde elas existirão em
Activity ou
Fragment . Isso é compensado por testes adicionais para a possibilidade de um valor zero em todos os lugares com os quais interagimos, mas este ainda é hemorróidas. Portanto, é melhor usar o modificador
lateinit :
lateinit var toolbar: Toolbar
Agora, como desenvolvedor, você não deve consultar a Barra de Ferramentas até que ela seja realmente inicializada. Isso funciona muito bem quando usado em conjunto com uma biblioteca como o
Butter Knife :
@BindView(R.id.toolbar) lateinit var toolbar: Toolbar override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) ButterKnife.bind(this)
Tipo Segurança
Algumas convenções do Android exigem digitação segura, porque a digitação regular não exclui erros de código. Por exemplo, uma maneira típica de criar um fragmento em ação envolve verificar o FragmentManager para garantir que ele já exista. E somente se não for, você o cria e o adiciona à ação. Quando você primeiro digita o Kotlin, pode implementar isso da seguinte maneira:
var feedFragment: FeedFragment? = supportFragmentManager .findFragmentByTag(TAG_FEED_FRAGMENT) as FeedFragment . as , . : var feedFragment: FeedFragment? = supportFragmentManager .findFragmentByTag(TAG_FEED_FRAGMENT) as? FeedFragment if (feedFragment == null) { feedFragment = FeedFragment.newInstance() supportFragmentManager.beginTransaction() .replace(R.id.root_fragment, feedFragment, TAG_FEED_FRAGMENT) .commit() }
ALAVANCA DE LETRA
A alavancagem permite que você execute um bloco se o valor do objeto for diferente de zero. Isso permite evitar verificações nulas e torna o código mais legível. Em Java, fica assim:
if (currentUser != null) { text.setText(currentUser.name) } Kotlin : user?.let { println(it.name) }
Esse código é muito mais legível, além de criar automaticamente uma variável com um valor diferente de zero, sem o risco de zerá-lo.
SNULLOREMPTY | ISNULLORBLANK
Temos que verificar os campos várias vezes durante o desenvolvimento do aplicativo Android. Se você conseguiu isso sem usar o Kotlin, provavelmente conhece a classe TextUtils no Android. A classe TextUtils é a seguinte:
if (TextUtils.isEmpty(name)) {
Neste exemplo, você notará que o usuário pode definir apenas espaços como o nome de usuário e ele passará no teste.
isNullOrEmpty e
isNullOrBlank estão integrados na linguagem Kotlin, eliminam a necessidade de
TextUtils.isEmpty (
someString ) e fornecem o benefício adicional de verificar apenas espaços. Se necessário, você pode usar algo como isto:
A verificação da correção do preenchimento dos campos geralmente é encontrada quando o registro é necessário no aplicativo. Esses métodos internos são ótimos para verificar o campo e alertar o usuário se algo estiver errado. Para verificações mais complexas, você pode usar métodos de extensão, por exemplo, para endereços de email:
fun TextInputLayout.isValidForEmail(): Boolean { val input = editText?.text.toString() if (input.isNullOrBlank()) { error = resources.getString(R.string.required) return false } else if (emailPattern.matcher(input).matches()) { error = resources.getString(R.string.invalid_email) return false } else { error = null return true } }
Dicas para o avançado
Você sabia que pode usar expressões lambda para criar código mais limpo e conciso?
Por exemplo, ao trabalhar em Java, é típico ter uma classe de ouvinte simples, como:
public interface OnClickListener { void onClick(View v); }
Uma característica distintiva do Kotlin é que ele executa conversões SAM (método abstrato único) para classes Java. Um ouvinte de clique em Java que se parece com:
textView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) {
Curiosamente, essa conversão não é possível para interfaces SAM criadas no Kotlin. Isso pode surpreender e até desapontar um pouco os novos usuários do Kotlin. Se a mesma interface fosse definida no Kotlin, o ouvinte se pareceria com isso:
view.setOnClickListener(object : OnClickListener { override fun onClick(v: View?) {
Para encurtar esse código, você pode escrever seus ouvintes na classe da seguinte maneira:
private var onClickListener: ((View) -> Unit)? = null fun setOnClickListener(listener: (view: View) -> Unit) { onClickListener = listener }
Isso fará com que você retorne a uma sintaxe lambda simples que possibilita a conversão automática do SAM.
Conclusão
Eu coletei os hacks mais úteis de tudo o que aprendi desde que me interessei pela linguagem Kotlin. Espero que o conhecimento dessas dicas o ajude significativamente no desenvolvimento de seus próprios projetos.
Só isso. Vejo você no
curso !