针对定义类的属性 kotlin会自动生成field、getter、setter，field用来存储属性数据 不能直接定义field 只暴露给getter、setter使用
默认都是封闭的（private）使其可以开放继承 使用open修饰

class Player{
    var name:String = "jack"
    //重写get set 方法
    get() = field.capitalize()//首字母大写
    set(value){
        field = value.trim() // 去掉空格
    } 
}
fun main() {
    var p = Player()
    println(p.name)
    p.name = " HHH "
    println(p.name)
}

主构造函数

class Player(
    _name:String, //下划线表示临时变量
    var age:Int,
    var isNormal:Boolean
){
    var name = _name
        get() = field.capitalize()//首字母大写
        set(value){
            field = value.trim() // 去掉空格
        }
//    var age = _age
//        get() = age.absoluteValue//取绝对值
//        set(value){
//            field = age.absoluteValue//取绝对值
//        }
//    var isNormal = _isNormal
    //重写构造函数constructor 注意参数对齐
    constructor(name:String):this(name,age=10,isNormal=false){
    this.name = name.toUpperCase() //全部大写字母
}
}
fun main() {
    val p = Player("Tony",12,true)
    println(p.name+p.age+p.isNormal)
}

初始化顺序

• 主构造函数里声明的属性
• 类级别的属性赋值
• init初始化块里的属性赋值和函数调用
• 次构造函数里的属性赋值和函数调用
  
• lateinit延迟初始化
• 惰性初始化

继承

• 继承父类 重写父类的方法是，父类方法前也要加 open 关键字
• as 操作符声明，也可以当做是一个类型转换
• kotlin中的超类的使用：any

Object

使用object可以定义一个只产生一个实例的类（单例）
三种使用方式：

1. 对象声明
2. 对象表达式（相当于传入一个匿名内部类对象）
3. 伴生对象（companion）一个类只有一个伴生对象（类中的伴生对象使用companion标记，伴生对象相当于java中的静态方法，使用companion来标记方法）

//对象声明
object ApplicationConfig{
    init {
        println("ApplicationConfig loading...")
    }
    fun doSomething(){
        println("doSomething")
    }
}
fun main() {
    // 类名 实例名 -> 单例
    // 对象声明
    ApplicationConfig.doSomething()
}

//对象表达式
open class Player(){
    open fun load() = "loading nothing..."
}
fun main() {
    //匿名类 依然遵循object关键字的原则 实例化后只有唯一的实例存在 
    val p = object:Player(){
        override fun load(): String {
            return "anonymous nothing..."
        }
    }
    println(p.load())
}

//伴生对象
open class ConfigMap{
    companion object{
        private const val PATH = "XXX"
        fun load() = File(PATH).readBytes()
    }
}
fun main() {
    //类比 static
    ConfigMap.load()
}

嵌套类

如果一个类只对另一个类有用，可以使用嵌套，将其嵌套进该类中，是这两个类保持在一起
实际开发过程中的例子可参考：在adapter类中，嵌套viewholder类

class Player{
    class Equipment(var name:String){
        fun show() = println("equipment:$name")
    }
    fun battle(){
        Equipment("sharp knife").show()
    }
}
fun main() {
    Player.Equipment("AK47").show()
}

数据类

经常需要比较、复制、打印自身内容的类

1. 数据类必须有至少带一个参数的主构造函数
2. 数据类主构造函数的参数必须是val或var
3. 数据类不能使用abstract open sealed inner 修饰符
4. 数据类不能继承类，但是可以实现接口

//用关键字 data 修饰
data class Coordinate(var x:Int,var y:Int){
    val isInBounds = x > 0 && y > 0
}
fun main() {
    println(Coordinate(10,20))
    //== 比较的是内容 ===比较的是引用
    //类没有具体实例 默认是any 超类 ==调用的是equals方法，默认实现=== 比较引用
    println(Coordinate(10,20) == Coordinate(10,20))
}

5. copy函数
   
6. 数据类支持解构（后台声明component1 component2）自动为所有定义在主构造函数的属性添加对应的组件函数
7. 运算符的重载
   

data class Coordinate(var x:Int,var y:Int){
    val isInBounds = x>0 && y>0
    //重载运算符 +
    operator fun plus(other:Coordinate) = Coordinate(x+other.x,y+other.y)
}
fun main() {
    val c1 = Coordinate(10,20)
    val c2 = Coordinate(10,20)
    println(c1 + c2)
}

枚举类

//数据类
data class Coordinate(var x:Int,var y:Int){
    val isInBounds = x>0 && y>0
    //重载运算符 +
    operator fun plus(other:Coordinate) = Coordinate(x+other.x,y+other.y)
}
//枚举类
enum class Direction(private val coordinate: Coordinate){
    EAST(Coordinate(1,0)),
    WEST(Coordinate(-1,0)),
    SOUTH(Coordinate(0,1)),
    NORTH(Coordinate(0,-1));
    //枚举类里 定义函数
    fun updateCoordinate(playerCoordinate: Coordinate) =
        Coordinate(playerCoordinate.x+coordinate.x,
        playerCoordinate.y+coordinate.y)
}
fun main() {
    println(Direction.EAST.updateCoordinate(Coordinate(10,20)))
}

• 扩展函数

扩展可以在不直接修改类定义的情况下增加类功能，在你无法接触某个类定义，或者某个类没有使用open修饰符，导致你无法继承它时，扩展就是增加类功能的最好选择

//给字符串添加扩展函数
fun String.addExt(amount:Int = 1) = this + "!".repeat(amount)
fun main() {
    println("abc".addExt(2))
}