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.