Visibility modifiers (public, private, internal, protected) in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code with visibility modifiers?

Consider the following Kotlin code snippet. What will be printed when Main().test() is called?

Kotlin

open class Main {
    private val secret = "hidden"
    internal val internalInfo = "inside module"
    protected val protectedInfo = "protected data"
    val publicInfo = "visible everywhere"

    fun test() {
        println(secret)
        println(internalInfo)
        println(publicInfo)
    }
}

fun main() {
    Main().test()
}

A

hidden
inside module
protected data

B

hidden
inside module
visible everywhere

C

visible everywhere
inside module
hidden

D Error: Cannot access protectedInfo

💡 Hint

Remember that private members are accessible inside the same class, internal inside the same module, and protected only in subclasses.

The test() function is inside the Main class, so it can access private, internal, and public members. The protected member is not accessed here. So the output prints secret, internalInfo, and publicInfo values.

❓ Predict Output

intermediate

What error occurs when accessing a private property from outside the class?

What happens if you try to access a private property from outside its class in Kotlin?

Kotlin

class Box {
    private val secret = "top secret"
}

fun main() {
    val box = Box()
    println(box.secret)
}

A Compilation error: Cannot access 'secret': it is private in 'Box'

B Prints: top secret

C Runtime error: IllegalAccessException

D Prints: null

💡 Hint

Think about what private means in Kotlin.

In Kotlin, private means the property is only accessible inside the class it is declared in. Trying to access it outside causes a compile-time error.

🔧 Debug

advanced

Why does this Kotlin code fail to compile due to visibility?

Examine the code below. Why does it fail to compile?

Kotlin

open class Parent {
    protected val data = "parent data"
}

class Child : Parent() {
    fun printData() {
        println(data)
    }
}

fun main() {
    val child = Child()
    println(child.data)
}

A Runtime error: IllegalAccessException

B Prints: parent data parent data

C Compilation error: 'data' is private in 'Parent'

D Compilation error: Cannot access 'data': it is protected in 'Parent'

💡 Hint

Remember where protected members can be accessed from.

The data property is protected, so it can be accessed inside Child class methods, but not from outside. The line println(child.data) is outside the class, causing a compile error.

❓ Predict Output

advanced

What is the output when accessing internal members from another module?

Assume ModuleA defines this class:

class Example {
    internal val info = "module info"
    val publicInfo = "public info"
}

And ModuleB tries to run:

fun main() {
    val ex = Example()
    println(ex.info)
    println(ex.publicInfo)
}

What happens?

A Compilation error: Cannot access 'info': it is internal in 'Example'

B

Prints:
module info
public info

C Runtime error: IllegalAccessException

D

Prints:
public info
module info

💡 Hint

Think about what internal means across modules.

internal means visible only inside the same module. Accessing info from another module causes a compile error. publicInfo is accessible everywhere.

🧠 Conceptual

expert

Which Kotlin visibility modifier allows access only within the same class and its subclasses?

Choose the visibility modifier that fits this description:

• Accessible inside the class and subclasses
• Not accessible from unrelated classes in the same module

A private

B internal

C protected

D public

💡 Hint

Think about which modifier restricts access to subclasses only.

protected allows access inside the class and subclasses regardless of module. internal allows access anywhere in the module but not outside. private restricts to the class only. public is everywhere.