> ## 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 Function
A `private` function in Kotlin is a function restricted by the `private` visibility modifier, confining its accessibility strictly to the lexical scope of its declaration. The exact visibility bounds depend on whether the function is declared as a member of a class/interface or at the top level of a file.
## Class and Interface Members
When declared inside a class or interface, a `private` function is visible only within that specific class or interface. It is strictly hidden from external callers, instantiated objects, and subclasses.
```kotlin theme={"dark"}
open class Component {
fun execute() {
// Permitted: Accessing within the same class scope
initialize()
}
private fun initialize() {
// Function body
}
}
class SubComponent : Component() {
fun run() {
// Compilation Error: Cannot access 'initialize': it is private in 'Component'
// initialize()
}
}
fun main() {
val comp = Component()
// Compilation Error: Cannot access 'initialize': it is private in 'Component'
// comp.initialize()
}
```
## Top-Level Declarations
Kotlin allows functions to be declared at the top level of a file, outside of any class. When a top-level function is marked `private`, its visibility is restricted to the specific `.kt` file in which it is defined. It cannot be imported or invoked by code residing in other files, even if they share the same package.
```kotlin theme={"dark"}
// File: MathOperations.kt
package com.example.math
private fun computeBase(value: Int): Int {
return value * 2
}
fun calculateTotal(value: Int): Int {
// Permitted: Accessing within the same file
return computeBase(value) + 10
}
```
```kotlin theme={"dark"}
// File: Calculator.kt
package com.example.math
fun performCalculation() {
// Compilation Error: Cannot access 'computeBase': it is private in file
// computeBase(5)
}
```
## Companion Object Visibility
If a `private` function is declared inside a `companion object`, it is accessible to the companion object itself and the enclosing class. However, it remains hidden from external scopes.
```kotlin theme={"dark"}
class SessionManager {
fun start() {
// Permitted: Enclosing class can access private members of its companion object
generateSessionId()
}
companion object {
private fun generateSessionId(): String {
return "ID-12345"
}
}
}
```
Tired of Poor Kotlin Skills? Fix That With Deep Grasping!
Learn More
