0.环境准备

用到是IDEA免费版本。新建一个Kotlin项目。

取个名字。

最后新建一个.kt文件，就可以开始使用kotlin了。

选择创建File。之后就会生成一个.kt的文件。

HelloWorld程序：

fun main() {
    var str:String="Hello"
    println(str)
}

手动编译运行：
执行下面的代码会生成一个叫HelloKt.class的字节码文件，非常奇怪的是，命令行并没有提供什么参数来修改这个生成的文件名字。

kotlinc Hello.kt

通过kotlin命令行来执行字节码文件：

kotlin HelloKt.class

也可以通过下面的代码生成jar文件，然后通过java -jar来运行

kotlinc Hello.kt -d hello.jar
java -jar hello.jar

1.数据类型

1.1数据的声明

下面的代码声明了一个String类型的变量，通过var关键字来声明变量，和java相比，这个写法好像非常的麻烦，多了var关键字还多了冒号，而且写的顺序也不一样，类型声明在后面，据说这个语法是从TypeScript那里学过来的，对TypeScript(JS)不熟。既然设计成这样，一定是有他的好处的。实际上，类型可以省略，kotlin会自动帮我们推导出来。

fun main() {
    var str:String="Hello"
    println(str)
}

省略后的写法：
也就是不管什么类型，都可以声明为var类型。对于开发者来说，还是节省了一点时间的，虽然牺牲了一点效率，因为倒推类型肯定需要额外的内部操作。

fun main() {
    var str="Hello"
    println(str)
}

1.2只读变量

下面的代码声明了一个String类型的变量，但是编译器会给一个警告，说"Hello"是一个只读变量，可以用val声明。注意是最后一个字母是L而不是R,var和val是两个关键字。var可以用来声明一般的变量，val用来声明只读变量，类似于java的final关键字。

 var str="Hello"

用val声明:

 val str="Hello"

注意这个只读并不等于常量，常量是用另一个关键字const来修饰的。

1.3 const常量

常量只能声明在方法外部，在方法内部是不能声明常量的。

const val MAX=1024

fun main() {
    println(MAX)
}

在kotlin中，const相对于java的static final。我们可以通过双击shitf,输入kotlin bytecode查看字节码信息。

public final static I MAX = 1024

1.4 引用类型

我们知道Java有引用类型和基本数据类型这两种类型。引用类型放在堆里面，一般是java对象。而kotlin只有一种类型，也就是引用类型，但是在编译的时候，还是会转化为基本类型。

val age=10

在字节码里面的LOCALVARIABLE I代表int类型。也就是会转化为基本数据类型。字节码内容了解一下就行。

LOCALVARIABLE age I L1 L6 0

2. 表达式

2.1 if else表达式

和Java的用法一样，就不写了。

2.2 range表达式

字面意思就是范围表达式，用到的关键字是in。下面这个例子很好的说明了使用的in关键字的用法。不光可以指定数字，还可以指定数组或者集合。

    val score=66
    if (score in 0..60){
        println("bad")
    }else if (score in 61..80){
        println("not bad")
    }else{
        println("good")
    }

2.3 when表达式

相对于Java的switch表达式，但更加简洁，推荐将所有的if else表达式都转化成when的形式，when表达式在kotlin中是非常常用的。
下面的代码对比Java的switch语句少了case和default关键字看起来简洁了非常多。
而且可以返回多种数据类型，这里返回了String类型的“男”，“女”，和int类型的-1。
返回类似是Any类型，这个有点类似Java的Object类型。->实际上是一个lambda表达式。如果只有单行可以直接返回结果，不用写return;

    val gender=3;
    val result:Any=when(gender){
        1->"男"
        2->"女"
        else-> -1
    }
    println(result)

如果lambda表达式存在多行，那么需要加一个大括号{}。

    val gender=3;
    val result=when(gender){
        1->"男"
        2->"女"
        else-> {
            println("未知")
            println("程序退出")
        }
    }
    println(result)

程序最后输出如下，kotlin.Unit类似于Java的void，因为println并没有返回值。

未知
程序退出
kotlin.Unit

2.4 String模板

String模板就是String的拼接。在Java中，我们用++拼接字符串，这个实际上是非常麻烦的。很多语言都支持用$符号拼接内容，用${}拼接表达式。

用$拼接内容：

	val animal="dog"
    val color="yellow"
    println("The $animal's color is $color")

输出内容：

The dog's color is yellow

用${}拼接表达式：

    val animal="dog"
    val color="yellow"
    val age=10
    println("The $animal's is $color and ${if(age>5) "old" else "young"}")

输出内容：

The dog's is yellow and old

3.函数

3.1 函数头

kotlin的函数头和Java还是差别非常大的，priavate表示权限，默认是oublic,fun是函数声明关键字,括号里面是参数列表，最后的:Boolean表示返回类型。
可以看到参数列表和返回值的顺序和Java是相反的，这实际上是更加符合逻辑的，先传输入再确定输出类型，也就是输入输出。只是Java用习惯了，也就习以为常了。

