Kotlin

一、变量和常量

1.1 常量的定义：关键字val

方式1：

val a:Int=1 //声明一个值为1的int型常量

方式2：

val a =1 //自动判断a为int型常量

方式3：

val a:Int //定义时可以先不赋值，此时一定要给定类型
a=1 //赋值,常量只能赋值一次，再次赋值会报错

1.2 变量：关键字var

和常量一样，3种方式声明。只是变量可以再次赋值。

二、基本类型

2.1数值

基本和java一致。注意：字符在 Kotlin 中不是数值类型

数值之间不支持隐式转换，需要做显式转换

val a :Int =1
var b:Long = a 

这样赋值会报错：

不同类型的数值之间需要做显式转换:

var a :Int =1
var b:Long = a.toLong()

数值都具备转换到其他类型数值的方法：

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

2.2 字符

字符类型用 Char 表示。不能直接当做数值来使用。

2.3 布尔值

2.4 array

2.5 字符串

字符串不可变，字符串可以用for循环遍历
常规意义的字符串(双引号包裹)：

var str = "hello \n world "

三引号包裹的字符串

var str2 = """
            val text= "xxxx"
            for(value in text){
               Log.d(TAG, value)
            }
            \n
        """

字符串模板

$取值

val i = 10
val s = "i = $i" // 识别为 "i = 10"

${}取对象属性，方法等

var i = 100
//通过$取i值，通过${}取i.toLong()的值
//最终打印出log: i = 100 , iLong = 100
Log.d(TAG, "i = $i , iLong = ${i.toLong()}" )

三、包

一个源文件以包声明开始：

package minjiang.demo

import android.app.Activity
import android.os.Bundle
import kotlin.minjiang.com.kotlindemo.R

class KotlinMain : Activity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_kotlin_main)
    }

}

如果没有指定包名，那这个文件的内容就从属于没有名字的 “default” 包。

导入文件：import foo.Bar
导入包：import foo.*
解决多个文件重名引起的冲突： import xx as xx

import foo.Bar // Bar 可以使用
import bar.Bar as bBar // bBar 代表 'bar.Bar'

四、流程控制

4.1 if

1 基本用法和java类似

2 if else 作为三元表达式

val a=5
val b=10
var max = if(a>b) a else b

3 if else 作为块 ，最后一个表达代表值

var max2 = if(a>b){
    Log.d("KotlinMain","max2 is a")
    a
}else{
    Log.d("KotlinMain","max2 is b")
    b
}

4.2 when表达式

4.3 for

item in array

for (item in collection)
    print(item)

for (item: Int in ints){
    //...
}

index in array

for (i in array.indices)
    print(array[i])

4.4 while

和java一样

4.5 返回和跳转

五、类和对象

5.1 类

类大体包含：类名，类头，类主体

class+类名

class Person

添加类主体

class Person{

}

添加主构造函数

class Person constructor(var firstName:String){

}

constructor在没有注解，没有可见性声明的时候可以省略, 如下：

class Person(var firstName:String){

}

主构造函数不能包含任意代码。初始化代码可以放在以 init 做前缀的初始化块内

class Person constructor(var firstName:String){
    init {
        Log.d("Person","init")
    }

}

二级构造函数：

如果类有主构造函数，每个二级构造函数都要，或直接或间接通过另一个二级构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字：

有主构造函数，有二级构造

class Person(val firstName: String) {
    init {
        Log.d("Person", "init")
    }

    //二级构造函数,代理主构造函数
    constructor(firstName: String, age: Int) : this(firstName) {

    }

    //二级构造函数,代理上一个二级改造函数
    constructor(firstName: String, age: Int, weight: Int) : this(firstName, age) {

    }
}

没有主构造函数

    //二级构造函数,代理主构造函数
    constructor(firstName: String)  {

    }

    //二级构造函数,代理主构造函数
    constructor(firstName: String, age: Int) : this(firstName) {

    }

    //二级构造函数,代理上一个二级改造函数
    constructor(firstName: String, age: Int, weight: Int) : this(firstName, age) {

    }

如果一个非抽象类没有声明构造函数(主构造函数或二级构造函数)，它会产生一个没有参数的构造函数。该构造函数的可见性是 public 。如果你不想你的类有公共的构造函数，你就得声明一个拥有非默认可见性的空主构造函数：

class Person private constructor(){
}

继承

默认类是final，需要添加open来设置类可继承

//class 默认为final ，需要显式设置open
open class Person(){
}

//man 继承person
class Man :Person(){

}