Visibility modifiers (public, private, internal, protected) in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a public function named greet.

Kotlin

[1] fun greet() {
    println("Hello!")
}

Drag options to blanks, or click blank then click option'

Aprivate

Bpublic

Cinternal

Dprotected

Attempts:

3 left

💡 Hint

Common Mistakes

Using private or protected which restrict access.

Using internal which limits visibility to the module.

In Kotlin, functions are public by default, but explicitly using public makes it clear the function is accessible everywhere.

2fill in blank

medium

Complete the code to declare a private variable named secret.

Kotlin

class Vault {
    [1] val secret = "1234"
}

Drag options to blanks, or click blank then click option'

Aprivate

Bprotected

Cpublic

Dinternal

Attempts:

3 left

💡 Hint

Common Mistakes

Using public which exposes the variable everywhere.

Using internal which allows access within the module.

The private modifier restricts access to the variable within the class only.

3fill in blank

hard

Fix the error in the code by choosing the correct visibility modifier for the function.

Kotlin

open class Base {
    [1] fun show() {
        println("Base show")
    }
}

Drag options to blanks, or click blank then click option'

Aprivate

Binternal

Cprotected

Dpublic

Attempts:

3 left

💡 Hint

Common Mistakes

Using private which hides the function from subclasses.

Using internal which exposes it to the whole module.

The protected modifier allows the function to be visible in subclasses but not outside the class hierarchy.

4fill in blank

hard

Fill both blanks to declare an internal class with a private property.

Kotlin

[1] class Data {
    [2] val data = "hidden"
}

Drag options to blanks, or click blank then click option'

Ainternal

Bpublic

Cprivate

Dprotected

Attempts:

3 left

💡 Hint

Common Mistakes

Using public for the class which exposes it everywhere.

Using protected for the property, which allows access from subclasses.

The class is internal, so it is visible within the module. The property is private, so it is only accessible inside the class.

5fill in blank

hard

Fill all three blanks to declare a protected open class with an internal function and a public property.

Kotlin

class Outer {
    [1] open class MyClass {
        [2] fun internalFunc() {
            println("Internal function")
        }
        [3] val name = "Kotlin"
    }
}

Drag options to blanks, or click blank then click option'

Aprotected

Binternal

Cpublic

Dprivate

Attempts:

3 left

💡 Hint

Common Mistakes

Using private for the class, which hides it from subclasses.

Using public for the function which exposes it everywhere.

Using internal for the property which limits visibility.

The class is protected and open, so it can be subclassed and is visible to subclasses. The function is internal, visible within the module. The property is public, visible 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