Diário de aprendizado do desenvolvimento do Android no quarto dia do capítulo externo _ arroz frito com Kotlin - quanto mais frito, menor - notas de alegria de Mo Yunle

Diário de Aprendizado de Desenvolvimento do Android no quarto dia do capítulo externo - arroz frito frito Kotlin - quanto mais frito, menor

O
primeiro dia do diário de
aprendizado de desenvolvimento Android_Android Studio3.6 instala o diário de aprendizado de desenvolvimento Android no segundo dia_o poço que destrói a sincronização do cartão de interceptação
diário de aprendizado de desenvolvimento Android terceiro dia_newbie button
Diário de aprendizado de desenvolvimento Android quarto dia_ Pode subir e correr

Desta vez, vamos tentar usar o kotlin para escrever um jogo pequeno como o diário do quarto dia, além de um efeito de redefinição automática

Preparação

Como executar o código a seguir em seu próprio Android Studio, escolha o idioma kotlin ao criar o projeto

conteúdo de activity_main.xml

O conteúdo é o mesmo do quarto dia. Você pode obter o diário de aprendizado de desenvolvimento do Android diretamente do
diário do quarto dia

Conteúdo principal de MainActivity.kt

Declarar variáveis

Podemos ver que o kotlin é uma linguagem fortemente tipada, não apenas var e val podem ser usados para especificar se uma variável é variável ou somente leitura , mas também um tipo pode ser adicionado após a variável para implementar seu mecanismo de inferência de tipo

 	//声明一个对象数组类型是Button，名字是buttons
    private var buttons = arrayOfNulls<Button>(10)
    //按钮的标签，用于判断按钮是否可见，用布尔数组表示
    private var flag: Array<Boolean> = arrayOf(true,true,true,true,true,true,true,true,true,true)
    //用于存放布局中按钮的ID，我们可以看出R.id.XX的类型是Int
    private val buttonID: Array<Int> = arrayOf(0,R.id.button1,R.id.button2,R.id.button3,R.id.button4,R.id.button5,R.id.button6,R.id.button7,R.id.button8,R.id.button9)
    //用于计算你点击了多少次
    private var count = 0

Instanciar uma matriz de objetos

Neste código, podemos ver dois açúcares sintáticos.Quando existe apenas uma instrução na estrutura do loop ou na estrutura de seleção, escrever o seguinte formulário pode simplificar o código e usá-lo de forma mais conveniente (o açúcar da sintaxe também é equivalente a nós Expressões idiomáticas em chinês, a concentração é a essência)

	override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        //利用循环简化赋值过程
        for(i in 1..9)buttons[i] = findViewById(buttonID[i])
        //需要传入接口实现类的实例。
        //此时接口实现类的实例为MainActivity
        for (j in 1..9) buttons[j]?.setOnClickListener(this)
    }

Há um "?" Atrás dos botões [i] no segundo loop for. Esse pequeno ponto de interrogação é usado para julgar nulo, porque quando escrevemos código, não sabemos necessariamente se um ponteiro nulo aparece durante a operação real, portanto, precisamos "Para julgar que o objeto está vazio.
Correspondentemente, se determinarmos que esse objeto não será um ponteiro nulo, podemos usar a declaração de afirmação não vazia" !! "para melhorar a eficiência da operação

O terceiro passo: escreva uma função para alterar o estado do botão, mova a interface de alteração do estado do botão para dentro

Quando você vê aqui, definitivamente encontrará que o loop for do kotlin é muito semelhante ao loop for do python, mas possui mais parênteses do que o loop for do python, onde 0..4 significa um intervalo fechado de 0 a 4.

	private fun convertBoolean(a: Int, b: Int, c: Int, d: Int, e: Int){
        val flags: Array<Int> = arrayOf(a,b,c,d,e)
        //根据传入的参数转换flag的值
        for(i in 0..4) if (flags[i] != 0)flag[flags[i]] = !flag[flags[i]]
        //按钮状态变换接口
        showButton()
    }

Etapa 4: realize a função de exibir e ocultar botões, detecte se o jogo acabou e redefina o jogo

O loop for aqui usa a sintaxe when do kotlin em vez da instrução switch do Java (o número de linhas estranhas é reduzido)

	private fun showButton(){
        var tag = 0
        //根据标签的状态实现按钮是否可见
        for(i in 1..9)when (flag[i]) {
                true -> buttons[i]?.visibility = View.VISIBLE//使按钮可见
                false -> buttons[i]?.visibility = View.INVISIBLE//使按钮不可见
        }
        //记录点击次数
        count++
        //检查标签的状态
        for (i in 1..9)if(!flag[i])tag++
        //在屏幕中弹出消息
        if(tag == 9){
            Toast.makeText(this,"恭喜你赢得了游戏!\n本次游戏你一共点击了"+count+"次！", Toast.LENGTH_LONG).show()
            //完成游戏后按钮复位
            for (i in 1 .. 9)convertBoolean(i,0,0,0,0)
        }
    }

Etapa 5: defina o evento de clique (é por isso que eu gosto do kotlin)

Você pode voltar ao diário do último dia para contar o número de linhas neste parágrafo. Usei algumas linhas com kotlin (kotlin). O
diário do quarto dia está
aqui. O v in quando também está vazio.

	override fun onClick(v: View?) {
        when(v?.id) {
            R.id.button1 -> convertBoolean (1,2,4,0,0)  //改变对于按钮的状态标签
            R.id.button2 -> convertBoolean (1,2,3,5,0)  //改变对于按钮的状态标签
            R.id.button3 -> convertBoolean (2,3,6,0,0)  //改变对于按钮的状态标签
            R.id.button4 -> convertBoolean (1,4,5,7,0)  //改变对于按钮的状态标签
            R.id.button5 -> convertBoolean (2,4,5,6,8)  //改变对于按钮的状态标签
            R.id.button6 -> convertBoolean (3,5,6,9,0)  //改变对于按钮的状态标签
            R.id.button7 -> convertBoolean (4,7,8,0,0)  //改变对于按钮的状态标签
            R.id.button8 -> convertBoolean (5,7,8,9,0)  //改变对于按钮的状态标签
            R.id.button9 -> convertBoolean (6,8,9,0,0)  //改变对于按钮的状态标签
        }
    }

Em seguida é o efeito de execução

Podemos descobrir que o efeito é o mesmo, mas a quantidade de código é reduzida

Se você acha que é bom, por favor, marque como favorito, obrigado por assistir