private fun doSomething(i:Int ,s:String):String{
    return "resultCode";
}

函数调用
直接调用就可以，不需要创建对象。

fun main() {
    val flag = doSomething(5, "abc")
    println(flag)
}

3.2 参数的默认值

参数还可以给默认值，只是Java所没有的，Java有固定的默认值。kotlin支持指定默认值。

private fun doSomething2(a:Int=2,s:String="null"):String{
    return "$a $s";
}

fun main() {
   //没有传任何参数
   val result = doSomething2()
    println(result)
}

输出结果：

2 null

3.3 具名函数参数

具名的意思就是在传入参数的时候可以指定参数的名字，这样的目的是增加可读性，因为光传参数，不知道这个参数是干嘛用的，可能传错位置，可读性也很差。
例如下面的代码，代码一的位置，写了参数的名字是age，和name,这样就不会搞错参数位置了，可读性非常强。但是，IDEA是支持参数类型提示的，可以直接显示参数类型，这相对于是IDEA已经实现的功能，可能就是为了弥补Java没有这个功能而设计的。

fun main() {
    //代码一
    var flag=doSomething(age=5,name="abc")
}

private fun doSomething(age:Int,name:String):Boolean{
    return true;
}

3.4 Unit函数

在Java中没有返回类型就返回void类型，但在泛型的时候，这个概念就有点矛盾。kotlin用kotlin.Unit这个类型表示没有返回类型。在kotlin中，如果没有返回类型，那么函数的返回类型可以不用写任何类型，也不用写void,kotlin根本就没有void这个关键字。

fun main() {
    println(testUnit(5,"abc"))
}

private fun testUnit(age:Int,name:String) {
}

输出：

kotlin.Unit

3.5 反引号的函数名

在函数名上面加一个反引号，kotlin支持这种写法，这样做的主要目的是为了和Java的交互性。Java和Kotlin是可以无缝调用的，但因为Java和Kotlin的关键字不同，可能一些方法名在Java是合法的，但到了Kotlin就变成非法，这时候就可以加反引号解决。
例如下面的Java代码，声明了一个is方法，这在Java里面是合法的，但如果在kotlin里面要调用这个方法就不行了，因为is在Kotlin里面是一个关键字。

public class Data {
    public static void is(){

    }
}

这时候在函数名上加一个反引号就可以解决这个问题。这样is就不被当作是关键字而可以在kotlin里面使用了。

//在kotlin中调用
Data.`is`()

有趣的是，加了反引号之后，方法名甚至可以写空格例如下面的代码。

private fun `first we calculate add`(a: Int,b:Int):Int{
    return a+b;
}

private fun `second we calculate sub`(a: Int,b:Int):Int{
    return a-b;
}

fun main() {
    val add= `first we calculate add`(1,2)
    val sub = `second we calculate sub`(1, 2)
    println("$add $sub")
}

用自然语言编程不再是梦。当然这个应该是用不太上，主要还是为了解决和Java的交换问题，写类似注释的方法名还是交给注释比较好。

3.6匿名内部类

我们举String的count方法为例，count方法有两个重载，第一个无参函数非常好理解，第二个重载声明如下，要求我们传入一个lambda表达式，这个表达式传入char，返回boolean（判断条件）,最后整个函数返回一个int,也就是我们指定的char字符有多少个。

public inline fun CharSequence.count(predicate: (Char) -> Boolean): Int

    var count="Kotlining".count()
    var countI = "Kotlining".count({letter -> letter == 'i'} )
    println(count)
    println(countI)

输出

9 
2

3.7 函数类型

这个和C语言的函数指针是非常像似的，但java是移除了这些特性的。
我们看下面的代码，第一次看这个代码可能非常的奇怪，看着像lambda表达式，又不完全是，其实这里的关键就是理解()->String的含义。这个语法是lambda表达式，但这里的真正含义是匿名内部类类型，并且这个匿名内部类返回String类型。顺理成章的，我们定义的变量result的类型也就变成了String类型。注意是一个类型声明，而不是lambda表达式实体，lambda表达式的实体是{}里面的内容。

	var result:()->String={
        val animal="dog"
        "This is $animal"
    }

看下和lambda表达式的对比：
下面是java的lambda表达式.一个非常明显的区别就是kotlin的匿名内部类没有return，而且在里面也是不可以写return的，这是因为他默认返回类型是表达式的最后一行。为了实现这个功能，就必须显示的声明类型，因为可能返回一个类对象。

	()->{
        val animal="dog"
        return "This is $animal"
	}

当然也是可以带参数的。在()里面声明参数类型，在{}开头可以写具体名字。写法还是非常飘逸的。

 val result2:(String,Int)->String={
        name,age->
        val animal="dog"
        "This is $animal , name is $name , age is $age"
    }

    println(result2("tom",5))

输出：

This is dog , name is tom , age is 5

还有一种类型推断的写法，如下，参数我们还是要指定类型的，但返回值可以推断出来。感觉这种写法更简洁一点，前面的写法更标准一些。

