https://zhuanlan.zhihu.com/p/36079284
Para apresentar a gramática básica do Kotlin, primeiro experimente o estilo de programação do Kotlin como um todo.
1. A declaração do pacote
Definir um pacote em Kotlin é um pouco diferente de Java. Em Kotlin, o diretório e a estrutura do pacote não precisam ser iguais. O código-fonte do Kotlin pode estar em qualquer lugar do disco.
- 1. A declaração do pacote
O arquivo de origem geralmente é igual ao Java no início da declaração do pacote.
package com.mikyou.hellokotlin
/**
* Created by mikyou on 2018/4/1.
*/
fun main(args: Array<String>) {
println("Hello Kotlin")
}
- 2. A importação padrão do pacote
Existem vários pacotes que são importados para cada arquivo Kotlin por padrão.
Em segundo lugar, a definição da função
- 1. A definição da função usa a palavra-chave "fun", o formato do parâmetro da função é: "parâmetro: tipo", o tipo de valor de retorno da função "fun (...): Int"
fun sum(a: Int, b: Int, c: Int): Int {
return a + b + c
}
- 2. A expressão é o corpo da função e o tipo do valor de retorno pode ser omitido. Você pode usar a função de inferência de tipo de Kotlin para inferir o tipo do valor de retorno da função.
fun sum(a: Int, b: Int, c: Int) = a + b + c
- 3. Funções sem valor de retorno (semelhante ao valor de retorno void em Java)
fun printSum(a: Int, b: Int, c: Int): Unit {
println(a + b + c)
}Ou omita o tipo de unidade
fun printSum(a: Int, b: Int, c: Int) {
println("sum = ${a + b + c}")
}
- 4. As funções de parâmetro de comprimento variável podem usar a palavra-chave "vararg" para identificar public void setData (Object ... objects) semelhante a Java.
fun vars(vararg args: Int) {
for (arg in args) {
print(arg)
}
}
- 5. Lambda (função anônima)
val sumLambda: (Int, Int, Int) -> Int = { a, b, c -> a + b + c }teste
println("sum = ${sumLambda(1, 6, 7)}")Três, constantes e variáveis
Constantes e variáveis podem não ter valor de inicialização, mas o compilador deve ser inicializado antes de ser referenciado.O compilador suporta julgamento automático de tipo, ou seja, o tipo não pode ser especificado quando é declarado e o compilador julga. Se não for inicializado no momento da declaração, o tipo da variável deve ser fornecido
- 1. Definição de variáveis variáveis: palavra-chave var
var <nome da variável>: <tipo de variável> = <valor inicial>
var sum: Int = 3
sum = 8
//由于编译支持类型推导可以省略Int类型
var sum = 3
sum = 8
- 2. A definição de variáveis imutáveis: a palavra-chave val, que não pode ser atribuída duas vezes, semelhante ao tipo final em Java
val <nome da constante>: <tipo de constante> = <valor inicial>
val sum: Int //没有赋值初始化之前必须指定类型
sum = 5`` `kotlin
fun sum (a: Int, b: Int, c: Int): Int { return a + b + c }
<h3 id = "4">四、注释</h3>
> Kotlin 支持单行和多行注释，和java中类似。
<h3 id = "5">五、字符串模板</h3>
* 1、模板中的简单名称
```kotlin
fun main(args: Array<String>) {
var a = 1
var s1 = "a is $a"
}
- 2. Qualquer expressão no modelo
fun main(args: Array<String>) {
var a = 1
a = 2
val s2 = "${s1.replace("is", "was")}, but now is $a"
}Seis, use expressões condicionais
- Use a expressão if para substituir o operador ternário em java
fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}
fun main(args: Array<String>) {
println(maxOf(1, 5))
}A expressão if em Kotlin tem um valor de retorno, portanto, pode ser simplificada da seguinte forma.
fun maxOf(a: Int, b: Int) = if (a > b) a else b
fun main(args: Array<String>) {
println(maxOf(1, 5))
}Sete, mecanismo de verificação NULL
Os parâmetros do projeto de segurança aérea Kotlin para a declaração podem estar vazios, quando em uso para ser o processo de julgamento vazio, há duas abordagens, o campo mais !! como Java lança uma exceção vazia , outro campo após a adição? Não é possível fazer O valor de retorno do processamento é nulo ou cooperar ?: processamento de julgamento breve
//类型后面加?表示可为空
var age: String? = "23"
//字段后面加"!!"抛出空指针异常
val ages = age!!.toInt()
//字段后面加”？“不做处理返回 null
val ages1 = age?.toInt()
//使用”?:“ 表示age为空返回-1
val ages2 = age?.toInt() ?: -1
- 1. Quando uma referência pode ter um valor nulo, a declaração de tipo correspondente deve ser claramente marcada como "?" Após o tipo para indicar que ele pode ser nulo.
Quando o conteúdo da string em str não é um inteiro, retorna nulo:
fun main(args: Array<String>) {
if (args.size < 2) {
println("Two Integers Expected")
return
}
val x = parseInt(args[0])
val y = parseInt(args[1])
//println(x + y) 由于标识了可能为null,直接使用x + y在编译器看来是非法，需要去做非空判断
if (x != null && y != null) {
println(x + y)
}
}
fun parseInt(s: String): Int? {//表示当前函数返回值可能为null,就必须在类型后面标识"?"
return s.toInt()
}Oito, detecção de tipo e conversão automática de tipo
Podemos usar o operador is para verificar se uma expressão é uma instância de um certo tipo (semelhante à palavra-chave instanceof em Java).
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// 做过类型判断以后，obj会被系统自动转换为String类型
return obj.length
}
//在这里还有一种方法，与Java中instanceof不同，使用!is
// if (obj !is String){
// // XXX
// }
// 这里的obj仍然是Any类型的引用
return null
}ou
fun getStringLength(obj: Any): Int? {
if (obj !is String)
return null
// 在这个分支中, `obj` 的类型会被自动转换为 `String`
return obj.length
}Pode até ser assim
fun getStringLength(obj: Any): Int? {
// 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
if (obj is String && obj.length > 0)
return obj.length
return null
}Nove, intervalo
Use o operador in para detectar se um número está dentro de um intervalo especificado. A expressão de intervalo tem a forma de operador ".." função rangeTo para ajudar na combinação e! O intervalo pode suportar qualquer tipo que possa ser comparado.Para o tipo inteiro nativo, há uma implementação otimizada interna.
- 1. Detecte se um número está dentro de um intervalo especificado
val x = 10
val y = 9
if (x in 1..y + 1) {//表示x是否在1~y+1范围内。
println("fits in range")
}
- 2. Detectar se um número está fora do intervalo especificado
val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
println("-1 is out of range")
}
if (list.size !in list.indices) {
println("list size is out of valid list indices range too")
}
- 3. Intervalo de iteração
for(x in 1..10){//相当于 x >= 1 && x <= 10
println(x)
}ou
fun printList(num: Int) {
for (i in 1..num) {//相当于 i >= 1 && i <= num
print(i)
}
}Use a função até para excluir elementos finais
for (i in 1 until 10) {// i in [1, 10) 排除了 10,相当于 i >= 1 && i < 10
println(i)
}
- 4. Iteração de sequência
for(x in 1..100 step 2){//递增数列迭代，每次间隔步长是2；1，3，5，7...
println(x)
}
for(x in 9 downTo 0 step 3){//递减数列迭代，每次间隔步长是3；9，6，3，0
println(x)
}10. Use coleções
- 1. Repita a coleção
fun main(args: Array<String>) {
val items = list.of("java", "kotlin", "python")
for (item in items) {
println(item)
}
}
- 2. Use o operador in para determinar se um conjunto contém uma instância
when {
"java" in items -> println("is good lang")
"kotlin" in items -> println("is good good lang")
else -> println("python is best lang")
}
- 3. Use expressões lambda para filtrar e mapear coleções
fun main(args: Array<String>) {
val langs = listOf("C", "C++", "Java", "Python", "JavaScript")
langs.filter { it.startsWith("C") }
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { println(it) }
}11. Use loop
Existem duas maneiras de fazer um loop em Kotlin: for, while, use "in" para percorrer o loop for e há dois métodos de travessia.
- 1. For loop
val items = listOf("java", "kotlin", "android")
for (item in items) {//for遍历集合
println("lang $item")
}
for (index in items.indices) {//类似于java中的数组的length-index的遍历
println("The $index index is ${items[index]}")
}
- 2. O loop while
val items = listOf("java", "kotlin", "android")
var index = 0
while (index < items.size) {//while 循环的遍历方式
println("The $index lang is ${items[index++]}")
}Doze, condições de uso se, quando
O uso de if em kotlin é semelhante a java, mas se em kotin é uma expressão que tem valor e em java é uma declaração, você pode usar if expression em kotlin para substituir o operador ternário em java em kotlin. quando é semelhante a mudar
fun main(args: Array<String>) {
println(descript("hello"))
}
fun descript(obj: Any): String = when (obj) {
1 -> "one"
"hello" -> "hello word"
is Long -> "long type"
!is String -> "is not String"
else -> {
"unknown type"
}
}Treze, crie classes e instâncias
fun main(args: Array<String>) {
val rectangle = Rectangle(100.0, 200.0)
val triangle = Triangle(100.0, 100.0, 100.0)
println("rectangle is ${rectangle.isSquare}, and perimeter is ${rectangle.perimeter}, and area is ${rectangle.calculateArea()}")
println("triangle perimeter is ${triangle.perimeter}, and area is ${triangle.calculateArea()}")
}
abstract class Shape(val sides: List<Double>) {
val perimeter: Double get() = sides.sum()
abstract fun calculateArea(): Double
}
interface RectangleProperity {
val isSquare: Boolean
}
class Rectangle(var height: Double, var length: Double)
: Shape(listOf(height, length, height, length)), RectangleProperity {
override fun calculateArea(): Double = height * length
override val isSquare: Boolean get() = height == length
}
class Triangle(var sideA: Double, var sideB: Double, var sideC: Double)
: Shape(listOf(sideA, sideB, sideC)) {
override fun calculateArea(): Double = sideA * sideB * sideC
}Neste ponto, a gramática básica da entrada do Kotlin acabou. O próximo artigo continuará a mergulhar no conteúdo relacionado ao Kotlin.