kotlin学习（7）-继承

类默认都是封闭的，要让某个类开放继承，必须使用open关键字修饰

open class Product(val name: String) {

    fun description() = "product:$name"
    //方法使用open修饰才能被子类重写
    open fun load() = "nothing.."
}

//继承product
class ChildProduct : Product("child") {
    //重写方法也需要open修饰
    override fun load(): String = ""
    fun special() = "child special fun"
}

无需在代码里显示指定，每一个类都会继承一个共同的类叫做Any的超类

//所有类的超类
public open class Any {
    
    public open operator fun equals(other: Any?): Boolean

    public open fun hashCode(): Int

    public open fun toString(): String
}

object关键字

可以定义一个只能产生一个实例的类-单例 使用object关键字有三种方式

• 1、对象声明
• 2、对象表达式
• 3、伴生对象：如果你想将某个对象的初始化和一个实例捆绑在一起，可以使用伴生对象，使用companion修饰符，可以在一个类定义里声明一个伴生对象，一个类里只能有一个伴生对象

//声明的方式
object ApplicationConfig{
    init {
        println("ApplicationConfig loading..")
    }
    
    fun doSomething()= print("doSomething..")
}

fun main() {
    //类名，实例名
    ApplicationConfig.doSomething()
    //同一个对象
    print(ApplicationConfig)
    print(ApplicationConfig)
}

open class Player {
    open fun load() = "load..."
}

fun main() {
    //对象表达式
    var p = object : Player() {
        override fun load() = "load override..."
    }
    print(p.load())
}

open class ConfigMap{
    
    //只有当调用load或者或者实例化ConfigMap 此object才会被实例化
    companion object{
        private const val PATH = "xxx"
        fun load() = File(PATH).readBytes()
    }
}

fun main() {
    //调用（类似于java中的static关键字）
    ConfigMap.load()
}

嵌套类

• 如果一个类只对另一个类有用，那么将其嵌入到该类中并使这两个类保持在一起是合乎逻辑的，可以使用嵌套类

class Test1 {
    //嵌套类
    class InnerTest1(var name: String) {
        fun show() = "$name"
    }

    fun battle() {}
}

//调用
Test1.InnerTest1("name").show()

数据类

• 是专门用来存储数据的类
• 提供了toString的个性化实现
• ==默认情况下，比较对象就是比较他们的引用值，数据类型提供equals和hashCode的个性化实现

data class TestData(var x: Int, var y: Int) {
    var isRight = x > 0 && y > 0
}

    val testData1 = TestData(10, 10)
    val testData2 = TestData(10, 10)
    //==比较的是内容
    //===比较的是引用
    //data修饰后会覆盖equals和hashCode方法 返回true（不用data修饰则返回false）
    print(testData1 == testData2)