文章目录

• 1、关键字：

• ？的含义
• ?:的含义
• :（冒号）
• ::(双冒号)
• ::class
• !!（双叹号）
• abstract :
• any:
• by
• companion object 伴生对象:
• const:
• constructor 用于标识构造函数
• data class:
• indices：
• inline：
• inner:
• internal:
• is:
• lateinit var 延迟初始化属性：
• by lazy 懒属性(延迟加载)
• object（用于创建单例模式）:
• open 说明可以被继承 :
• override :
• reified：
• sealed 密封类：
• tailrec（尾递归）：
• Unit 类型：
• var和val：
• typealias：
• vararg ：
• when 用于判断 相当于java中的switch()语句

• 2、注解：

• @JvmField
• @JVMStatic

• 3、作用域函数

• let
• apply:
• run:
• with:
• also

• 4、定义类

• 4.1、属性修饰符
• 4.2、访问权限修饰符

Kotlin关键字一览表

关键字与操作符 （官）

？的含义

在kotlin中单独使用？表示可为空；

kotlin代码书写格式：

java代码书写格式：

有人疑问加“?”和不加的根本区别在哪？就在于程序运行过程中对变量的赋值，如果给没有加“?”的变量赋值了null，程序就会异常。

?:的含义

在kotlin中表示三元操作符（即三目运算符）

:（冒号）

类型和超类型之间的冒号前要有一个空格，而实例和类型之间的冒号前不要有空格：

Kotlin 可以有包级函数，因此我们并不需要声明一个类来包装 main 函数：

::(双冒号)

双冒号操作符 表示把一个方法当做一个参数，传递到另一个方法中进行使用，通俗的来讲就是引用一个方法。

::class

如何获得 class 的实例

Java 当中：

Kotlin当中：

同样效果的 Kotlin 代码看上去确实很奇怪，实际上 Hello::class 拿到的是 Kotlin 的 KClass，这个是 Kotlin 的类型；
如果想要拿到 Java 的 Class 实例，那么就需要Hello::class.java。

!!（双叹号）

意味着「有一个潜在未处理的 KotlinNullPointerException 在这里」

在kotlin中表示一定不能为空；

abstract :

抽象类 一个类或一些成员可能被声明成 abstract 。一个抽象方法在它的类中没有实现方法。
记住我们不用给一个抽象类或函数添加 open 注解，它默认是带着的。

any:

相当于Java中的Object。

by

类委托、属性委托

companion object 伴生对象:

类似static。

在 kotlin 中，不像 java 或者 C# ，它没有静态方法。在大多数情形下，我们建议只用包级别的函数。

如果你要写一个没有实例类就可以调用的方法，但需要访问到类内部(比如说一个工厂方法)，你可以把它写成它所在类的一个成员(you can write it as a member of an object declaration inside that class)更高效的方法是，你可以在你的类中声明一个伴随对象，这样你就可以像 java/c# 那样把它当做静态方法调用，只需要它的类名做一个识别就好了。

实例:获取全局的Application实例

const:

使用 const 修饰符标记为 编译期常量

constructor 用于标识构造函数

二级构造函数

3.1、注：kotlin中的类定义同时也是构造函数，这个时候是不能进行操作的，所以kotlin增加了一个新的关键字init用来处理类的初始化问题，init模块中的内容可以直接使用构造函数的参数。

3.2、java中加入final为不可继承，而kotlin中定义类默认前面带有修饰符final，所以，如果想继承该类，在最前面加上open或者abstract即可。即：

3.3、如果init中没有操作，则可以省略

3.4、如果连参数也没有，甚至可以这么写

3.5、但是当构造参数中的参数、类型变化时可能需要不只是一个构造函数，需要多组构造函数来处理不同view上的数据时，使用constructor加上参数，后面用this加上主构造函数的参数。
次级构造函数

data class:

kotlin中的data class

data class就是一个类中只包含一些数据字段。

