kotlin 第五站

//Kotlin 类和对象
//Kotlin 类包含：构造函数、初始代码块、函数、属性、内部类、对象说明
//Kotlin 中使用class 关键字声明类，后面紧跟类名
class Person(sex:Int){//主构造函数

    //属性定义
    //类的属性可以用var关键字声明可变的，否则使用只读关键字val声明为不可变的
    var name:String?=null//手动实现get、set方法

    get() =  field //field 为后端变量

    set(value) {value}//value 表示传入的值

    var city:String?=null//如果不写get、set方法Kotlin会生成默认的get/set方法完成赋值取值
    val sex :Int?//默认实现get方法，但必须要在构造方法中初始化
    var height = 154.5f
    private set //把set方法私有化，只能在本类中进行赋值，该类对象不能进行赋值
    init {//构造方法
        this.sex = sex
        this.height = 160f
    }
    fun run(){
        println("person can run")//成员函数
    }
}
class Person2(name:String){
    //类可以有二级构造函数，需要在前面添加constructor
    //如果类有主构造函数，每个次要构造函数都要直接或者间接调用这个主构造函数
    //如果一个非抽象类没有声明构造函数（主构造函数和次构造函数），会自动生成一个无参的构造函数
    //构造函数都是public，如果不想类有公共的构造函数可以声明成private constructor（）
    constructor(name : String , age : Int):this(name){//次构造函数
        this.age=age
    }
    var name :String? = null
    var age : Int = 0
    init {
        this.name = name
    }
}
//抽象类
//抽象是面向对象的特征之一，类本身或类中部分成员都可以声明成abstract的。
//抽象成员在类中不存在具体的实现
//注意：无需对抽象类或成员标注open注解
open class Base{//如果类不用open修饰，该类就是final 不允许继承
    open fun f(){}// 如果方法不用open修饰，方法也是final 的不允许重写
}
abstract class Derived:Base(){
    override abstract  fun f()
}
//嵌套类  我们可以把类嵌套在其他类中
//内部类  内部类使用inner关键字来表示
class Outor{ //外部类
    private val bar = 1
    var ss = 9
    class Nested{ //嵌套类
        fun foo() = 2
    }
    inner class Inner{
        fun foo() = println("bar = $bar")
        fun innerTest(){
            var o = this@Outor //为了消除歧义，要访问来自外部作用域的this，需要使用this@lable
            println("内部类可以引用外部类的成员，例如：" + o.ss)
        }
    }
}

/**
 * 第一接口
 */
interface ITestInterface{
    fun test()
}
class Test{
    var v = "成员属性"
    fun setInterface(inter:ITestInterface){
        inter.test()
    }
}


fun main(args:Array<String>){
    var person = Person(1)// Kotlin 中没有new关键字
    person.run()
    person.city = "北京"
    person.name = "张三"
    val va = Outor.Nested().foo()//调用格式 外部类.嵌套类().嵌套方法或属性
    println(va)
    val inn = Outor().Inner()
    inn.foo()
    inn.innerTest()
    var test = Test()
    /**
     * 通过对象表达式创建接口对象，即匿名内部类实例
     */
    test.setInterface(object : ITestInterface{
        override fun test(){
            println("对象表达式创建匿名内部类的示例")
        }
    })
}
/**
 * 类的修饰符
 * 类的修饰符包括 classModifier 和 accessModifier
 * classModifier：类属性修饰符，标示类本身特性
 * abstract 抽象类
 * final 类不可被继承 默认属性
 * enum 枚举类型
 * open 类可继承 ， 类默认是final
 * annotation 注解类
 *
 * accessModifier 访问权限修饰符
 * private 仅在同一个文件中可用
 * protected 同一个文件中或子类中可见
 * public 所有调用的地方都可见
 * internal 同一个模块中可见
 * */