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.

Practice

1. Which visibility modifier in Kotlin allows a class member to be accessed from anywhere in the project?

easy

A. internal

B. private

C. public

D. protected

Solution

1. Step 1: Understand the meaning of public

   The public modifier means the member is visible everywhere in the project.

2. Step 2: Compare with other modifiers

   private restricts to class/file, internal restricts to module, protected restricts to class and subclasses only.

3. Final Answer:

   public -> Option C

4. Quick Check:

   Visible everywhere = public [OK]

Hint: Public means visible everywhere in the project [OK]

Common Mistakes:

• Confusing private with public visibility
• Thinking internal is visible everywhere
• Assuming protected is public

2. Which of the following is the correct syntax to declare a private property named count in a Kotlin class?

easy

A. private val count: Int = 0

B. val private count: Int = 0

C. val count private: Int = 0

D. private count val: Int = 0

Solution

1. Step 1: Recall Kotlin property declaration syntax

   Visibility modifier comes before val or var, so private val count: Int = 0 is correct.

2. Step 2: Check other options for syntax errors

   Options B, C, and D have incorrect order of keywords, which is invalid in Kotlin.

3. Final Answer:

   private val count: Int = 0 -> Option A

4. Quick Check:

   Modifier before val/var = correct syntax [OK]

Hint: Put visibility modifier before val or var [OK]

Common Mistakes:

• Placing private after val
• Mixing order of keywords
• Omitting colon before type

3. Consider the following Kotlin code:

open class Parent {
    protected val secret = "hidden"
}

class Child : Parent() {
    fun reveal() = secret
}

fun main() {
    val child = Child()
    println(child.reveal())
    // println(child.secret) // Line X
}

What will happen if the commented Line X is uncommented?

medium

A. Compilation error: Cannot access 'secret' outside the class or subclass

B. Prints 'hidden' without error

C. Runtime error: Illegal access

D. Compilation error: 'secret' is private

Solution

1. Step 1: Understand protected visibility

   protected members are accessible inside the class and its subclasses, but not outside.

2. Step 2: Analyze access in main function

   Accessing child.secret from outside the class hierarchy causes a compilation error.

3. Final Answer:

   Compilation error: Cannot access 'secret' outside the class or subclass -> Option A

4. Quick Check:

   Protected blocks external access [OK]

Hint: Protected is accessible only inside class and subclasses [OK]

Common Mistakes:

• Assuming protected is public
• Expecting runtime error instead of compile error
• Confusing private and protected

4. Given this Kotlin code snippet:

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

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

What is the error and how to fix it?

medium

A. No error; code runs and prints 'top secret'

B. Error: Missing constructor; fix by adding constructor

C. Error: Syntax error; fix by adding semicolon

D. Error: Cannot access private property outside class; fix by changing to public

Solution

1. Step 1: Identify visibility of secret

   The property secret is declared private, so it cannot be accessed outside the class.

2. Step 2: Understand the error cause and fix

   Trying to print ex.secret from outside causes a compilation error. Changing private to public or providing a public method to access it fixes the error.

3. Final Answer:

   Error: Cannot access private property outside class; fix by changing to public -> Option D

4. Quick Check:

   Private blocks external access [OK]

Hint: Private hides members outside class; use public or accessor [OK]

Common Mistakes:

• Thinking private allows outside access
• Confusing syntax errors with visibility errors
• Ignoring need for accessor methods

5. You have two Kotlin files in the same module: FileA.kt and FileB.kt. In FileA.kt, there is an internal function fun greet() = "Hello". Which of the following statements is true about calling greet() from FileB.kt?

hard

A. greet() cannot be called because internal means private

B. greet() can be called from FileB.kt because internal allows access within the same module

C. greet() cannot be called because internal restricts access to the same file only

D. greet() can be called only if FileB.kt inherits from FileA.kt

Solution

1. Step 1: Understand internal visibility

   internal means visible anywhere inside the same module, regardless of file.

2. Step 2: Apply to given files

   Since FileA.kt and FileB.kt are in the same module, greet() is accessible from FileB.kt.

3. Final Answer:

   greet() can be called from FileB.kt because internal allows access within the same module -> Option B

4. Quick Check:

   Internal = visible in module [OK]

Hint: Internal means visible anywhere in the same module [OK]

Common Mistakes:

• Confusing internal with private or file-private
• Thinking internal restricts to one file
• Assuming inheritance needed for internal access