val result4 = { name: String, age: Int ->
        val animal = "dog"
        "This is $animal , name is $name , age is $age"
    }

3.8 it关键字

接着上小节，如果参数只有一个的时候，我们可以不写具体的参数名字，kotlin默认为我们提供了一个it关键字，可以直接使用这个关键字当参数变量名称。

  val result3:(String)->String={
        val animal="dog"
        "This is a $animal , name is $it."
    }

    println(result3("tom"))

输出：

This is a dog , name is tom.

3.9函数做为函数参数

下面这个函数的功能是显示学生信息，包括学生的姓名和身份证，第二个参数是一个函数类型，没错可以将一个函数做为参数传进来。这个函数可以合成学生的身份证，身份证由邮政编码，生日，编号构成。

private fun showStudentInfo(name: String, getId: (Int,Int,Int) -> String): String {
    //必须用大括号
    return "$name's id is ${getId(300027,20001212,1001)}"
}

	var getId = { code: Int, birth: Int, num: Int ->
            "$code$birth$num"
    }
    println(showStudentInfo("Tom", getId))

输出：

Tom's id is 300027200012121001

其实这个写法非常的奇怪。声明一个函数然后又去调用，那干嘛不直接写一个函数呢？其实，上面的写法是不合理的，一般不会这么写，问题就出在var getId这个变量上，我们写了这个变量来引用函数类型，这是没有必要的，因为我们用函数类型的目的就是为了写匿名函数，取名字完全是多此一举。可以简化写成下面的样子。

 println(showStudentInfo("Tom", { code, birth, num ->
        "$code$birth$num"
    }))

这样看起来就是非常简洁了。而且，kotlin有规定，如果只有一个函数类型，或者函数类型是最后一个，（）可以省略。
函数类型是最后一个的情况：

  println(showStudentInfo("Tom") { code, birth, num ->
        "$code$birth$num"
    })

只有一个函数类型做参数的时候

   println(showStudentInfo { code, birth, num ->
        "$code$birth$num"
    })

这种写法一定要掌握，因为这个写法在kotlin里面是非常常见的。
这种写法一定要掌握，因为这个写法在kotlin里面是非常常见的。
这种写法一定要掌握，因为这个写法在kotlin里面是非常常见的。

3.10 内联函数

内联函数的主要用途就是为匿名函数提高性能。在调用下面的有函数类型做为参数的方法时，会使用到匿名内部类。第二个参数要求我们传入匿名内部类，对于编译器来说，匿名内部类的创建和普通类是一样的，但既然是匿名的，效率应该要更高写，如果也是和普通类一样创建，效率就比较低了。内联函数就是为了解决这个性能问题，那么是怎么解决的呢？答案是通过宏替换，如果你学过C语言，你就知道C语言的宏替换，内联函数也是一样的，通过宏替换，我们直接把匿名内部类的代码直接复制到调用的函数里面，这样就不需要创建类了，不需要创建类当然性能就提高了。

private fun showStudentInfo(name: String, getId: (Int,Int,Int) -> String): String {
    return xxx
}

使用方法就是直接添加一个inline关键字就可以了。

private inline fun showStudentInfo(name: String, getId: (Int,Int,Int) -> String): String {
    return xxx
}

3.11 函数引用

在调用含有函数类型的方法时，不光可以传入匿名内部类，也可以传通常的方法，这时候就需要用到函数引用。
例如下面的代码，foo方法的参数列表和showStudentInfo里面的getId函数类型的参数列表是一样的，这个时候可以把foo直接传给showStudentInfo。使用方法就是在::加普通函数名称。

private fun showStudentInfo( name:String, getId: (Int,Int,Int) -> String): String {
    //必须用大括号
    return   "$name's id is ${getId(300027,20001212,1001)}"
}

private fun foo(  a:Int,b:Int,c:Int ): String {
    return   "$a$b$c"
}

 println(showStudentInfo("Tom", ::foo))

输出：

id is 300027200012121001

3.12 函数类型做为返回类型

简单来说，就是一个函数返回另一个函数。什么？这有什么意义？如果有多个函数进行嵌套调用，那么就会形成函数之间的层层包含关系。这样的好处就是子函数可以共享父函数的变量，这种写法在脚本语言中是非常常见的，例如JavaScript。这样做的原因是脚本语言存在一个很大的问题，就是即使在不同的文件里面定义相同的变量名也会报错。因为脚本语言并没有像java这样有package和class的概念。kotlin也可以做为脚本语言。我们只能举个简单的例子来说明一下她的形式，理解的比较深还是需要大量的实践的。
看下面的代码，返回值是一个函数类型，传入一个String返回String。

private fun foo(a:Int):(String)->String{
    return {
        "$it"
    }
}

在main函数中执行，返回函数类型的变量bar,可以调用，传入"abc"返回"abc"

    var bar = foo(1)
    println(bar.invoke("abc"))

输出：

abc