1、方法的定义：

fun sum(a: Int, b: Int): Int {   // Int 参数a和b，返回值 Int
    return a + b
}
//表达式作为函数体，返回类型自动推断
fun sum(a: Int, b: Int) = a + b
public fun sum(a: Int, b: Int): Int = a + b   // public 方法则必须明确写出返回类型

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

//Unit相当于java中的void
// 如果是返回 Unit类型，则可以省略(对于public方法也是这样)：
public fun printSum(a: Int, b: Int) { 
    print(a + b)
}

可变长参数函数

fun vars(vararg v:Int){
    for(vt in v){
        print(vt)
    }
}

// 测试
fun main(args: Array<String>) {
    vars(1,2,3,4,5)  // 输出12345
}

lambda(匿名函数)

// 测试
fun main(args: Array<String>) {
    val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
    println(sumLambda(1,2))  // 输出 3
}

2、常量与变量：

var和val的区别：
val:定义的变量是不可修改的（类似于java中的final）
var:定义的变量是可以修改的

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

val a: Int = 1
val b = 1       // 系统自动推断变量类型为Int
val c: Int      // 如果不在声明时初始化则必须提供变量类型
c = 1           // 明确赋值
var x = 5        // 系统自动推断变量类型为Int
x += 1           // 变量可修改

3、NULL检查机制：

代码中可为空的参数，使用时需要进行空判断处理，2种处理方式
1、字段后加!!像Java一样抛出空异常
2、字段后加?可不做处理，返回值为 null或配合?:做空判断处理

任何对象都分为可null和不可null,当对象可以为null时，使用的时候必须加判断,或者加上!!

fun main(args: Array<String>) {
//类型后面加?表示可为空
var age: String? = "23" 
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1
//-----------------------------------------------------------
    //使用
    val token = token()
    //第一种方法
    if (token != null) {//不加判断会报错
        println(token.length)
        //token?.length  //如果token为null，则token?.length返回null，不会报错
    }
 //第二种方法,当token为null时，会抛出空异常
 //println(token!!.length) 
}
//声明返回值可以为null
fun token(): String? {
    return null
}

4、类型检测及自动类型转换：

使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)

fun getStringLength(obj: Any): Int? {
    if (obj !is String)
        return null
    // 在这个分支中, `obj` 的类型会被自动转换为 `String`
    //---------------------------------------------------
    // 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
    /*  if (obj is String && obj.length > 0)
          return obj.length*/
    //---------------------------------------------------
    return obj.length
}

5、区间：

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成

for (i in 1..4) print(i) // 输出“1234”

for (i in 4..1) print(i) // 什么都不输出

if (i in 1..10) { // 等同于 1 <= i && i <= 10
    println(i)
}

// 使用 step 指定步长
for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”

// 使用 until 函数排除结束元素
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}

6、比较数字：

Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小

fun main(args: Array<String>) {
    val a: Int = 10000
    println(a === a) // true，值相等，对象地址相等

    //经过了装箱，创建了两个不同的对象
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a

    //虽然经过了装箱，但是值是相等的，都是10000
    println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样
    println(boxedA == anotherBoxedA) // true，值相等
}

7、类型转换：

  val b: Byte = 1 // OK, 字面值是静态检测的
    //al i: Int = b // 错误
    val i: Int = b.toInt() // OK

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

8、数组：

数组的创建两种方式：
1、一种是使用函数arrayOf()
2、另外一种是使用工厂函数。

fun main(args: Array<String>) {
    //[1,2,3]
    val a = arrayOf(1, 2, 3)
    //[0,2,4]
    val b = Array(3, { i -> (i * 2) })

    //读取数组内容
    println(a[0])    // 输出结果：1
    println(b[1])    // 输出结果：2
}

除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组

9、字符串：

和 Java 一样，String 是不可变的

 var str = "1234";
    for (c in str) {//遍历打印字符串
        println(c)
    }
    //----------------------------
    val text = """
    多行字符串
    多行字符串
    """.trimMargin()//去掉前置空格

