Public vs SerializeField in Unity - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of accessing fields in Unity script

Consider this Unity C# script attached to a GameObject:

using UnityEngine;

public class TestScript : MonoBehaviour {
    public int publicValue = 5;
    [SerializeField] private int serializedValue = 10;

    void Start() {
        Debug.Log(publicValue);
        Debug.Log(serializedValue);
    }
}

What will be printed in the Unity Console when the game starts?

Unity

using UnityEngine;

public class TestScript : MonoBehaviour {
    public int publicValue = 5;
    [SerializeField] private int serializedValue = 10;

    void Start() {
        Debug.Log(publicValue);
        Debug.Log(serializedValue);
    }
}

A 5 and 10

B 0 and 0

C 5 and 0

D Compilation error because serializedValue is private

💡 Hint

Remember that SerializeField makes private fields visible in the Inspector and keeps their values.

The publicValue is public, so it can be accessed and printed directly. The serializedValue is private but marked with [SerializeField], so Unity serializes it and keeps its value. Both print their assigned values.

🧠 Conceptual

intermediate

Why use [SerializeField] on private fields?

In Unity, why would a developer use [SerializeField] on a private field instead of making the field public?

A To keep the field private but still editable in the Inspector

B To make the field accessible from other scripts

C To prevent the field from being saved with the scene

D To make the field read-only in the Inspector

💡 Hint

Think about encapsulation and editing values in the Unity Editor.

[SerializeField] allows private fields to be shown and edited in the Unity Inspector without exposing them publicly to other scripts. This helps keep code encapsulated while allowing designers to tweak values.

🔧 Debug

advanced

Why is the private field not visible in Inspector?

Look at this Unity script:

using UnityEngine;

public class Player : MonoBehaviour {
    private int health = 100;
    [SerializeField] private int mana;

    void Start() {
        Debug.Log(health);
        Debug.Log(mana);
    }
}

When attached to a GameObject, the mana field does not show in the Inspector. What is the most likely reason?

A The <code>mana</code> field is private and missing <code>[SerializeField]</code>

B The <code>mana</code> field is not initialized, so it won't appear

C The script file name does not match the class name

D The Unity Editor needs to be restarted to show private serialized fields

💡 Hint

Unity requires script file names to match class names exactly.

If the script file name does not match the class name, Unity will not compile the script properly, and serialized fields won't show in the Inspector. This is a common cause of private serialized fields not appearing.

📝 Syntax

advanced

Which code correctly serializes a private field?

Which of the following Unity C# code snippets correctly serializes a private integer field so it appears in the Inspector?

A private int score = 0; [SerializeField]

B public int score = 0; [SerializeField]

C private [SerializeField] int score = 0;

D [SerializeField] private int score = 0;

💡 Hint

Look at the correct order of attributes and access modifiers in C#.

The attribute [SerializeField] must come before the access modifier and type declaration. Option D is the correct syntax.

🚀 Application

expert

Choosing field visibility for game settings

You are designing a Unity game and want to store a player's maximum health. You want this value to be editable in the Inspector but not accessible or modifiable by other scripts directly. Which declaration is best?

A public int maxHealth = 100;

B [SerializeField] private int maxHealth = 100;

C private int maxHealth = 100;

D [SerializeField] public int maxHealth = 100;

💡 Hint

Think about encapsulation and Inspector visibility.

Option B keeps the field private so other scripts cannot access it directly, but [SerializeField] makes it editable in the Inspector. This balances encapsulation and usability.

Practice

1. What is the main difference between a public variable and a [SerializeField] private variable in Unity?

easy

A. public variables are accessible by other scripts and visible in the Inspector, while [SerializeField] private variables are only visible in the Inspector but not accessible by other scripts.

B. public variables are hidden in the Inspector, but [SerializeField] private variables are accessible by all scripts.

C. public variables cannot be edited in the Inspector, but [SerializeField] private variables can be edited by other scripts.

D. public variables are only accessible inside the class, while [SerializeField] private variables are accessible everywhere.

Solution

1. Step 1: Understand public variable behavior

   A public variable is accessible by all scripts and also visible in the Unity Inspector for editing.

2. Step 2: Understand [SerializeField] with private

   A [SerializeField] private variable is hidden from other scripts but still visible and editable in the Inspector.

3. Final Answer:

   public variables are accessible by other scripts and visible in the Inspector, while [SerializeField] private variables are only visible in the Inspector but not accessible by other scripts. -> Option A

