kotlin快速上手

val + 变量名：final类型对象
var + 变量名：普通对象

声明并初始化：val + 变量名 = 类()
val mLintPaint = Paint()

定义变量时，可在类型后面加一个问号?，表示该变量是Nullable，不加表示该变量不可为null。如下：
var s:String? = null
var s2:String = “xxx” //如果该变量被赋值为null，则编译不通过

声明数组：
var long_array:LongArray = longArrayOf(1, 2, 3)
var float_array:FloatArray = floatArrayOf(1.0f, 2.0f, 3.0f)
var double_array:DoubleArray = doubleArrayOf(1.0, 2.0, 3.0)
var boolean_array:BooleanArray = booleanArrayOf(true, false, true)
var char_array:CharArray = charArrayOf(‘a’, ‘b’, ‘c’)
var string_array:Array = arrayOf(“How”, “Are”, “You”)
val list4 = arrayListOf(“人类”, “高质量”, “码农”)

指定长度的数组：

//Java写法:
String[] params2 = new String[12];

//kotlin写法:
val params2 = arrayOfNulls<String>(12)

lateinit 关键字：

1. lateinit var只能用来修饰类属性，不能用来修饰局部变量，并且只能用来修饰对象，不能用来修饰基本类型(因为基本类型的属性在类加载后的准备阶段都会被初始化为默认值)。
2. lateinit var的作用也比较简单，就是让编译期在检查时不要因为属性变量未被初始化而报错。
3. Kotlin相信当开发者显式使用lateinit var 关键字的时候，他一定也会在后面某个合理的时机将该属性对象初始化的

示例：声明未实例化的对象
lateinit var name: String

声明静态变量
kotlin定义静态变量、方法可以采用伴生对象companion object的方式。

class TestFragment : Fragment() {
    companion object {
        private val ARG_PARAM1 = "param1"
        private val ARG_PARAM2 = "param2"

        fun newInstance(param1: String, param2: String): TestFragment {
            val fragment = TestFragment()
            val args = Bundle()
            args.putString(ARG_PARAM1, param1)
            args.putString(ARG_PARAM2, param2)
            fragment.arguments = args
            return fragment
        }
    }

方法

常规：fun + 方法名(){}

带返回值的方法：
fun methodName(param1: Int, param2: Int): Int {
return 0
}

继承

再kotlin中 类默认是不允许被继承的 如果要设置成能被继承的类 需要open关键字
如：open class Person { ... }
比如继承View直接使用：代替extends 同时直接声明了构造方法

class ClassName(context: Context?) : View(context) {}

任何一个面向对象的编程语言都会有构造函数的概念，Kotlin中也有，但是Kotlin将构造函数分成了两种：主构造函数和次构造函数。
主构造函数将会是你最常用的构造函数，每个类默认都会有一个不带参数的主构造函数，当然你也可以显式地给它指明参数。主构造函数的特点是没有函数体，直接定义在类名的后面即可。比如下面这种写法：

class Student(val sno: String, val grade: Int) : Person() {
}

这里我们将学号和年级这两个字段都放到了主构造函数当中，这就表明在对Student类进行实例化的时候，必须传入构造函数中要求的所有参数。
比如：
val student = Student(“a123”, 5)这样我们就创建了一个Student的对象，同时指定该学生的学号是a123，年级5。另外，由于构造函数中的参数是在创建实例的时候传入的，不像之前的写法那样还得重新赋值，因此我们可以将参数全部声明成val。你可能会问，主构造函数没有函数体，如果我想在主构造函数中编写一些逻辑，该怎么办呢？
Kotlin给我们提供了一个init结构体，所有主构造函数中的逻辑都可以写在里面：

class Student(val sno: String, val grade: Int) : Person() {
 init {
 println("sno is " + sno)
 println("grade is " + grade)
 }
}

constructor构造方法关键字 如上例子 在没有其他关键字修饰的情况 声明类后可直接括号代表构造方法参数 如果有其他关键字 则需要加上constructor
如： class Person constructor(username: String, age: Int){}

其他构造方法声明方式：

