Skip to main content

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.

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. 
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. 
// 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
}

// 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. 
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"
        }
    }
}
Master Kotlin with Deep Grasping Methodology!Learn More