Kotlin学习笔记——可见性修饰符

    在

Kotlin

中，类、对象、接口、构造函数、方法、属性和它们的

setter

都可以有 可见性修饰符。 （

getter

总是与属性有着相同的可见性。） 在

Kotli

n 中有这四个可见性修饰符：

private

、

protected

、

internal

和

public

。 如果没有显式指定修饰符的话，默认可见性是

public

。

包内顶层声明的访问修饰符

可以在函数、属性和类、对象和接口顶层声明，即直接在包内声明

package com.xiaoying.base
fun main(args: Array<String>) {
    
}

// 只在文件内可见
private fun test() {
}

class Base {
}
           

顶层声明的访问修饰符有以下特点

• 如果你不指定任何可见性修饰符，默认为

  public

  ，这意味着你的声明将随处可见；
• 如果你声明为

  private

  ，它只会在声明它的文件内可见（如果类内部的）；
• 如果你声明为

  internal

  ，它会在相同模块内随处可见；

• protected

  不适用于顶层声明。

• 一个文件只能有一个包声明。
• 虽然

  public

  修饰符随处可见，但是在不同的包进行引用时，必须导入包。

类和接口中声明的修饰符

对于类内部声明的成员：

• private

  只在这个类内部（包含类所有成员）可见；

• protected

  在这个类的内部极其子类中可见（如果覆盖一个 protected 成员并且没有显式指定其可见性，该成员还会是 protected 可见性）；

• internal

  只在能见到类声明的本模块内可见；

• public

  在能见到类声明的任何地方都可见这个类的

  public

  成员。

注意： 跟Java不同的是，Kotlin中外部类不能访问内部类的 private 成员。

open class A {

    // 没有指定默认public
    open fun printTest() {
        test()

        val b = B()
        b.printTest() // public的成员，只要能看见类声明的地方都可以访问

//        b.test() B类中的private成员，只能在B内部访问，外部无法访问
    }

    private fun test() {
        println("This is test in A")
    }

    protected open fun play() {
        println("Play in A")
    }

    internal fun stopPlay() {
        println("Stop play in A")
    }
}


class B {
    fun printTest() {
        test()
    }

    private fun test() {
        println("This is test in B")
    }
}

class C: A() {

    // 重写父类的protected成员，没有指定访问修饰，默认是protected
    override fun printTest() {
        val d = D()
        d.printTest() // 内部类的public成员可以访问
        // d.test() // 内部类的private成员不可访问，这是跟java的不同之处
    }

    fun superPlay() {
        // 父类protected的成员，在子类中可以访问
        super.play()
    }

    override fun play() {
        println("Play in C")
    }
    
    class D {
        fun printTest() {
            test()
        }
        
        // 内部类的private成员，外部类无法访问
        private fun test() {
            println("This is test in D")
        }
    }
}
           

为构造函数添加访问修饰

    默认情况下，构造函数都是

public

的。

注意：如果主构造函数修改了默认的（

public

）访问修饰符，则需要显式使用

constructor

关键字

// 主构造函数如果修改默认的修饰符，需要添加constructor关键字
class B private constructor(var id: String) {
    
    private constructor(id: String, name: String): this(id) {
        
    }
    
    fun printTest() {
        test()
    }

    private fun test() {
        println("This is test in B")
    }
}