Kotlin学习之关键字

var与val ：var表示java中的变量申明，而val表示常量的申明

Kotlin不允许声明变量但不初始化 赋非空值 var str: String = “” （…）
设为null
var str: String? =null （建议这样写）
强制设为null
var str: String = null!! （非常不建议）
Kotlin是空安全的，但是第三种是例外情况，如果给一个变量赋值为null!!，那么就等于声明这个变量不是空安全的，就算这样使用 var
str:String = null!! str.length

lateinit：延迟初始化属性
都知道的是，在类内声明的属性必须初始化，如果设置非NULL的属性，应该将此属性在构造器内进行初始化。假如想在类内声明一个NULL属性，在需要时再进行初始化，与Kotlin的规则是相背的，此时我们可以声明一个属性并延迟其初始化，此属性用lateinit修饰符修饰。

XX：Bundle? 代表xx允许为空

?:操作符 如果 ?: 左侧的表达式值不是null, 就会返回表达式的的值,否则, 返回右侧表达式的值. 用 ?.
运算符来访问一个可空的变量。 用 ?: 运算符来指定当该变量为空时的替代值

open class 的使用
使用open该关键字表示当前类需要被重写，与java中的final关键字相反，如果不希望该类被重写，可以使用final关键字

Unit 只有一个值的类型:单元对象。这种类型对应于Java中的“void”类型。 (pos : Int)
->Unit他的输入为int，返回值为Unit

as as相当于java中的强制类型转换

>     """
>     原始字符串(raw string)由三重引号（“”“）分隔。
>     原始字符串可以包含换行符和任何其他字符。
>     val fooRawString = """

vararg fun varargExample(vararg names: Int) 用“vararg”关键字标记函数参数，
则允许将可变数量的参数传递给函数。

单个表达式
fun odd(x: Int): Boolean = x % 2 == 1
当函数由单个表达式组成时，可以省略大括号，
直接在 = 符号后写函数体。

:: 用 :: 操作符把一个命名函数用作参数

it
如果lambda只有一个参数，
那么它的声明可以（与 -> 一起）省略。
单个参数的名称将是“it”。
val notPositive = not {it > 0}

调用构造函数来创建一个实例。
注意，Kotlin没有 “new” 这个关键字。
val fooExampleClass = ExampleClass(7)

infix 如果一个函数用 “infix” 关键字标记，称为中缀标记。 println(fooExampleClass infixMemberFunction 4) // => 28

data class 在kotlin中
class前添加data可以实现javabean的效果，“hashCode”、“equals”和“toString”方法都是自动生成的。

with
"with" 方法与JavaScript中的 "with" 声明类似.是kotlin中一种代替swich的方式,"when" 可以带参数，"when" 也可以当作函数，并返回值.

Of的使用 listOf 可以用 “listOf” 方法创建一个list。 这个list是不可变的 —— 不能增加或删除元素。
可以通过序号获取list中的元素。 println(fooList[1]) // => b

setOf
用 "setOf" 方法创建集合.
val fooSet = setOf("a", "b", "c")

mapOf 用 “mapOf” 方法创建 map. val fooMap = mapOf(“a” to 8, “b” to 7, “c”
to 9)

在map中，通过 kep 来获取 value. println(fooMap["a"]) // => 8

if “if” 表达式可以,“when” 可以带参数.直接返回值。 因此，Kotlin 不需要三元运算符 ?:

is
可以用“is”运算符检查对象是否是特定类型。
如果对象通过了类型检查，就可以把它当作这个类型来用，无需显示转换。
if (x is Boolean) {
            // x is automatically cast to Boolean
            return x
        }

扩展方法 在kotlin中允许开发者在已写好的接口类中添加扩展方法，方法名与要扩展的方法名字一致就可添加

enum枚举类
枚举类与Java的枚举类型相似.
enum class EnumExample {
    A, B, C
}

object “object” 关键字可用于创建单例对象。 我们不能实例化它，但我们可以通过它的名称来引用它的唯一实例。
这与Scala的单例对象类似。
*/ object ObjectExample {
fun hello(): String {
return “hello”
} } fun useObject() {
ObjectExample.hello()
val someRef: Any = ObjectExample // 可以直接使用对象名称 }

const 如果属性值载编译期间就能确定，则可以使用const修饰符，将属性标记为编译器常数值，这类属性必须满足以下所有条件：

必须是顶级属性，或者是一个object的成员 值被初始化为String类型，或基本类型 不存自定义的取值方法

其效果相当于java中的static，但是其内容必须确定是一个常量的值

!!与?空判断 Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式一种像Java一样抛出空异常，字段后加 !! ，另一种不做处理直接跳过，字段后加 ?

$字符串模板 在Java中拼接字符串的代码可读性都很差，在Kotlin字符串拼接变得非常简洁，只需用 $ 后面加上参数名，复杂的参数要加上
{} val user = User() //赋值 user.name = “tutu” user.age = “23” //取值 val
name = user.name val age = user.age var userInfo = “name:$user.name,age:$age” //输出结果：name:tutu, age:23

companion object
伴生对象（静态变量）
Kotlin一般在类中不允许static成员,可以使用companion object来创建一个伴生对象从而可以使用static成员.

高阶函数（Higher-Order Functions ）

Kotlin还有一个Java不具备的特性，就是给方法传参数的时候，这个参数也可以是个方法。多么神奇。我们写个方法，就是从一个List种取出偶数，组成一个新的List。

我们用Java写:

public List<Integer> filter(List<Integer> list) {

    List<Integer> resultList = new ArrayList<>();

    for (int t : list) {
        if (t % 2 == 0) {
            resultList.add(t);
        }
    }

    return resultList;
}

我们用Kotlin写：

fun  filter(items: Collection<Int>, f: (Int) -> Boolean): List<Int> {

    val filtered = arrayListOf<Int>()

    for (item in filtered) {
        if (f(item)) {
            filtered.add(item)
        }
    }

    return filtered
}

在Kotlin中，方法的参数类型是在：的后面。(Int) -> Boolean这个是上面方法的第二个参数的参数类型。表示这个参数是个方法并且这个方法的传入的是一个Int类型的值，返回值是Boolean类型的值。那么怎么调用这个上面这个方法呢？

val numbers = listOf<Int>(1, 2, 3, 4)

// 得到所有偶数组成的List
filter(numbers， {
    it % 2 == 0
}) 

在Kotlin中当一个方法的方法参数是最后一个的时候我们还可以写成这样

val numbers = listOf<Int>(1, 2, 3, 4)
// 可以把大挂号放外面
filter(numbers) {
    it % 2 == 0
}

如果我们想得到List中的奇数组成的List可以这样，相当简单

val numbers = listOf<Int>(1, 2, 3, 4)
filter(numbers) {
    it % 2 == 1  // 奇数
}

从上面的例子我们可以看出方法参数的厉害和简洁了。