Kotlin的基本语法和类型

基本类型

Kotlin 中使用的基本类型：数字、字符、布尔值、数组与字符串。

数字

表示方式

在Kotlin中数值长亮可用字面表达有：

• 十进制: 123 Long 类型用大写 L 标记: 123L
• 十六进制: 0x0F
• 二进制: 0b00001011

自1.1起可以使用下划线使数字常量更易读：

val oneMillion = 1_000_000                         => 100000
val creditCardNumber = 1234_5678L                  => 12345678
val socialSecurityNumber = 999_99_9999L            => 999999999
val hexBytes = 0xFF_EC_DE_5E                       => 4293713502
val bytes = 0b11010010_01101001_10010100_10010010  =>3530134674

类型转换

类型转换有两种：

• 隐式转换

val a: Int? = 1 // 一个装箱的 Int (java.lang.Integer)
val b: Long? = a // 隐式转换产生一个装箱的 Long (java.lang.Long)
Log.d("",a == b+"") => false 

Long 的 equals() 检测其他部分也是 Long,而较小的类型不能隐式转换为较大的类型。

• 显式转换

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b // 这里就会报错，编译不通过

显式转换
val i: Int = b.toInt()

基本转换如下:

• toByte(): Byte
• toShort(): Short
• toInt(): Int
• toLong(): Long
• toFloat(): Float
• toDouble(): Double
• toChar(): Char

基本语法

定义函数

//函数=> Android的方法
//基本的函数  Unit表示无意义的返回可有可无
fun sum():Unit{
    .....
}
//带参数的函数
fun sum(a: Int, b: Int){
    .....
}
//有返回值得函数
fun sum()：Int{
    return 0
}
//表达式作为函数体
fun sum(a: Int, b: Int) = a + b

定义变量

//定义变量的基本方法：var 变量名：变量类型 = 变量初始值

/******************可变变量*******************/
var a: Int = 1  // 立即赋值
val c: Int  // 如果没有初始值，类型不能省略
c = 3       // 明确赋值

//类型后+ ? 表示可为空
var name: String? = null;

//lateinit延时加载 可在全局只定义不初始化
lateinit var sex: String;

//自动推断出类型 定义的时候直接赋值可自动推断出类型
var a = 2

/******************只读变量*******************/
val PI = 3.14

/*****************数组***********************/
//实例化一个数组，长度为3 值为 1 2 3
var sz: Array<String> = Array(3, { i -> (i +1).toString() })

/*****************集合***********************/
val items = listOf(1, 2, 3, 4)

注意：在Kotlin中定义变量使用 var 和 val，val表示只读，相当于Android的final

使用字符串模板

var a = 1
// 模板中的简单名称：
val s1 = "a is $a"  => "a is 1"

var b = 2
// 模板中的任意表达式：
val s2 = "${s1.replace("is", "was")}, but now is $b"  => a was 1,but now is 2

if条件表达式

fun maxOf(a: Int, b: Int): Int {
    if (a > b)
        return a
    else 
        return b
}

fun main(args: Array<String>) {
    Log.d("","max of 0 and 42 is ${maxOf(0, 42)}") => max of 0 and 42 is 42
}

使用可空值及null检测

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}
var age = "10";
var name = "Ez"

val x = parseInt(age)  => 10
val y = parseInt(name) => null 空对象

for循环

//	item项循环
val items = listOf("apple", "banana", "kiwi")
for (item in items) {
    Log.d("",item)    => apple  banana  kiwi
}
//下标循环
val items = listOf("apple", "banana", "kiwi")
for (index in items.indices) {
    Log.d("","$index is ${items[index]}")  
}
=>  0 is apple
    1 is banana
    2 is kiwi

when 表达式

val items = listOf("apple", "banana", "kiwi")
for (item in items) {
    when (item) {
        "apple" ->{
			 Log.d("==", "apple")
		}
        "banana" -> Log.d("==", "banana")
        else -> {
            Log.d("==", "kiwi")
        }
    }
}

注意：when 相当于switch操作符，可以使用块{}，也可以直接执行。

区间

val x = 10
val y = 9
if (x in 1..y+1) {
   //x在1到10之间包括1和10
}
if (x !in 1..y+1) {
   //x不在1到10之间包括1和10
}


//区间迭代
 for (x in 1..5) {
         Log.d("==", "x")  => 1 2 3 4 5
    }

//数列迭代
for (x in 1..10 step 2) {
        Log.d("==", "x")  => 1 3 5 7 9
    }
for (x in 9 downTo 0 step 3) {
        Log.d("==", "x")  => 9 6 3 0
    }

使用lambda 表达式来过滤（filter）和映射（map）集合

val fruits = listOf("banana", "avocado", "apple", "kiwi")
fruits.filter { it.startsWith("a") }  //首字母是"a"
      .sortedBy { it }
      .map { it.toUpperCase() }       //大写
      .forEach {  Log.d("===",it) }   =>APPLE  AVOCADO

lambda表达式以及高阶函数可查看官网

创建基本类及其实例

val rectangle = Rectangle(5.0, 2.0) // 不需要“new”关键字

刚开始使用的确很不习惯，不过代码的确非常的简洁，感觉写法很像是前端的，大致来讲还是非常好用的。