10、条件控制：

fun main(args: Array<String>) {
    var x = 0
    if(x>0){
        println("x 大于 0")
    }else if(x==0){
        println("x 等于 0")
    }else{
        println("x 小于 0")
    }

    var a = 1
    var b = 2
    val c = if (a>=b) a else b
    println("c 的值为 $c")
}

使用区间

fun main(args: Array<String>) {
    val x = 5
    val y = 9
    if (x in 1..8) {
        println("x 在区间内")
    }
}

11、When 表达式：

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

when 既可以被当做表达式使用也可以被当做语句使用。

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x 不是 1 ，也不是 2")
    }
}
//----------------------------------------
when (x) {
    0, 1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}
//-----------------------------------------
when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}
//----------------------------------------------
fun hasPrefix(x: Any) = when(x) {
    is String -> x.startsWith("prefix")
    else -> false
}
//----------------------------------------------
//用来取代if-else if
when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

在 when 中，else 等同 switch 的 default

12、循环控制：

For 循环

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }

    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}

while 与 do...while 循环

fun main(args: Array<String>) {
    println("----while 使用-----")
    var x = 5
    while (x > 0) {
        println( x--)
    }
    println("----do...while 使用-----")
    var y = 5
    do {
        println(y--)
    } while(y>0)
}

11、类的定义和类的属性：

//constructor...主构造函数
//如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略
class Person constructor(firstName: String) {
    var name: String = "张三"
}

fun main(args: Array<String>) {
    var person = Person("李四")//Kotlin 中没有 new 关键字
    println("姓名：" + person.name)
}

• getter 和 setter

getter 和 setter 都是可选
如果属性类型可以从初始化语句或者类的成员函数中推断出来，那就可以省去类型，val不允许设置setter函数，因为它是只读的。

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val inferredType = 1   // 类型为 Int 类型,默认实现 getter

示例：

class Person {
    var lastName: String = "zheng"
    //当调用person.lastName，获取值field.toUpperCase()
    //field(后端变量)   toUpperCase将变量赋值后转换为大写
        get() = field.toUpperCase()
        set//当调用person.lastName = "wang"，触发set
    var no: Int = 100
        get() = field
        set(value) {//value当前传递过来的值，在赋值给field（后端变量）之前做一些操作改变值
            if (value < 10) {
                field = value  //传入的值小于10返回改值
            } else {
                field = -1     //如果传入的值大于等于10 返回-1
            }
        }
    var heiht: Float = 145.4f
        private set//set方法为私有是，外部不可调
}

fun main(args: Array<String>) {
    var person = Person()
    person.lastName = "wang"//将wang赋值给lastName
    println("lastName:${person.lastName}")
    person.no = 9
    println("no:${person.no}")
}

• 输出
  lastName:WANG
  no:9

Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器

• 非空属性必须在定义的时候初始化,kotlin提供了一种可以延迟初始化的方案,使用 lateinit 关键字描述属性

 class MyTest {
    private lateinit var person: Person
    fun setUp() {
        person = Person("哇哈哈")
    }
    fun test() {
        println(person.name)
    }
}
fun main(args: Array<String>) {
    val myTest=MyTest()
    myTest.setUp()
    myTest.test()
}

• 主构造器

主构造器中不能包含任何代码，初始化代码可以放在初始化代码段中，初始化代码段使用 init 关键字作为前缀

class Person constructor(firstName: String) {
    init {
        println("FirstName is $firstName")
    }
}

构造器有注解，或者有可见度修饰符，这时constructor关键字是必须的，注解和修饰符要放在它之前。

• 次构造函数
  需要加前缀 constructor

