// 读写变量
var name: String = "ly"
// 只读变量
val age: Int = 18

class MainActivity : AppCompatActivity() {
    val age: Int // = 18
    constructor() {
        this.age = 18
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val tempVar: String
        ...
        tempVar = "初始值"
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        var a:String = null // 编译报错
        var a:String? = null // 编译通过
        if(savedInstanceState != null) {
            a = "HelloWorld"
        }
        Log.d("liuyang", "${a.length}") // 编译报错
    }

}

class Animal(name: String, age: Int) {
    var name: String
    var age: Int
    init {
        this.name = name
        this.age = age;
    }
    // 运算符重载
    operator fun plus(other: Animal): Animal{
        this.name = this.name + other.name
        this.age = this.age + other.age
        return this;
    }

}

var animal: Animal = Animal("animal", 2);
var animal2: Animal = Animal("animal2", 1);
var animal3: Animal
// 下面两个写法是一样的
animal3 = animal.plus(animal2);
animal3 = animal + animal2 // 编译为字节码的代码：animal.plus(animal2);

var a = "字符串"
var b = a
var c = a
print(b === c) // 结果为true

// 创建数组
var array: Array<String>
array = arrayOf("a", "b", "c");
array = Array<String>(3, {index-> "a${index}"})

// 创建List
var list: List<String>
list = listOf("a", "b", "c")        // 长度不可变
list.add("d") // 无此方法，编译报错
list = mutableListOf("a", "b", "c") // 长度可变
list.add("d") // 编译成功
list = arrayListOf("a", "b", "c")   // ArrayList

// 创建Set
var set: Set<String>
set = setOf("a", "b", "c")          // 长度不可变
set.add("d") // 无此方法，编译报错
set = mutableSetOf("a", "b", "c")   // 长度可变
set.add("d") // 编译成功
set = hashSetOf("a", "b", "c")      // HashSet
set = linkedSetOf("a", "b", "c")    // LinkedHashSet

// 遍历值
for (value in array) {
    Log.d("liuyang", "${value}")
}
// 遍历下标
for (index in array.indices){
    Log.d("liuyang", "${array[index]}")
}
// 遍历下标与值
for ((index, value) in array.withIndex()){
    Log.d("liuyang", "${index},${value}")
}

// 创建Map
var map: Map<String, Int>
map = mapOf("Java" to 86, "Kotlin" to 87)         // 长度不可变
// map.put("Flutter", 88) // 无此方法，编译报错
map = mutableMapOf("Java" to 86, "Kotlin" to 87)  // 长度可变
map.put("Flutter", 88) // 编译成功
map = hashMapOf("Java" to 86, "Kotlin" to 87)     // HashMap
map = linkedMapOf("Java" to 86, "Kotlin" to 87)   // LinkedHashMap

// 遍历Entry
for (en in map.entries) {
    Log.d("liuyang", "${en.key},${en.value}")
}
// 解构遍历key，value
for ((key, value) in map) {
    Log.d("liuyang", "${key},${value}")
}
// 遍历key
for (key in map.keys) {
    Log.d("liuyang", "${key},${map[key]}")
}

// 函数
fun add(a: Int, b: Int): Int {
    return a + b
}

// 函数调用
var c: Int = add(1, 2)
var d: Int = add( b = 1, a = 2)
// 创建一个函数类型
var e: (Int, Int) -> Int = ::add
var f: Int = e(1, 2)
//var g: Int = e(a=1, b=2) // 编译不通过

class MainActivity : AppCompatActivity() {

    var clickTime: Int = 0

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        var text: TextView = findViewById(R.id.textView2)
        var btn: Button = findViewById(R.id.btn)

        // OnClickListener是一个函数式接口（只有onClick(View)的方法）
        // setOnClickListener(OnClickListener) 此方法只有一个函数式接口参数，可省略括号
        btn.setOnClickListener { view ->
            text.setText("${text.text} ${++clickTime}")
        }

        // postDelayed(Runnable, long) 有两个参数，且Runnable参数不在最后，不能省略
        btn.postDelayed({
            text.setText("${text.text} ${++clickTime}")
        }, 1000)

    }

}

// 只读属性
val fur: String = "red"
    get() {
        return "fur=${field}" // 拦截fur变量，添加前缀
    }

// 计算属性
val nameAndAge: String
    get(){
        // 没有使用field属性，所以不会生成backing field
        return "${this.name}-${this.age}"
    }

// 定义常量，需处于top-level
// 相当于java里的：static final String TAG = "liuyang"
const val TAG: String = "liuyang"

class Animal constructor(name: String, age: Int) {
    // 只读属性
    // 相当于java里的：final String description = "Animal Class"
    val description: String = "Animal Class"
}

open class Animal constructor(name: String, age: Int) {

