Kotlin - Visibility Modifiers

Visibility Modifiers in Kotlin

Kotlin, a statically-typed programming language developed by JetBrains, provides a concise and expressive syntax. One of the key components of object-oriented programming is access control. Access control mechanisms help ensure encapsulation and data hiding. Kotlin offers a set of visibility modifiers that determine the accessibility of classes, objects, interfaces, constructors, functions, properties, and their setters. Understanding Kotlin visibility modifiers is essential for designing secure, modular, and maintainable applications.

Overview of Visibility Modifiers

Kotlin provides four visibility modifiers:

• public
• internal
• protected
• private

Each of these modifiers defines a different level of access control. By default, if no modifier is specified, Kotlin uses public as the default visibility.

1. Public Modifier

Definition

The public modifier means that the declaration is visible everywhere. This is the least restrictive access level in Kotlin.

Usage

public class PublicClass {
    public fun publicFunction() {
        println("This is a public function")
    }
}

In the above code, both the class and function are accessible from anywhere in the project or from other modules that depend on it.

Key Points

• Classes and their members are accessible everywhere.
• This is the default visibility modifier in Kotlin.

2. Internal Modifier

Definition

The internal modifier restricts the visibility to the same module. A module in Kotlin is a set of Kotlin files compiled together. For example, a Maven or Gradle project is considered a module.

Usage

internal class InternalClass {
    internal fun internalFunction() {
        println("This is an internal function")
    }
}

This class and function are accessible anywhere within the same module but are not accessible from another module.

Key Points

• Useful for hiding implementation details within a module.
• More restrictive than public but less restrictive than private.
• Commonly used in libraries to expose APIs internally but hide from external usage.

3. Protected Modifier

Definition

The protected modifier allows visibility within the class and its subclasses. It is not applicable at the top level (i.e., outside a class).

Usage

open class Base {
    protected fun protectedFunction() {
        println("This is a protected function")
    }
}

class Derived : Base() {
    fun accessProtected() {
        protectedFunction()
    }
}

Here, protectedFunction() is accessible from the subclass but not from outside the class hierarchy.

Key Points

• Useful for inheritance-based designs.
• Cannot be used for top-level declarations.
• Provides controlled access to base class members.

4. Private Modifier

Definition

The private modifier restricts visibility to the declaration's scope. The behavior of private differs slightly depending on where it is used.

Usage in Class

class MyClass {
    private val secret = "Top Secret"

    private fun privateFunction() {
        println("Accessing private function")
    }
}

The property and function are accessible only within MyClass.

Usage in File

private fun fileLevelFunction() {
    println("This function is visible only in this file")
}

This function is visible only within the same Kotlin file.

Key Points

• Provides strict encapsulation.
• Can be used to declare file-private functions or variables.
• Essential for hiding implementation details.

Visibility Modifiers on Constructors

Primary Constructors

You can specify a visibility modifier on a primary constructor by prefixing the constructor keyword.

class Secret private constructor() {
    // Instance cannot be created outside this class
}

This pattern is useful in singleton or factory patterns where instance creation needs to be controlled.

Visibility Modifiers in Interfaces

Behavior

In Kotlin, all members of an interface are implicitly public and cannot have other visibility modifiers. This includes properties and functions.

interface MyInterface {
    fun doSomething() // implicitly public
}

Visibility Modifiers with Getters and Setters

In Kotlin, you can specify different visibility modifiers for property accessors.

class Account {
    var balance: Int = 0
        private set // The setter is private, getter remains public
}

In this example, other classes can read the balance, but they cannot modify it directly because the setter is private.

Top-Level Declarations

In Kotlin, functions, properties, and classes can be declared at the top level (outside any class). The visibility modifiers applicable are:

• public – accessible everywhere
• internal – accessible within the module
• private – accessible within the same file

internal val MAX_USERS = 100
private fun logMessage(msg: String) {
    println(msg)
}

Nested and Inner Classes

Visibility modifiers are also applicable to nested and inner classes.

class Outer {
    private class Inner {
        fun sayHello() = println("Hello from Inner")
    }

    fun accessInner() {
        val inner = Inner()
        inner.sayHello()
    }
}

Here, the class Inner is accessible only within the Outer class.

Default Visibility

If you do not explicitly specify a visibility modifier, Kotlin uses public by default.

class MyClass {
    fun defaultFunction() {
        println("This is public by default")
    }
}

defaultFunction() is public and can be accessed from anywhere.

Comparison Table

Best Practices

• Use private to enforce strong encapsulation.
• Use internal to limit access to your module, especially for library internals.
• Use protected only when designing for inheritance.
• Avoid unnecessary public visibility to reduce the surface area for bugs or misuse.

Kotlin’s visibility modifiers—public, internal, protected, and private—are powerful tools for defining the accessibility and encapsulation of code. They help developers build robust and modular applications by enforcing clear boundaries and reducing coupling between components. By understanding and properly applying visibility modifiers, you can write more secure, maintainable, and scalable Kotlin code.