 constructor(context: Context) : this(context, null) {
        mContext = context
    }

注意：任何一个类只能有一个主构造函数，但可以有多个次构造函数，次构造函数也可以用于实例化一个类，且次构造函数是有函数体的。

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

    kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数（包括间接调用）

重写方法 override 关键字

例如： override fun onDraw(canvas: Canvas) {}

for循环： 点击跳转

when条件语句

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
}

这里定义了一个getScore()函数，这个函数接收一个学生姓名参数，然后通过if判断找到该学生对应的考试分数并返回。可以看到，这里再次使用了单行代码函数的语法糖
虽然上述代码确实可以实现我们想要的功能，但是写了这么多的if和else，你有没有觉得代码很冗余？没错，当你的判断条件非常多的时候，就是应该考虑使用when语句的时候，现在我们将代码改成如下写法：

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

when语句和if语句一样，也是可以有返回值的，因此我们仍然可以使用单行代码函数的语法糖。
when语句允许传入一个任意类型的参数，然后可以在when的结构体中定义一系列的条件，格式是：

匹配值 -> { 执行逻辑 }
当你的执行逻辑只有一行代码时，{ }可以省略。

除了精确匹配之外，when语句还允许进行类型匹配。什么是类型匹配呢？这里我再举个例子。
定义一个checkNumber()函数，如下所示：

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

is关键字就是类型匹配的核心，它相当于Java中的instanceof关键字。由于checkNumber()函数接收一个Number类型的参数，这是Kotlin内置的一个抽象类，像Int、Long、Float、Double等与数字相关的类都是它的子类，所以这里就可以使用类型匹配来判断传入的参数到底属于什么类型，如果是Int型或Double型，就将该类型打印出来，否则就打
印不支持该参数的类型。

修饰符

支持拼接字符串

例如

"hello, ${obj.name}. nice to meet you!"

可以看到，Kotlin允许我们在字符串里嵌入${}这种语法结构的表达式，并在运行时使用表达式执行的结果替代这一部分内容。
另外，当表达式中仅有一个变量的时候，还可以将两边的大括号省略，如下所示：

"hello, $name. nice to meet you!"

实例对比：
java：

val brand = "Samsung"
val price = 1299.99
println("Cellphone(brand=" + brand + ", price=" + price + ")")

kt：

val brand = "Samsung"
val price = 1299.99
println("Cellphone(brand=$brand, price=$price)")

函数的参数默认值

给函数设定参数默认值。
其实之前在学习次构造函数用法的时候我就提到过，次构造函数在Kotlin中很少用，因为Kotlin 提供了给函数设定参数默认值的功能，它在很大程度上能够替代次构造函数的作用。
具体来讲，我们可以在定义函数的时候给任意参数设定一个默认值，这样当调用此函数时就不会强制要求调用方为此参数传值，在没有传值的情况下会自动使用参数的默认值。
给参数设定默认值的方式也很简单，观察如下代码：

fun printParams(num: Int, str: String = "hello") {    println("num is $num , str is $str")
}

可以看到，这里我们给printParams()函数的第二个参数设定了一个默认值，这样当调用
printParams()函数时，可以选择给第二个参数传值，也可以选择不传，在不传的情况下就会自动使用默认值。

当然上面这个例子比较理想化，因为正好是给最后一个参数设定了默认值，现在我们将代码改成给第一个参数设定默认值，如下所示：

fun printParams(num: Int = 100, str: String) {    println("num is $num , str is $str")
}

这时如果想让num参数使用默认值该怎么办呢？模仿刚才的写法肯定是行不通的，因为编译器会认为我们想把字符串赋值给第一个num参数，从而报类型不匹配的错误

类型不匹配错误提示
不过不用担心，Kotlin提供了另外一种神奇的机制，就是可以通过键值对的方式来传参，从而不必像传统写法那样按照参数定义的顺序来传参。比如调用printParams()函数，我们还可以这样写：printParams(str = "world", num = 123)
此时哪个参数在前哪个参数在后都无所谓，Kotlin可以准确地将参数匹配上。而使用这种键值对的传参方式之后，我们就可以省略num参数了，代码如下：

fun printParams(num: Int = 100, str: String) {    println("num is $num , str is $str")
}
fun main() {
    printParams(str = "world")
}