> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Kotlin Private Property
A private property in Kotlin is a class member or top-level variable declared with the `private` visibility modifier, strictly confining its lexical scope and accessibility to the exact enclosing declaration.
## Syntax
The `private` modifier precedes the `val` (read-only) or `var` (mutable) keyword:
```kotlin theme={"dark"}
private val immutableData: String = "Static"
private var mutableState: Int = 0
```
## Scoping Rules
The exact boundary of a private property depends on its declaration context:
* **Class/Interface Level:** When declared inside a class or interface, the property is visible only within the `{}` block of that specific class. It is strictly invisible to external classes, instantiating code, and subclasses (unlike the `protected` modifier).
* **Top-Level (File Level):** When declared outside of any class, the property is visible to all functions, classes, and objects defined within that specific `.kt` file, but invisible to the rest of the module or package.
## JVM Compilation and Backing Fields
Under the hood, when compiling to the JVM, Kotlin handles private properties differently than public ones:
1. **Field Generation:** It generates a `private` backing field.
2. **Accessor Generation:** Unlike public properties, the Kotlin compiler does *not* generate public `get()` and `set()` methods.
3. **Direct Access:** Accessing the private property from within its allowed scope is typically optimized by the compiler into direct field access at the bytecode level, bypassing method invocation overhead unless custom accessors are defined.
## Custom Accessors
Private properties fully support custom getters and setters. The accessors implicitly inherit the `private` visibility of the property itself.
```kotlin theme={"dark"}
class DataContainer {
private var internalCounter: Int = 0
get() = field + 1
set(value) {
field = if (value > 0) value else 0
}
}
```
## Companion Object Interaction
Kotlin enforces a specific visibility relationship between a class and its companion object regarding private members:
* A class can access the private properties of its `companion object`.
* A `companion object` can access the private properties of its enclosing class instances.
```kotlin theme={"dark"}
class OuterClass {
private val instanceSecret = "Instance Level"
companion object {
private val staticSecret = "Companion Level"
}
fun readCompanion() {
println(staticSecret) // Valid access
}
}
```
Tired of Poor Kotlin Skills? Fix That With Deep Grasping!
Learn More
