Kotlin对象-修饰符

类的修饰Open、Override、final：

package com.init.demo.modify

/***
 * 对象：修饰符
 */
open class  ModifyPerson{
    open var name:String =""
    open var age:Int =0
    var height:Double =0.0
    var weight:Double =0.0

    /**
     * 子类方法重写超类方法时，超类方法不添加open，编译器提示error:
     *       'printlnInfomation' in 'ModifyPerson' is final and cannot be overridden
     * 超类方法加上open修饰符，意味着该方法可被重写，如果没有，超类方法会默认添加final
     * 修饰符，意味着该方法不可被重写
     */
    open fun  printlnInfomation() = println("name${name}")
}

/**
 * 子类继承超类时，超类不添加open，编译器提示error:
 *          This type is final, so it cannot be inherited from
 *  超类加上open修饰符，意味着该类可被继承，如果没有，超类会默认添加final
 *  修饰符，意味着该类不可被继承
 */
open class ModifyStudent:ModifyPerson(){

    /**
     * 子类属性重写超类属性时，超类属性不添加open，编译器提示error:
     *      'xxx' in 'xxxxx' is final and cannot be override
     * 超类属性加上open修饰符，意味着该属性g可被重写，如果没有，超类属性会默认添加final
     * 修饰符，意味着该属性不可被重写
     */
    override var  name:String = "xxx"
    final  override  var age:Int =18

    override fun  printlnInfomation() = println("name${name}")
}

/**
 * Kotlin中，在进行继承一个类后进行override修饰，这个修饰
 *  也使某个方法、属性open化，可以使以后的类继承、覆盖重写
 */
class ModifyGoodStudent:ModifyStudent(){
    override var  name:String = "yyyy"
    /**
     * 在属性和方法添加修饰符final，以后继承他的类方法和属性就没法覆盖和重写
     * //age' in 'ModifyStudent' is final and cannot be overridden
     */
//    override  var age:Int =18
    override fun  printlnInfomation() = println("name${name},AGE=$age")

}

接口的修饰Open、Override、final：

package com.init.demo.modify

/**
 * 接口和非抽象类是不同的，接口可以把属性和方法进行抽象化，
 * 不对其进行具体的赋值和实现，而非抽象类是不可以的。
 * 那么接口需要加上open修饰符吗？不需要，在Kotlin中，
 * 接口本身和它内部的方法和属性都是默认加上open修饰符的，
 * 和普通类中默认加上final修饰符是不同的。当然，
 * 在接口中也不能手动加上final修饰符，因为接口本身就是为了抽象而存在.
 */
interface ModifyinterfacePerson {
    var name: String
    var age: Int
    fun  printlnInfomation()
}

修饰符：private、protected、internal、public的使用：

package com.init.demo.modify

/**
 * private 这个属性只能在内的内部访问（包含其所有成员）
 * 无论是在子类还是其他类，外部都不能访问private命名的方法、属性
 * 外部访问时，报一下error：
 *       Cannot access 'age': it is private in 'DemoPersonPrivate
 *  protected   不仅可以在内部可见 还可以在在子类可以见
 *  但是在其他不是子类的类里面，还是会报错：
 *       Cannot access 'age': it is private in 'DemoPersonPrivate
 * protected的方法和属性只能在当前类和他的子类中可见，其他地方是不可以的
 * internal 能见到类声明的本模块内的客户端都可见
 * public 能见到类声明的任何客户端都可见
 */
 open  class DemoPersonPrivate(name: String, age: Int, weight: Double, height: Double) {

    protected val name = name
    private val age = age
    public val weight = weight
    internal val height = height

    fun printInfomation(){
        println(name)
        println(age)
        println(weight)
        println(height)
    }

//    private fun zero() = println("0")

    protected fun zero() = println("0")

    internal fun printAge() = println(age)

    internal fun printWeight() = println(weight)
}

子类继承DemoPersonPrivate：

package com.init.demo.modify

class DemoPersonCHildPrivate(name: String, age: Int, weight: Double, height: Double) : DemoPersonPrivate(name, age, weight, height) {

    /**
     *private 在子类中访问时error：
     * Cannot access 'zero': it is invisible (private in a supertype) in 'DemoPersonCHildPrivate
     */
    fun access() {
        print(name)
        zero()
    }
}

测试类1:

package com.init.demo.model

import com.init.demo.modify.DemoPersonPrivate

fun main(args: Array<String>) {
    val demoPersonPrivate = DemoPersonPrivate("xiaoMing", 20, 158.0, 176.0)
    println(demoPersonPrivate.height)
    demoPersonPrivate.printAge()

    demoPersonPrivate.printWeight()

    /**
     * 小结：open和final修饰符是针对类和类中的属性及方法。
     * 类、象、接口、构造函数、方法、属性和它们的setter
     * 都有可见性修饰符（getter总是与属性有的可见性）。
     */
}

测试类2：

package com.init.demo.modify

fun main(args: Array<String>) {

    val demoPersonPrivate = DemoPersonPrivate("xiaoMing",20,158.0,176.0)
//    println(demoPersonPrivate.name)
    //通过内部方法访问其内部成员属性
    demoPersonPrivate.printInfomation()


}