    var name: String
    var age: Int
    init {
        this.name = name
        this.age = age;
    }
    open fun showDescription(): String{
        return "Animal description is ${this.name}-${this.age}"
    }
}

// 继承Animal，并调用其主构造器
class Dog(age: Int): Animal("dog", age) {

    // 重写父类的showDescription()方法
    override fun showDescription(): String {
        return "Dog description is ${this.name}-${this.age}"
    }
}

// 使用
var animal: Animal = Dog(3)
        
// 按java的思路的写法，不然会崩溃
if(animal is Dog) {
    var dog: Dog = animal as Dog
}
// 更简单写法
var dog: Dog? = animal as? Dog

var list: List<Int> = mutableListOf(5, 4, 2, 1)

// 给List类扩展sort排序方法
fun List<Int>.sort(){
    Collections.sort(this)
}
list.sort()

Log.d("liuyang", "${list}") // 输出结果为：[1, 2, 4, 5]

interface Action {
    // 只读属性定义了 getter 方法，非抽象属性
    val description: String
        get() {
            return ""
        }

    // 读写属性没有定义 getter、setter 方法，抽象属性
    var name: String

    // 抽象方法
    fun eat(food: String)

    // 非抽象方法
    fun print(vararg msgs: String) {
        for (msg in msgs) {
            println(msg)
        }
    }
}

var btn: Button = findViewById(R.id.btn)
// 对象表达式实现匿名内部类
btn.setOnClickListener(object: View.OnClickListener {
    override fun onClick(v: View?) {
        text.setText("${text.text} ${++clickTime}")
    }
})
// OnClickListener是函数式接口，可使用Lambda表达式
btn.setOnClickListener { view ->
    text.setText("${text.text} ${++clickTime}")
}

// 对象志明---单例
object FoodManager {
    var foods: MutableList<String>
    init{
        foods = mutableListOf<String>()

        // 初始化食物池
        for (i in 1..9) {
            foods.add("food${i}")
        }
    }
}
var foods = FoodManager.foods // 使用对象声明

// 伴生对象---静态成员
interface Outputable{
    fun output(msg: String)
}
class MyClass{
    // 定义的MyClass的伴生对象
    companion object: Outputable{
        val name = ”name属性值” 
        
        //重写父接口中的抽象方法
        override fun output(msg: String) {
            for(i in 1..6){
                println (”<h$(i}>${ msg}</h${i}>”)
            }
        }
    }
}

fun main(args: Array<String>) {
    // 调用伴生对象里的方法与属性，与调用静态成员一样
    MyClass.output("fkit.org")
    println(MyClass.name)
}

interface Outputable {
    var type: String
    fun output(msg: String)
}
// 定义一个DefaultOutput类实现Outputable接口
class DefaultOutput: Outputable {
    override var type: String = "输出设备"
    override fun output(msg: String) {
        for(i in 1..6){
            println("<h${i}>${msg}</h${i}>")
        }
    }
}
// 指定b为委托对象，也可以通过继承DefaultOutput来实现，java里还可以通过Proxy来实现
class Printer(b: DefaultOutput): Outputable by b
// 接口被委托后，还可以重写方法，重写后，就会调用自己重新的方法了
class Printer(b: DefaultOutput): Outputable by b {
    // 重写被委托的方法
    override fun output(msg: String) {
        javax.swing.JOptionPane . showMessageDialog(null, msg);
    }
}

// 属性委托
class PropertyDelegation {
    var name: String by MyDelegation()
}
class MyDelegation {
    private var _backValue = "默认值"
    operator fun getValue(thisRef: PropertyDelegation, property: KProperty<*>): String {
        println("${thisRef}的${property.name}属性执行getter方法")
        return _backValue
    }
    operator fun setValue(thisRef: PropertyDelegation, property: KProperty<*>, newValue: String){
        println("${thisRef}的${property.name}属性执行setter方法")
        _backValue = newValue
    }
}

// Java的基本泛型
class Foo<T> {}
// 对应Kotlin的写法
class Foo<T> {}

// Java的通配符
class Foo<T extends View> {}
// 对应Kotlin的写法
class Foo<out T: View> {}

// java类
public class Utils {
    public static String format(String text) {
        return text.isEmpty() ? null : text;
    }
}

// kotlin调用此java类的三种方式
fun doSth(text: String) {
    // 方式一：指定为不为null类型
    val f: String = Utils.format(text) // 能通过编译
    println ("f.len : ${f.length}") // 运行时可能会报错
    
    // 方式二：不指定类型，让其做类型推断
    val f = Utils.format(text) // 能通过编译
    println ("f.len : ${f.length}") // 运行时可能会报错
    
    // 方式三：指定为可null类型
    val f: String? = Utils.format(text) // 能通过编译
    println ("f.len : ${f.length}") // 编译报错
    println ("f.len : ${f?.length}") // 编译成功，运行时不会报错
}