fun main() {
    var v1:Test<Int> = Test<Int>()
    v1.print(1)
    var v2:Test<String> = Test<String>()
    v2.print("fd")
}

// 模板类
class Test<T>(){
    init{
    }
    
    fun print(v:T){
        println("this is " + when(v){
            is String -> "String "
            is Int -> "Int "
            else -> "Object "
        } + " " + v)
    }
}

public : 对所有人开放。Kotlin的类、函数、变量不加开放性修饰符的话，默认就是public类型。
internal : 只对本模块内部开放，这是Kotlin新增的关键字。对于App开发来说，本模块便是指App自身。
protected : 只对自己和子类开放。
private : 只对自己开放，即私有。

fun main() {
    var v1:Test2 = Test2()
    v1.print1()
    v1.print2()
}

// 被继承前面必须增加open
open class Test(){
    fun print1(){
        println("Test fun1")
    }
    
    // 子类才能重构
    open fun print2(){
        println("Test fun2")
    }
}

class Test2:Test(){
    // 因为父类没设置open所以不能重构
//     override fun print1(){
//         println("Test2 fun1")
//     }
    
    override fun print2(){
        println("Test2 fun2")
    }
}

fun main() {
    var v1:Test = Test("fd", 1, true)
    v1.print()
    var v2:Test = Test("gg",5.5)
    v2.print()
}

// 带var 就会定义同名成员变量，并且只能在类的这个构造函数加
// 也可以增加默认值
class Test(var v1:String, var v2:Int, var v3:Boolean = true){
    init {
        println("v1 " + v1)
        println("v2 " + v2)
        println("v3 " + v3)
    }
    
    // v4 只是参数，这里还想加成员变量也加不了
    constructor( v1:String, v4:Double):this(v1, 0, false){
        println("v4 " + v4)
    }
    
    fun print(){
        println("Test ${this.v1} ${this.v2} ${this.v3}")
    }
}

fun main() {
    println(arrayOf(1,2).sum())
    println("fd".test())
    println(test1({a,b->a+b}))
}

// 扩展函数
fun Array<Int>.sum():Int{
    var sum:Int = 0;
    for(v in this){
        sum += v;
    }
    
    return sum;
}

// 扩展函数
fun String.test():String {
    return this + "_test";
}

// 高级函数
fun test1(v:(Int, Int)->Int):Int {
    return v(100, 200)
}