编译器在背后默默给我们生成了如下的东西

• equals()/hashCode()
• toString()方法
• componentN()方法《实现解构申明》
• copy()方法

如何申明一个简单的数据类？ 有一下几点要求：

• 主构造函数必须要至少有一个参数（就代表了必须要有一个数据字段，hashCode,equals,toString都是要依据主构造函数来生成的）
• 主构造函数中的所有参数必须被标记为val或者var（相当于表明了数据字段的访问权限，这就达到了Java中我们手动生成set get的目的）
• 数据类不能有以下修饰符：abstract，inner,open,sealed
• data class只能实现接口（Kotlin1.1以前的规则），现在也可以继承其它类
  data class User(var id: Int, var name: String)

indices：

inline：

作用：修饰内联函数。

如果被调用的Lambda表达式或函数包含大量的执行代码，那么就不应该使用内联函数；
如果被调用的Lambda表达式或函数只包含非常简单的执行代码，就使用内联函数；

inner:

嵌套类：

如果想让类 B 能访问类 A 的成员，可以加 inner 标记：

访问：

internal:

在Kotlin编程中有四种修饰词：private,protected,internal,public，默认的修饰词是public。

• internal 声明，在同一模块中的任何地方可见。

is:

相当于Java中的 instanceof

lateinit var 延迟初始化属性：

通常,那些被定义为拥有非空类型的属性,都需要在构造器中初始化.但有时候这并没有那么方便.

例如在单元测试中,属性应该通过依赖注入进行初始化, 或者通过一个 setup 方法进行初始化.在这种条件下,你不能在构造器中提供一个非空的初始化语句,但是你仍然希望在访问这个属性的时候,避免非空检查.

为了处理这种情况,你可以为这个属性加上 lateinit 修饰符

注意：lateinit修饰的变量/属性 不能 是原始数据类型。

这个修饰符只能够被用在类的 var 类型的可变属性定义中,不能用在构造方法中.并且属性不能有自定义的 getter 和 setter访问器.这个属性的类型必须是非空的,同样也不能为一个基本类型.
在一个延迟初始化的属性初始化前访问他,会导致一个特定异常,告诉你访问的时候值还没有初始化.

初始化前访问一个 lateinit 属性会抛出一个特定异常，该异常明确标识该属性被访问及它没有初始化的事实。

by lazy 懒属性(延迟加载)

Kotlin的延迟初始化: lateinit var 和 by lazy

• lateinit 只用于 var，而 lazy 只用于 val
• lateinit var只是让编译期忽略对属性未初始化的检查，后续在哪里以及何时初始化还需要开发者自己决定。
• by lazy真正做到了声明的同时也指定了延迟初始化时的行为，在属性被第一次被使用的时候能自动初始化。

object（用于创建单例模式）:

open 说明可以被继承 :

open 注解与java 中的 final相反:它允许别的类继承这个类。

默认情形下，kotlin 中所有的类都是 final ,用来表示他可以被继承。

所以，父类使用open声明类，不然默认final，无法继承。

修饰类: 说明可以被继承

修饰成员 : 在 kotlin 中坚持做明确的事。不像 java ，kotlin 需要把可以复写的成员都明确注解出来，并且重写它们

override :

reified：

sealed 密封类：

密封类用于代表严格的类结构，值只能是有限集合中的某中类型，不可以是任何其它类型。这就相当于一个枚举类的扩展：枚举值集合的类型是严格限制的，但每个枚举常量只有一个实例，而密封类的子类可以有包含不同状态的多个实例。
声明密封类需要在 class 前加一个 sealed 修饰符。密封类可以有子类但必须全部嵌套在密封类声明内部.

注意密封类子类的扩展可以在任何地方，不必在密封类声明内部进行。
使用密封类的最主要的的好处体现在你使用 when 表达式。可以确保声明可以覆盖到所有的情形，不需要再使用 else 情形。

