1. 基本类型

package com.brain.day1
/**
 * 基本数据类型.
 * 1. Kotlin 只有8种基本数据类型没有包装类型.
 * 2. kotlin自动根据使用场景选择使用基本数据类型还是包装数据类型
 */
fun main(args: Array<String>) {
    baseDataType()
    autoTypeConfirm()
    varAndVal()
}

/**
 * 可变变量 : 使用var 修饰的变量, 可以修改.
 * 不可变变量 : 使用val修饰, 不可修改.
 *
 * 注意 : 建议使用val, 如果需要修改再换成var.
 */
fun varAndVal() {
    // 1. var // 可以修改.
    var v1 = 12
    v1 = 13

    // 2. val 不可修改
    val v2 = 13
    // error : val can not be reassigned .
    // v2 = 14
}

/**
 * 自动类型推导
 */
fun autoTypeConfirm() {
    // 1. 正常书写: 给出类型
    val i1:Int = 13

    // 2. 使用智能类型推导, 直接赋值Kotlin可以根据赋值的类型判断 变量类型.
    val i2 = 13
}

/**
 * 8种基本数据类型.
 */
private fun baseDataType() {
    var a: Boolean = true
    var a1: Byte = 1
    var short: Short = 20
    var char: Char = 'a'
    var int: Int = 100
    var f: Float = 1.12345f
    var double: Double = 1.12345
    var l: Long = 10L

    // 字符串类型.
    var s: String = "张三"
}

2. 字符串

package com.brain.day1

/**
 * String
 */
fun main(args: Array<String>) {
    func1()
    func2()
    func3()
}

/**
 * 字符串比较
 * equals  字符串值是否相等
 * == 相当于equals
 * ===相当于java的 == 比较内存地址
 */
fun func3() {
    val s1 = "hello"
    // 创建一个新的String.防止内存地址相同.
    val s2 = String(charArrayOf('h','e','l','l','o'))

    // 1. 比较值
    println(s1.equals(s2))
    // 2. 比较值
    println(s1 == s2)
    // 3. 比较地址
    println(s1 === s2)
}

/**
 * 删除空格, trimMargin(marginPrefix:String)
 */
fun func2() {
    val s2 = """
        01
        02
        03
    """
    println(s2)
    println(s2.trimIndent())
    val s3 = """
        |01
        |02
        |03
    """
    // 删除 | 之前的空格.默认是 | 也可以设置其他字符.
    println(s3.trimMargin())
    val s4 = """
        ,01
        ,02
        ,03
    """
    println(s4.trimMargin(","))
}

/**
 * 两种方式
 */
fun func1() {
    // 1. 普通方式, 里面可以有转义字符
    val s1 = "I am Jack , \n My age is 12"
    // 2. 原生字符串, 没有转义字符
    val s2 = """
       row 1 \n ,
       row 2 \n
    """.trimIndent()

    println(s1)
    println(s2)
    // 1. trimIndent() 删除前面的空格.
}

3. 元组

package com.brain.day1

/**
 * 元组数据, 其实就是封装了一个data类.
 * 二元元组 2个属性 Pair
 *  第一种:Pair("张三",30)
 *  第二种:"张三" to 30
 * 三元元组 3个属性
 *  三元元组定义: Triple("张三",30,"14567890000")
 */
fun main(args: Array<String>) {
    pairFunc()
    tripleFunc()
}

/**
 * 三元元组
 *  1. Triple(v1, v2, v3)
 */
fun tripleFunc() {
    val t1 = Triple("Jack",12,170)
    println(t1)
}

/**
 * 二元元组
 *  1. Pair(value1, value2)
 *  2. value1 to value2
 */
fun pairFunc() {
    val p1 = Pair("Jack", 12)
    val p2 = "Tim" to 13
    println(p1)
    println(p2)
}

4. 空值处理

package com.brain.day1

/**
 * 空值处理
 * null空
 * val s:String   s不为空的类型 不能赋值为null
 * val s: String? s是可空类型  可以赋值为null
 *
 * ?.  空安全调用符
 * !!  非空断言 告诉编译器当前s一定不为null 如果s为null会产生空指针异常
 */
fun main(args: Array<String>) {
    // 1. 定义字符串, 不能赋值为null, 类型不匹配.
    // val s1: String = null

    // 2. 定义可空类型字符串, 可以赋值null
    var s2: String? = null
    // 使用时需要判断 if
    if(s2!=null){
        println(s2.toInt())
    }else{
        println("s2 为 null")
    }

    // 3. 空安全调用符 : "?." 如果前面的变量!=null 才会执行后面的函数,否则不执行函数直接返回null.
    println(s2?.toInt())

    // 4. 非空断言 : "!!"告诉编译器,变量一定!=null, 注意如果为null则产生空指针异常.
    s2 = "123"
    println(s2!!.toInt())


    // 5. ?:Elvis操作符 可以设置一个返回值
    val s3: String? = null
    // 如果 s3 == null则返回 ":" 后面的数据(-1), 否则返回s3.toInt()的值
    val a:Int = s3?.toInt()?:-1
    println(a)
}

5. 输入输出函数

package com.brain.day1

/**
 * 输入 : readLine()
 * 输出 : println()
 */
fun main(args: Array<String>) {
    /*---------------------------- 输出函数 ----------------------------*/
    val a = 10
    val b = 20
    println("a=$a b=$b")

    /*---------------------------- 输入函数 ----------------------------*/
    var s:Int = 0
    // 从控制台输入数据
    s = readLine()?.toInt()?:-1
    println(s)
}