kotlin set 私有_Kotlin可见性修改器–公共，受保护，内部，私有

kotlin set 私有

In this tutorial, we’ll be discussing the various Visibility Modifiers available in Kotlin programming.

在本教程中，我们将讨论Kotlin编程中可用的各种Visibility Modifiers。

Kotlin可见性修改器 (Kotlin Visibility Modifiers)

Visibility Modifiers are modifiers that when appended to a class/interface/property/function in Kotlin, would define where all it is visible and from where all it can be accessed.
The setters of properties in Kotlin can have a separate modifier from the property. The getters can’t have a visibility modifier defined. They use the same modifier as that of the property.

可见性修饰符是一种修饰符，当附加到Kotlin中的类/接口/属性/功能时，将定义所有可见位置以及可从何处访问所有内容。
Kotlin中的属性设置器可以具有与属性不同的修饰符。 吸气剂不能定义可见性修饰符。 它们使用与属性相同的修饰符。

Following are the visibility modifiers:

以下是可见性修改器：

• public
  上市
• protected
  受保护的
• internal
  内部
• private
  私人的

公共修饰符 (Public Modifier)

A Public Modifier is the default modifier in Kotlin. Just like the Java public modifier, it means that the declaration is visible everywhere.

公共修饰符是Kotlin中的默认修饰符。 就像Java公共修饰符一样，它意味着该声明在任何地方都可见。

class Hello{
}

public class H{
}

fun hi()
public fun hello()

val i = 0
public val j = 5

All the above declarations are the in the top level of the file. ALL are public.
If we don’t mention the declaration of the members of the class, they are public(unless they are overridden).

以上所有声明都在文件的顶层。 所有都是公开的。
如果我们不提及类成员的声明，则它们是公共的（除非它们被重写）。

保护修饰符 (Protected Modifier)

A Protected Modifier in Kotlin:
CANNOT be set on top-level declarations.
Declarations that are protected in a class, can be accessed only in their subclasses.

Kotlin中的保护修饰符：
不能在顶级声明中设置。
在类中受保护的声明只能在其子类中访问。

open class Pr{
    protected val i = 0
}

class Another : Pr{

    fun iValue() : Int
    {
        return i
    }
}

Classes which are not a subclass of Pr cannot access i

不是Pr的子类的类不能访问i

Declarations that are protected, when overridden would have the same protected modifier in the subclass unless you explicitly change them.

除非您明确更改，否则被覆盖的受保护声明在子类中将具有相同的protected修饰符。

open class Pr{
    open protected val i = 0
}

class Another : Pr(){

    fun iValue() : Int
    {
        return i
    }
    
    override val i = 5 //protected visibility
}

The concept of Protected Modifiers in Kotlin that’s defined above differs from that in Java.

上面定义的Kotlin中的保护修饰符概念不同于Java中的概念。

内部修饰符 (Internal Modifier)

Internal is a new modifier available in Kotlin that’s not there in Java.
Setting a declaration as internal means that it’ll be available in the same module only.
By module in Kotlin, we mean a group of files that are compiled together.

Internal是Kotlin中可用的新修饰符，而Java中不存在。
将声明设置为内部意味着它将仅在同一模块中可用。
所谓Kotlin中的模块，是指一组一起编译的文件。

internal class A {
}

internal val x = 0

These won’t be visible outside the current module.
Internal Modifiers is useful when you need to hide specific library implementations from the users.
This wasn’t possible using the package-private visibility in Java.

这些在当前模块之外不可见。
当您需要向用户隐藏特定的库实现时，“内部修饰符”很有用。
使用Java中的程序包专用可见性是不可能的。

私人修饰符 (Private Modifiers)

Private Modifiers do not allow the declarations to be visible outside the current scope.

私有修饰符不允许声明在当前作用域之外可见。

var setterVisibility: String = "abc"
private set

open class Pr{
    open protected val i = 0

    fun iValue() : Int
    {
        setterVisibility = 10
        return setterVisibility
    }
}

Since kotlin allows multiple top level definitions the above code works.

由于kotlin允许多个顶级定义，因此上述代码适用。

The below doesn’t

以下不

private open class ABC{
    private val x = 6
}

private class BDE : ABC()
{
    fun getX()
    {
        return x //x cannot be accessed here.
    }
}

x is visibile only from inside its class.

x仅在其类内部可见。

We can set private constructors in the following way:

我们可以通过以下方式设置私有构造函数：

class PRIV private constructor(a: String) {
 ... 
}

By default classes have public constructors. Wherever the class goes the constructor follows.
We need to set the visibility modifier on the constructor in the definition itself.

默认情况下，类具有公共构造函数。 该类到哪里去，构造函数都将遵循。
我们需要在定义本身的构造函数中设置可见性修饰符。

Thus Kotlin uses the protected and internal modifiers differently from Java. Also Java’s default modifier is package-private which doesn’t exist in Kotlin, yet.

因此，Kotlin与Java不同地使用了protected和internal修饰符。 Java的默认修饰符是package-private，但Kotlin中尚不存在。

This brings an end to this quick tutorial on Visibility Modifiers in Kotlin.

这结束了有关Kotlin中的“可见性修改器”的快速教程。

翻译自: https://www.journaldev.com/20235/kotlin-visibility-modifiers-public-protected-internal-private

kotlin set 私有