这是我参与「第四届青训营」笔记创作活动的的第1天

声明&&定义

变量

使用 val , var 来声明变量：

val : 声明不可变的变量，相当于使用 final 修饰的变量
var : 声明可变的变量，相当于没有使用 final 修饰的变量

定义类型：

在变量名后使用 :类型 的形式定义变量类型

int：val i : Int
float：val f : Float
long：val l : Long
double：val d : Double
short：val s : short
boolean：val b : Boolean
char：val c : Char
byte：val b : Byte

函数

fun 函数名(参数名: 类型): 返回值类型{}

import kotlin.math.max

fun main() {
    val a = 37
    val b = 40
    val value = largerNumber(a, b)
    println("The larger number is $value")
}

fun largerNumber(a: Int, b: Int): Int {
    return max(a, b)
}

类

class Person {
  var name = ""
  var age = 0
  
  fun eat() {
    println("$name is eating. He is $age years old.")
  }
}

继承

在 kotlin 中任何一个非抽象类默认使用 final 修饰，不可继承。

使其可继承，使用 open 修饰：

open class Person{
  ...
}

主构造函数

主构造函数的特点是没有函数体，直接定义在类名后面即可：

class Person(val name:String, val age:Int){
  ...
}

init 结构体，所有主构造函数的逻辑都写在里面：

class Person(val name:String, val age:Int){
  init{
    ...
  }
  ...
}

继承

当继承时，父类有主构造函数，须添加括号：

class Student() : Person(){
  ...
}

次构造函数

次构造函数是通过 constructor 关键字定义

注：当一个类既有主构造函数又有次构造函数时，所有次构造函数都必须调用主构造函数（包括间接调用）

class Student(val sno: String, val grade: Int, name: String, age: Int) : 
    Person(name, age) { //1
  constructor(name: String, age: Int) : this("", 0, name, age) { } //2
  constructor() : this("", 0) { } //3
}

③调用②（间接调用主构造函数），②调用①（直接调用主构造函数）。

接口

interface 定义一个接口：

interface Study { 
  fun readBooks() 
  fun doHomework()
}

接口的默认实现：

interface Study { 
  fun readBooks()
  fun doHomework() { 
    println("do homework default implementation.")
  }
}

操作

if

类似 java 写法：

fun largerNumber(num1: Int, num2: Int): Int { 
  var value = 0 
  if (num1 > num2) { 
    value = num1
  } else { 
    value = num2
  } 
  return value
}

kotlin 中 if 语句具有返回值：

fun largerNumber(num1: Int, num2: Int): Int { 
  val value = if (num1 > num2) { 
    num1
  } else { 
    num2
  } 
  return value
}

精简 value 变量：

fun largerNumber(num1: Int, num2: Int): Int { 
  return if (num1 > num2) { 
    num1
  } else { 
    num2
  }
}

精简 return 语句：

fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) { 
  num1
} else { 
  num2
}

压缩：

fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) num1 else num2

when

相当于 java 中的 case 语句，但是更好用：匹配值 -> { 执行逻辑 }

fun getScore(name: String) = if (name == "Tom") { 
    86
  } else if (name == "Jim") { 
    77
  } else if (name == "Jack") { 
    95
  } else if (name == "Lily") { 
    100
  } else { 
    0
}

改成 when写法：

fun getScore(name: String) = when (name) { 
  "Tom" -> 86 
  "Jim" -> 77 
  "Jack" -> 95 
  "Lily" -> 100 
  else -> 0
}

另一种 when 写法：

fun getScore(name: String) = when { 
  name.startsWith("Tom") -> 86 
  name == "Jim" -> 77 
  name == "Jack" -> 95 
  name == "Lily" -> 100 
  else -> 0
}

类型匹配

when语句还允许进行类型匹配

fun checkNumber(num: Number) { 
  when (num) {
  is Int -> println("number is Int") 
  is Double -> println("number is Double") 
  else -> println("number not support")
  }
}

for

left..right

.. 是创建两端闭区间的关键字，创建左闭右闭的区间： $[left,right]$

fun main() { 
  for (i in 0..10) { 
    println(i)
  }
}

输出：0 1 2 3 4 5 6 7 8 9 10

until

until 创建左闭右开区间： $[left, right)$

fun main() { 
  for (i in 0 until 10) { 
    println(i)
  }
}

输出：0 1 2 3 4 5 6 7 8 9

step

step 指定步长

fun main() { 
  for (i in 0 until 10 step 2) { 
    println(i)
  }
}

输出：0 2 4 6 8

downTo

创建一个左闭右闭的降序区间

fun main() { 
  for (i in 10 downTo 1) { 
    println(i)
  }
}

输出：10 9 8 7 6 5 4 3 2 1

一文简单了解 Kotlin 语法 ｜ 青训营笔记