本文收录于 kotlin入门潜修专题系列，欢迎学习交流。

创作不易，如有转载，还请备注。

访问权限修饰符

访问权限修饰符也可叫做可见性修饰符（Visibility Modifiers），了解java语言的应该很清楚，这里先介绍下java中的四种权限访问修饰符。

有朋友会说java不就三种访问修饰符吗？private、protected、public，还有什么访问修饰符？

是的，通常我们常用的也就这三个，事实上也够用了。其实java中还有一个默认的default的权限控制，但是并没有明确的关键字，当定义字段的时候不写private、protected、public就表示该字段是default。java中的权限修饰符可见性总结如下：

	public	protected	default	private
同一类中的成员	是	是	是	是
同一包中的成员	是	是	是	否
不同包中的子类	是	是	否	否
不同包中的非子类	是	否	否	否

接下来看下kotlin中的权限访问修饰符

kotlin中也有四种权限访问修饰符：private、protected、internal、public。kotlin中如果不显示指定权限访问修饰符，则默认是public的，这个和java不太一样。

kotlin中权限访问修饰符可以修饰类、单例对象、接口、构造方法、方法、属性以及属性的set方法。这里我们先一步步看下kotlin中的不同访问权限场景，然后再给出一个权限访问修饰符的总结列表。

top-level级别的权限访问修饰符

kotlin中，类、方法、属性、单例对象以及接口都可以被定义为top-level级别的，所谓top-level实际上前面已经讲到过，即脱离了类的控制，不在类中定义。如下所示：

package com.test
//下面的属性、方法、class都直接定义在了com.test包下的Person.kt文件中，都属于top-level级别的成员
val name = "zhangsan"//没有修饰符，则默认是public，任何地方都可以使用
private val age = 20//private修饰，只能当前文件中使用，即只能在Person.kt中使用
internal val state = "china"//internal修饰，在同一个module中可以访问
public var phone: Int = 5//其实这里public是多余的，默认都是public的
    private set//注意这里使用private修饰了phone的set方法，表示只能在当前文件中修改phone的值，外部无法修改。

protected val sex = "男"//!!!编译错误，top-level级别的成员无法使用protected修饰

internal fun getAddress(): String {//使用访问权限修饰符修饰的方法的可见性同属性一样，这里也是同一个module可见
    return "hang zhou"
}

private fun printAge() {//只能在当前文件中可见
    println(age)
}

class Person {//默认是public
}

上面代码中，已经对各个场景做了详细注释。再总结一下：

1. 如果没有显示指定访问权限修饰符，则默认是public，即随处可见。
2. 如果使用private修饰，则只能在当前文件中使用。
3. 如果使用internal修饰，则在同一个module中都是可见的。
4. protected修饰符是不允许修饰top-level成员的。
   还需要注意一点，想要使用top-level成员，必须要import。如下所示：

//在另一个文件中使用上面Person.kt中的top-leve属性name，则需要import
import com.test.name
class Test {
    fun test() {
        println(name)//import后即可使用
    }
}

最后，关于internal修饰符，总是说能在同一个module中访问，那么什么是同一个module？kotlin中是这样定义的：

1. 一个intellij IDEA module。即使用idea ide 新建文件的时候，选择的是module类型。
2. 一个maven工程。这个用过maven的都应该能理解。
3. 一个gradle SourceSet。gradle和maven类似，后面会有文章来阐述kotlin和gradle。
4. ant中， 使用kotlinc（针对jvm的kotlin编译器）命令编译的文件集合。
   一般情况下，第一种是我们自己建立的，后三种都是结合构建工具进行构建的，后面文章会有所阐述，这里姑且了解下。

类和接口中的修饰符

照例，我们来先看一段代码示例

//ParentClass，位于com.test包下
package com.test
open class ParentClass {
    private val a = 1
    protected open val b = 2
    internal val c = 3
    val d = 4
    protected class Nested {
        public val e = 5
    }
}

//ParentClass的子类SubClass
package com.test
class SubClass : ParentClass() {
    fun test() {
        Nested()//正确，子类能访问protected
        super.a//编译错误，private只能在同一个类中访问
        super.b//正确，子类能访问父类的protected成员
        super.c//正确，子类能访问父类internal的成员
        super.d//正确，子类能访问父类的public成员
    }
}

//同一个包下的成员
package com.test
class Test {
    fun test(){
        val p = ParentClass()
        p.c//正确，同一个包下的其他成员可以访问另一个成员的internal成员
        p.d//正确，同一个包下的其他成员可以访问另一个成员的public成员
        p.b//错误，同一个包下的其他成员无法访问另一个成员的protected成员
        p.a//错误，同一个包下的其他成员无法访问另一个成员的private成员
    }
}

上面例子已经标注了类和接口的访问权限情况，但是相信很多朋友容易看出神，这里我们再总结下。

1. private修饰，意味着只有在class内部可见。
2. protected修饰，在class内部可见，子类中也可见。
3. internal修饰，同一个module中可见。
4. public修饰， 任何地方都可见。

另外需要注意的是：

1. 外部类无法访问内部的类中的private和protected成员。如下所示：

open class ParentClass {
    fun test() {
        val nested = Nested()
        nested.e//正确，可以访问内部的类中的public修饰的成员
        nested.f//错误，无法访问内部的类中的protected修饰的成员
        nested.d//错误，无法访问内部的类中的private修饰的成员
    }
    protected class Nested {
        protected var f = 1;
        private var d = 2;
        val e = 5
        fun test() {
            val p = ParentClass()
            println()
        }
    }

2. 在override一个属性的时候，如果不改变其访问权限修饰符，则默认和父类一致。
3. override只能扩充父类的访问权限修饰符范围，不能缩小。如父类使用了protected修饰，子类在override的时候可以修改为public，但不能修改为private。

构造方法

构造方法默认的修饰符都是public的，可以显示指定修饰符，如下所示：

class MyClass private constructor() {//private修饰的constructor，意味着只能在SubClass内部生成对象，无法在外部生成对象。
    fun getInstance(): MyClass {//MyClass内部可以使用，有没有种java单例的感觉？
        return MyClass()
    }
}
//外部无法使用
class Test {
    val myClass = MyClass()//错误，MyClass构造方法是私有的，无法再外部使用，也无法继承
}

注意，private修饰构造方法和修饰类是两个概念，再看下下面的代码

private open class MyClass constructor() {//这种方式表示MyClass这个类是私有的，对外界是不可见的，即外界无法使用，也无法继承
}

总结

能看到这里的朋友应该都是很厉害的了，因为我自己写的时候都已经很痛苦了，各种权限修饰，各种例子展示。在具体使用中如果时时记着这些场景确实很难受。当然万事万物都有个熟能生巧的过程，写多了自然而然就知道了，所以在彻底理解清楚之前，可以把本篇文章作为一个词典，什么时候忘记了什么时候过来看一眼即可。

下面给出一份总结：

1. top-level级别的成员

	public	protected	internal	private
同一类中的成员	是	无法使用	是	是
同一module中的成员	是	无法使用	是	否
不同module中的成员	是	无法使用	否	否

2. 类或接口的成员

	public	internal	protected	private
同一类中的成员	是	是	是	是
子类中的成员	是	是	是	否
同一module中的成员	是	是	否	否
不同module中的成员	是	否	否	否