tailrec（尾递归）：

作用：修身尾递归函数。与普通递归相比，编译器会对尾递归进行修改，将其优化成一个快速而高效的基于循环的版本，这样减少内存消耗。

Unit 类型：

如果函数返回 Unit 类型，该返回类型应该省略：

var和val：

var是一个可变变量，这是一个可以通过重新分配来更改为另一个值的变量。这种声明变量的方式和java中声明变量的方式一样。
val是一个只读变量，这种声明变量的方式相当于java中的final变量。一个val创建的时候必须初始化，因为以后不能被改变。

typealias：

定义类型别名。

vararg ：

功能：可变参数。一个函数最多只能有一个可变参数。

标记后,允许给函数传递可变长度的参数：

when 用于判断 相当于java中的switch()语句

when分支：

• 不再需要case关键字
• case值后的冒号改为使用箭头（->）
• default改为更有意义、更明确的else
• when分支可以匹配多个值
• when分支可以是任意表达式
• when分支对条件表达式的类型没有任何要求

when分支作为表达式：

处理范围（in…），处理类型(is Int,is Double…)：

@JvmField

静态字段：
在命名对象或伴生对象中声明的 Kotlin 属性会在该命名对象或包含伴生对象的类中具有静态幕后字段。

通常这些字段是私有的，但可以通过以下方式之一暴露出来：

• @JvmField 注解；（ public static final 字段）
• lateinit 修饰符；（ public static 非-final 字段）
• const 修饰符。（static 字段）

@JVMStatic

静态方法：
在 “companion object” 中的公共函数必须用使用 @JvmStatic 注解才能暴露为静态方法。

如果使用 @JvmStatic 注解，编译器既会在相应对象的类中生成静态方法，也会在对象自身中生成实例方法。
如果没有这个注解，这些函数仅可用作静态 Companion 字段上的实例方法。

作用域函数（官）

Kotlin之let,apply,with,run函数区别

Kotlin之let,apply,run,with等函数区别2

Kotlin 标准库包含几个函数，它们的唯一目的是在对象的上下文中执行代码块。当对一个对象调用这样的函数并提供一个 lambda 表达式时，它会形成一个临时作用域。在此作用域中，可以访问该对象而无需其名称。这些函数称为作用域函数。共有以下五种：let、run、with、apply 以及 also。

每个作用域函数之间有两个主要区别：

• 引用上下文对象的方式
• 返回值

let

默认当前这个对象作为闭包的it参数，返回值是函数里面最后一行，或者指定return

apply:

apply函数是这样的，调用某对象的apply函数，在函数范围内，可以任意调用该对象的任意方法，并返回该对象.

apply函数和run函数很像，唯一不同点就是它们各自返回的值不一样，run函数是以闭包形式返回最后一行代码的值，而apply函数的返回的是传入对象的本身。

run:

run函数和apply函数很像，只不过run函数是使用最后一行的返回，apply返回当前自己的对象。

run函数是let,with两个函数结合体，准确来说它弥补了let函数在函数体内必须使用it参数替代对象，在run函数中可以像with函数一样可以省略，直接访问实例的公有属性和方法，另一方面它弥补了with函数传入对象判空问题，在run函数中可以像let函数一样做判空处理。

with:

with函数是一个单独的函数，并不是Kotlin中的extension，所以调用方式有点不一样，返回是最后一行，然后可以直接调用对象的方法，感觉像是let和apply的结合。

also

上下文对象作为 lambda 表达式的参数（it）来访问。 返回值是上下文对面本身。

4.1、属性修饰符

• annotation //注解类
• abstract //抽象类
• final //类不可继承，默认属性
• enum //枚举类
• open //类可继承，类默认是final的

4.2、访问权限修饰符

• private //仅在同一个文件中可见
• protected //同一个文件中或子类可见
• public //所有调用的地方都可见
• internal //同一个模块中可见