4. Quick Check:

   Access and visibility differ between public and [SerializeField] private [OK]

Hint: Public = accessible everywhere; SerializeField private = Inspector only [OK]

Common Mistakes:

• Thinking SerializeField makes variable public
• Assuming public variables are hidden in Inspector
• Confusing private and public accessibility

2. Which of the following is the correct way to make a private variable visible in the Unity Inspector?

easy

A. private int score; [SerializeField]

B. [SerializeField] private int score;

C. public [SerializeField] int score;

D. int [SerializeField] private score;

Solution

1. Step 1: Recall correct attribute placement

   The [SerializeField] attribute must be placed before the variable declaration.

2. Step 2: Check variable declaration syntax

   The correct syntax is [SerializeField] private int score; to make a private variable visible in Inspector.

3. Final Answer:

   [SerializeField] private int score; -> Option B

4. Quick Check:

   Attribute before private variable declaration [OK]

Hint: Put [SerializeField] before private variable declaration [OK]

Common Mistakes:

• Placing [SerializeField] after variable
• Mixing public and [SerializeField] incorrectly
• Wrong order of keywords

3. Consider this Unity C# script snippet:

public class Player : MonoBehaviour {
    [SerializeField] private int health = 100;
    public int score = 0;

    void Start() {
        Debug.Log(health);
        Debug.Log(score);
    }
}

What will be printed in the Unity Console when the game starts?

medium

A. Error: health is private and cannot be accessed

B. 0 and 100

C. 100 and 0

D. Nothing will print

Solution

1. Step 1: Understand variable values and accessibility

   The private variable health is serialized and initialized to 100, so it is accessible inside the class and prints 100. The public variable score is initialized to 0 and prints 0.

2. Step 2: Check Debug.Log outputs

   Both Debug.Log(health) and Debug.Log(score) print their current values: 100 and 0 respectively.

3. Final Answer:

   100 and 0 -> Option C

4. Quick Check:

   Private serialized variables accessible inside class [OK]

Hint: Private serialized variables print normally inside class [OK]

Common Mistakes:

• Thinking private variables can't be accessed inside class
• Confusing initialization values
• Assuming serialization affects runtime access

4. You have this code in Unity:

public class Enemy : MonoBehaviour {
    [SerializeField] private int damage = 10;
}

But in the Inspector, the damage value stays at 0 even after you press Play. What is the likely problem?

medium

A. The damage variable is private and cannot be changed at runtime.

B. The [SerializeField] attribute is only for public variables.

C. You forgot to make damage public to change it in code.

D. The Inspector value overrides the code assignment, so damage stays at 0.

Solution

1. Step 1: Understand Inspector and code value interaction

   If a serialized field has a value set in the Inspector, Unity uses that value at runtime, overriding the code default initialization.

2. Step 2: Explain why damage stays 0

   The Inspector value for damage is 0, so even though code initializes it to 10, the Inspector value overrides it.

3. Final Answer:

   The Inspector value overrides the code assignment, so damage stays at 0. -> Option D

4. Quick Check:

   Inspector values override code assignments at runtime [OK]

Hint: Inspector values override code assignments on serialized fields [OK]

Common Mistakes:

• Assuming private variables can't be changed in code
• Thinking [SerializeField] only works on public variables
• Ignoring Inspector value overrides

5. You want to keep a variable speed editable in the Unity Inspector but prevent other scripts from modifying it directly. Which is the best way to declare it?

hard

A. [SerializeField] private float speed;

B. private float speed; // no attribute

C. public float speed;

D. public float speed { get; private set; }

Solution

1. Step 1: Identify requirement for Inspector editing and script protection

   The variable must be editable in Inspector but not accessible publicly by other scripts.

2. Step 2: Evaluate options

   public float speed; makes it public, so other scripts can modify it. private float speed; // no attribute hides it from Inspector. [SerializeField] private float speed; uses [SerializeField] with private, making it editable in Inspector but hidden from other scripts. public float speed { get; private set; } uses a public property with private setter, which is not visible in Inspector by default.

3. Final Answer:

   [SerializeField] private float speed; -> Option A

4. Quick Check:

   SerializeField + private = Inspector editable, script protected [OK]

Hint: Use [SerializeField] private for Inspector edit, no public access [OK]

Common Mistakes:

• Making variable public and exposing it
• Using property without SerializeField
• Forgetting to add [SerializeField]