class MyTest(name: String="") {
    var strName: String = ""
    var age: Int = 0
    init {
        strName = name
    }
    //同一个类中代理另一个构造函数使用 this 关键字
    constructor(name: String, age: Int) : this(name) {
        strName = name
        this.age = age
    }
    fun print() {
        println("strName" + strName + "-----age" + age)
    }
}
fun main(args: Array<String>) {
    val myTest1 = MyTest("传递给次构造函数", 20)
    myTest1.print()
    val myTest2 = MyTest("传递给主造函数")
    myTest2.print()
}

• 输出
  strName传递给次构造函数-----age20
  strName传递给主造函数-----age0

如果一个非抽象类没有声明构造函数(主构造函数或次构造函数)，它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想你的类有公共的构造函数，你就得声明一个空的主构造函数：

class DontCreateMe private constructor () {
}

12、抽象类和嵌套类：

• 抽象类

open class Base {//open 标识此类可以被继承
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

注意：无需对抽象类或抽象成员标注open注解

• 嵌套类

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

fun main(args: Array<String>) {
    val demo = Outer.Nested().foo() // 调用格式：外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}

13、内部类和匿名内部类：

• 内部类

class Outer {
    private val bar: Int = 1
    var v = "成员属性"

    /**嵌套内部类**/
    //类标记为inner,可以访问外部类成员:
    inner class Inner {
        fun foo() = bar  // 访问外部类成员

        fun innerTest() {
            var o = this@Outer //获取外部类的对象
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }
}

fun main(args: Array<String>) {
    val demo = Outer().Inner().foo()
    println(demo) //   1
    val demo2 = Outer().Inner().innerTest()
    println(demo2)   // 内部类可以引用外部类的成员，例如：成员属性
}

要访问来自外部作用域的 this，我们使用this@label，其中 @label 是一个 代指 this 来源的标签

• 匿名内部类

class Test {
    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}

/**
 * 定义接口
 */
interface TestInterFace {
    fun test()
}

fun main(args: Array<String>) {
    var test = Test()

    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例。
     */
    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}

14、类的修饰符：

• classModifier: 类属性修饰符，标示类本身特性。

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

• accessModifier: 访问权限修饰符

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

15、继承：

Kotlin 中所有类都继承该 Any 类，它是所有类的超类，对于没有超类型声明的类是默认超类

如果一个类要被继承，可以使用 open 关键字进行修饰

open class Base(p: Int)           // 定义基类

class Derived(p: Int) : Base(p)

• 子类有主构造函数
  则基类必须在主构造函数中立即初始化

open class Person2(var name : String, var age : Int){// 基类
}

class Student(name : String, age : Int, var no : String, var score : Int) : Person2(name, age) {//子类
}

• 子类没有主构造函数
  则必须在每一个二级构造函数中用 super 关键字初始化基类，或者在代理另一个构造函数。初始化基类时，可以调用基类的不同构造方法。

class Student : Person {
    constructor(ctx: Context) : super(ctx) {
    } 

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
    }
}

16、重写：

在基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写。如果允许子类重写该函数，那么就要手动添加 open 修饰它, 子类重写方法使用 override 关键词：

/**用户基类**/
open class Person{
    open fun study(){       // 允许子类重写
        println("我毕业了")
    }
}
/**子类继承 Person 类**/
class Student : Person() {
    override fun study(){    // 重写方法
        println("我在读大学")
    }
}

多个相同的方法（继承或者实现自其他类，如A、B类），则必须要重写该方法，使用super范型去选择性地调用父类的实现。

• 示例

open class A {
    open fun f () { print("A") }
    fun a() { print("a") }
}
interface B {
    fun f() { print("B") } //接口的成员变量默认是 open 的
    fun b() { print("b") }
}
class C() : A() , B{
    override fun f() {
        super<A>.f()//调用 A.f()
        super<B>.f()//调用 B.f()
    }
}
fun main(args: Array<String>) {
    val c =  C()
    c.f();

}

• 输出
  AB
• 属性重写
  使用 override 关键字，属性必须具有兼容类型，每一个声明的属性都可以通过初始化程序或者getter方法被重写：

interface Foo {
    val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
}