Readonly classes in PHP - Step-by-Step Execution

Concept Flow - Readonly classes

Define readonly class

↓

Create instance with properties

↓

Try to modify property?

Yes→Error: Cannot modify readonly property

No↓

Use properties as read-only

↓

End

This flow shows how a readonly class is defined, instantiated, and how its properties cannot be changed after creation.

Execution Sample

PHP

<?php
readonly class User {
  public string $name;
  public function __construct(string $name) {
    $this->name = $name;
  }
}
$user = new User("Alice");
$user->name = "Bob"; // Error
?>

Defines a readonly class User with a name property, creates an instance, then tries to change the name property which causes an error.

Execution Table

Step	Action	Property 'name' Value	Result/Output
1	Define readonly class User	N/A	Class User is readonly
2	Create User instance with name='Alice'	name = 'Alice'	Instance created successfully
3	Attempt to assign name='Bob'	name = 'Alice'	Error: Cannot modify readonly property User::$name
4	End	name = 'Alice'	Execution stops due to error

💡 Execution stops at step 3 because readonly property cannot be modified after initialization

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
$user->name	undefined	Alice	Alice	Alice

Key Moments - 2 Insights

Why can't we change the property 'name' after creating the User object?

Because the class is declared as readonly, its properties can only be set once during construction. Step 3 in the execution_table shows the error when trying to modify 'name'.

Is it allowed to set the property 'name' inside the constructor?

Yes, setting properties inside the constructor is allowed and is how readonly properties get their initial value, as shown in step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of $user->name after step 3?

A "Alice"

B "Bob"

C undefined

D null

💡 Hint

Check the 'Property 'name' Value' column at step 3 in the execution_table.

At which step does the program stop due to an error?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Result/Output' column for the error message in the execution_table.

If the class was not declared readonly, what would happen at step 3?

A Error would still occur

B The program would crash

C The property 'name' would change to 'Bob'

D The property would become null

💡 Hint

Consider how normal class properties behave when assigned after construction.

Concept Snapshot

readonly class ClassName {
  public type $property;
  public function __construct(type $property) {
    $this->property = $property; // Allowed
  }
}
Properties cannot be changed after construction; attempts cause errors.

Full Transcript

This example shows how to define a readonly class in PHP. The class User has a readonly property 'name' set in the constructor. When we create a User object with name 'Alice', it works fine. But if we try to change 'name' later to 'Bob', PHP throws an error because readonly properties cannot be modified after initialization. The execution table traces these steps clearly, showing the error at step 3. The variable tracker confirms the property value stays 'Alice'. This helps beginners understand readonly classes by watching the code run step-by-step.

Practice

1. What does a readonly class in PHP ensure about its properties?

easy

A. Properties are static and shared between all instances.

B. Properties can be changed anytime after creation.

C. All properties cannot be changed after the object is created.

D. Properties are private and cannot be accessed outside the class.

Solution

1. Step 1: Understand the meaning of readonly class

   A readonly class means all its properties are readonly by default, so they cannot be changed after the object is created.

2. Step 2: Compare options with this definition

   Only the option stating "All properties cannot be changed after the object is created." correctly states that properties cannot be changed after creation.

3. Final Answer:

   All properties cannot be changed after the object is created. -> Option C

4. Quick Check:

   Readonly class = immutable properties [OK]

Hint: Readonly means no property changes after creation [OK]

Common Mistakes:

• Thinking readonly means private or static
• Assuming properties can be changed anytime
• Confusing readonly with access modifiers

2. Which of the following is the correct syntax to declare a readonly class in PHP?

easy

A. readonly class User { public readonly string $name; }

B. class readonly User {}

C. class User readonly {}

D. readonly class User {}

Solution

1. Step 1: Recall PHP readonly class syntax

   In PHP, the keyword readonly comes before class to declare a readonly class.

2. Step 2: Check each option

   readonly class User {} correctly uses readonly class User {}. class readonly User {} reverses the order, class User readonly {} places readonly incorrectly, and readonly class User { public readonly string $name; } is invalid syntax.

3. Final Answer:

   readonly class User {} -> Option D

4. Quick Check:

   Keyword readonly before class [OK]

Hint: Put readonly before class keyword [OK]

Common Mistakes:

• Placing readonly after class name
• Using readonly as a property only
• Mixing readonly with access modifiers

3. What will be the output of this PHP code?

readonly class Point {
    public int $x;
    public int $y;
    public function __construct(int $x, int $y) {
        $this->x = $x;
        $this->y = $y;
    }
}

$p = new Point(5, 10);
echo $p->x . ', ' . $p->y;

medium

A. 5, 10

B. Error: Cannot modify readonly property

C. 0, 0

D. 5 10

Solution

1. Step 1: Understand readonly class property initialization

   Readonly properties can be set inside the constructor. Here, $x and $y are set to 5 and 10 respectively.

2. Step 2: Check output of echo statement

   The echo prints 5, 10 as expected because the properties were initialized correctly and not modified later.

3. Final Answer:

   5, 10 -> Option A

4. Quick Check:

   Readonly properties set in constructor output values [OK]

Hint: Readonly properties can be set in constructor only [OK]

Common Mistakes:

• Thinking readonly properties cannot be set at all
• Expecting error on property access
• Confusing output format with space instead of comma

4. Identify the error in this PHP code using a readonly class:

readonly class User {
    public string $name;
    public function __construct(string $name) {
        $this->name = $name;
    }
}

$user = new User('Alice');
$user->name = 'Bob';

medium

A. Cannot assign to readonly property after construction

B. Missing readonly keyword before property declaration

C. Constructor must be static in readonly class

D. No error, code runs fine

Solution

1. Step 1: Understand readonly property behavior

   In a readonly class, properties can only be assigned once during construction. Changing them later causes an error.

2. Step 2: Analyze the code

   The code tries to change $user->name after construction, which is not allowed and causes an error.

3. Final Answer:

   Cannot assign to readonly property after construction -> Option A

4. Quick Check:

   Readonly properties are immutable after construction [OK]

Hint: Readonly properties cannot be changed after constructor [OK]

Common Mistakes:

• Thinking readonly properties can be changed anytime
• Confusing readonly class with readonly property keyword
• Ignoring error on property reassignment

5. Given this readonly class, which code snippet correctly creates an immutable user and tries to update the name without error?

readonly class User {
    public string $name;
    public function __construct(string $name) {
        $this->name = $name;
    }
}

Choose the correct approach:

hard

A. $user = new User('Alice');
$user->name = 'Bob';

B. $user = new User('Alice');
$newUser = new User('Bob');

C. $user = new User('Alice');
$user->name = strtoupper($user->name);

D. $user = new User('Alice');
unset($user->name);

Solution

1. Step 1: Understand immutability of readonly classes

   Readonly class properties cannot be changed after construction, so to 'change' data, create a new object with new values.

2. Step 2: Evaluate each option

   $user = new User('Alice'); $user->name = 'Bob'; tries to change property directly - error. $user = new User('Alice'); $user->name = strtoupper($user->name); tries to modify property - error. $user = new User('Alice'); $newUser = new User('Bob'); creates a new User object with new name - correct. $user = new User('Alice'); unset($user->name); tries to unset property - invalid.

3. Final Answer:

   Create a new User object with updated name -> Option B

4. Quick Check:

   Immutable means create new object for changes [OK]

Hint: Change readonly data by creating new object [OK]

Common Mistakes:

• Trying to modify readonly property directly
• Using unset on readonly properties
• Assuming readonly means properties can be changed