本文是技术视野Kotlin学习笔记系列的投稿。
上一篇文章的名字叫Kotlin tutorial，后来想了想可能不太合适，所以决定改成Kotlin学习笔记。 上一篇文章发表后，有几位读者留言问不学Java直接学Kotlin行不行？ 我认为没有问题。 嗯，前面的文章对Kotlin的一些特性有一个简单的了解，后来用Kotlin写了一个最简单的HelloWorld。 不清楚的可以先看上一篇：Kotlin学习笔记（一）：走进Kotlin的世界。
包名
Kotlin在包名声明和类型导入方面与Java基本一致，风格如下：
package xxx.xxx.xxx //包名声明
import xxx.xxx.xxx //类型导入
...正如每个Java文件都会默认导入java.lang.*一样，Kotlin也会默认导入以下包，默认导入的包会根据运行平台的不同略有不同。
// 每个Kotlin文件会默认导入下面的包
kotlin.*
kotlin.annotation.*
kotlin.collections.*
kotlin.comparisons.*
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*
// JVM下的Kotlin还会导入
java.lang.*
kotlin.jvm.*
// JS下的Kotlin还会导入
kotlin.js.*值类型
Kotlin 的数值类型包括 Byte（1 字节）、Short（2 字节）、Int（4 字节）、Long（8 字节）、Float（4 字节）、Double（8 字节节）。
文字常量
从Kotlin 1.1版本开始，可以使用下划线来增强可读性
val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010布尔值
关键字 Boolean 只有两个值：true 和 false。 与 Java 一样，您可以使用 &&、||、! 执行 AND 或 NOT 操作。
操作员
Kotlin支持标准的算术运算符，也支持以下各种位运算
上面的位运算符只对 Int 和 Long 类型有用。
var x = (1 shl 2) and 0x000FF000
var y = 0x000FF000
var z = y.inv() //z是y取反获得的特点
关键字 Char 与 Java 中 char 的基本用法没有太大区别。
var useChar: Char = 'c'大批
关键字 Array，Kotlin 中数组的使用与 Java 有很大的不同。 例如，如果我想创建一个数组，我必须使用 arrayOf
//使用arrayOf简单创建数组
var students: Array = arrayOf("Clock", "D_clock", "技术视界")
var studentNums = arrayOf(1, 2, 3)使用 arrayOfNulls 创建指定长度且元素为空的数组
//创一个长度为10，元素内容皆为null的数组
var emptyArray = arrayOfNulls(10)Kotlin对一些基本类型定义数组有拆箱开销，所以也可以使用自己封装的一些API来创建数组来减少开销
//创建一个int数组，避免封箱装箱操作
var intArray = intArrayOf(1, 2, 3)Kotlin 数组还支持使用闭包进行初始化，就像这样
//使用闭包初始化一个Array，数组内容为["0", "1", "4", "9", "16"]
var asc = Array(5, { i -> (i * i).toString() })细绳
关键字 String 的用法与 Java 没有太大区别。
var useString: String = "I am a boy"
var firstChar: Char = useString[0] //相当于Java的String.charAt(0)Kotlin 也支持字符串模板，但是比Java 的String.format 简洁多了。 例如：
var nickname: String = "D_clock爱吃葱花"
println("my nickname is $nickname")//输出昵称
println("nickname length: ${nickname.length}")//输出昵称的长度定义变量
Kotlin 中的变量分为可变的和不可变的。 和Java中是否声明final变量是一样的。 定义变量的语法如下：
可变类型 变量名:数据类型给出一个比较 Kotlin 和 Java 的简单示例代码
/***Kotlin版代码***/
//定义可变变量
var id: Int = 1 //
var name: String = "D_clock爱吃葱花"
//定义不可变变量
val useVal: Int = 1000
/***Java版代码***/
int id = 1;
String name = "D_clock爱吃葱花";
final int useFinal = 1000;Kotlin 支持类型推导。 定义变量时，可以不显式声明类型，而是通过赋值的方式来确定变量类型。因此，定义变量的代码也可以这样写
//类型推导
var tmpId = 1
var tmpName = "D_clock爱吃葱花"定义函数
Kotlin中定义函数的风格大致如下
访问控制符 fun 方法名(参数,参数,参数) : 返回值类型{
...
...
}/***Kotlin版代码***/
//有返回参数的函数
fun getName(): String {
return "Kotlin"
}
//无返回参数的函数
fun displayName(name: String) {
println("name: $name")
}
/***Java版代码***/
public String getName() {
return "Java";
}
public void displayName(String name) {
System.out.println("name: " + name);
}与Java相比，Kotlin支持包级函数，即函数不依赖于类。
/***Kotlin版代码***/
package lesson1
/**
* Created by Clock on 2017/6/18.
*/
fun main(args: Array) {
println("Kotlin")
}
/***Java版代码***/
package lesson1;
/**
* Created by Clock on 2017/6/18.
*/
public class Lesson1 {
public static void main(String[] args) {
System.out.println("Java");
}
}与上面的代码相比，Java需要先创建一个类，然后再创建一个方法。 刚开始安装IntelliJ IDEA写代码的时候，我还有一个疑惑，为什么创建Kotlin File/Class会有两个选项，到这里就明白了。
参数加长
在Kotlin中改变参数的长度非常简单，传递的参数可以用关键字vararg来标记
/***Kotlin版代码***/
//参数变长
fun displayActors(vararg name: String) {
println("actors: " + name);
}
/***Java版代码***/
public void displayActors(String... name) {
System.out.println("actors :" + name);
}与 Java 相比，可变长度参数在 Kotlin 代码中更为常见。
静态变量和函数
Kotlin 没有 Java 中的静态概念。 如果你需要在 Kotlin 中像 Java 一样定义静态变量和函数，你可以使用伴随对象。 您可以在伴生对象后添加自定义对象名称，也可以省略它。
/***Kotlin版代码***/
class KotlinStatic {
companion object Test {
var kotlinInt: Int = 0
fun getInstance(): KotlinStatic {
return KotlinStatic()
}
}
}
/***Java版代码***/
public class Lesson1 {
public static int javaInt = 0;
public static Lesson1 getInstance() {
return new Lesson1();
}
}这样就可以在需要的地方进行如下调用
package lesson0
import lesson1.KotlinStatic
/**
* Created by Clock on 2017/6/17.
*/
fun main(args: Array) {
println("Hello, world!")
KotlinStatic.kotlinInt
KotlinStatic.getInstance()
}虽然看起来companion object在Java中实现了和static一样的功能，但是与Java不同的是，Kotlin会在运行时创建一个companion object实例对象。 在Kotlin中，如果你真的想在Java中实现静态变量或函数，官方推荐使用包级变量或函数。
If 表达式（语句）
if在Kotlin中不同于Java，它不仅可以作为判断语句，还可以作为表达式，即If判断的执行是有返回值的。
fun useIf() {
//使用If表达式判断a、b的大小
var a = 5
var b = 3
var result = if (a > b) {
println("a > b")
true //返回结果
} else {
println("a <= b")
false
}
println("result: $result")
}If表达式中每个条件代码块最后一行执行语句就是返回值变量声明和定义的区别，相当于Java中的三元运算符：condition? Then: otherwise变量声明和定义的区别，所以当用If作为表达式时，必须有else分支， 这样逻辑上保证最后一定有返回值，否则会报语法错误。
When 表达式（语句）
在 Kotlin 中，像 If 一样，可以用作语句或表达式。 作为语句使用时，相当于Java中的switch。下面是对传入参数输入的判断
fun useWhen(input: Int) {
var result = when (input) {
//判断input是否为1
1 -> println("input == 1")
//判断input是否为2
2 -> {
println("input == 2")
}
//input是否在10到20的范围内
in 10..20 -> println("input number in the range")
//input是否不在20到30的范围内
!in 20..30 -> println("input number outside the range")
else -> { //When作为表达式使用时，最后一定要以else
println("input: $input")
}
}
println("result: $result")
}从上面的代码中，你会发现它比Java的switch灵活多了。 这里只用When语句，如果要用When表达式，应该和If表达式一样，最后必须以else结尾。
for循环
for循环可以遍历任何提供迭代器（iterator）的对象，语法格式如下：
for (item in collection){
//代码块
...
}它不同于Java，但也很简单。 Kotlin 中的 for 更类似于 Java 中增强的 for 循环。
fun useFor() {
val students: Array = arrayOf("Clock", "D_clock", "技术视界")
for (student in students) {//输出学生名字
println("student: $student")
}
for ((index, student) in students.withIndex()) {//输出学生的下标和名字
println("the element at $index is $student")
}
}while循环
Kotlin中的white(){}和do{}while()与Java类似，这里不再赘述。
fun useWhile() {
var counter = 10
while (counter > 0) {
counter--
println("counter: $counter")
}
do {
counter++
println("counter: $counter")
} while (counter < 10)
}后退和跳跃
Kotlin和Java一样，有以下三种跳转表达式
以上三种跳转都支持跳转到指定标签。标签的使用也很简单，用@标记对应的循环或匿名函数即可，如下面的示例代码
fun useJump() {
val numbers = arrayOf(1, 2, 3, 4, 5)
val numbers2 = arrayOf(1, 3, 5, 7, 9)
//设置testLab标签名
testLab@ for (num in numbers) {
println("num: $num")
for (num2 in numbers2) {
if (num == 3) {
break@testLab//直接中断标签指定的整个循环
}
}
}
}总结
以上就是本文整理的Kotlin的一些基本语法注释。 如有错误或遗漏，敬请指正。
