kotlin 由浅入深（三）基本语法（包、函数、常量、变量、注释

定义包

包的声明在源文件的顶部

package my.demo             // 包名

import java.util.*          // 引入

目录与包的结构无需匹配：源代码可以在文件系统的任意位置。

• 包
  一个源文件以包声明开始，源文件的所有内容(比如类和函数)都被包声明包括。

package foo.bar

fun bza() {}                // 全名是 foo.bar.bza

class Goo {}              // 全名是 foo.bar.Goo

如果没有指定包名，那这个文件的内容就从属于没有名字的 "default" 包。

• Imports
  除了模块中默认导入的包，每个文件都可以有它自己的导入指令。

—— 导入一个单独的名字
import foo.Bar    //Bar 现在可以不用条件就可以使用

—— 范围内的所有可用的内容 (包，类，对象，等等):
import foo.*       //foo 中的所有都可以使用

—— 如果命名有冲突，我们可以使用 as 关键字局部重命名解决冲突
import foo.Bar // Bar 可以使用
import bar.Bar as bBar // bBar 代表 'bar.Bar'

函数

先看几个函数

    // 1、带有两个Int参数，返回Int的函数
    fun getNum(a: Int, b: Int): Int {
        return a + b
    }

    // 2、将表达式作为函数体、返回值类型自动推断的函数
    fun getNum2(a: Int, b: Int): Int = a + b

    // 3、返回无意义的值(包含Unit)
    fun setText(str: String): Unit {
        Log.e("zpan", "=====包含Unit======" + str)
    }

    // 4、Unit 返回类型可以省略
    fun setText2(str: String) {
        Log.e("zpan", "=====省略Unit=====" + str)
    }

    // 5、不带参数
    fun setText3() {
        Log.e("zpan", "=====省略Unit、不带参数=====")
    }

• 函数声明

用关键字 fun 声明函数

fun double(x: Int): Int {
}

• 函数用法

一般调用方式同 java

val result = double(2) 

通过 "." 调用成员函数

Sample().foo()           // 创建Sample类的实例,调用foo方法

• 中缀符号

在满足以下条件时,函数也可以通过中缀符号进行调用:

它们是成员函数或者是扩展函数 　只有一个参数 使用infix关键词进行标记

//给 Int 定义一个扩展方法
infix fun Int.shl(x: Int): Int {
...
}

1 shl 2                 //用中缀注解调用扩展函数

1.shl(2)

• 参数

参数之间用逗号隔开，每个参数与类型之间用 “：” 号隔开，参数类型首字母大写。

fun powerOf(number: Int, exponent: Int) {
}

• 默认参数

参数可以使用默认值，参数被忽略时会使用默认值；默认值可以通过在type类型后使用 "=" 号进行赋值

// 调用
read(arrayOf("1", "2", "3"))

// 带有默认参数的函数
fun read(b: Array<String>, off: Int = 0, len: Int = b.size) {
     Log.e("zpan","====off====" + off + "===len==" + len)
}

// 日志
E/zpan: ====off====0===len==3

• 无返回值函数
  返回类型是 Unit（类似于Java中的void），但是Kotlin中 Unit 可以省略

fun printSum(a: Int, b: Int): Unit { 
    
}

// Unit可以省略(对于public方法也是这样)：
public fun printSum(a: Int, b: Int) { 
    
}

• 单表达式函数
  当函数返回单个表达式时，可以省略花括号并且在 = 符号之后指定代码体

    fun double(x: Int): Int = x * 2
    
    // 当返回值类型可由编译器推断时，返回类型可省略
    fun double(x: Int) = x * 2

    // public 方法则必须明确写出返回类型
    public fun sum(a: Int, b: Int): Int = a + b  

注：函数博大精深，基础部分先写到这里，还有待深入实践研究！！！

常量&变量

• 常量：用val 关键字修饰，只能赋值一次的变量(类似Java中final修饰的变量)。
• 变量：用var 关键字修饰。

注：常量与变量都可以没有初始化值,但是在引用前必须初始化
编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

    // 常量
    fun setConstant() {
        // 1、立即赋值
        val a: Int = 2
        // 2、自动推断出“Int”类型
        val b = 2
        // 3、如果没有初始值，类型不能省略
        val c: Int
        // 3、明确赋值
        c = 2
    }

    // 变量
    fun setVariable() {
        // 自动推断出 Int 类型
        var d = 3
        // 数值变化
        d += 4
    }

注释

单行、多行注释用法都和Java相同，唯一的不同点是，Kotlin支持嵌套注释，而Java是不支持的。（然而并没有什么用）

    /*
       第一层块注释
        /*
           第二层块注释
              /*
                  第三层块注释
                  这种注释方式在java中是不支持的，但是在kotlin中是支持的（貌似意义不大）。
               */
        */
     */