Static properties and methods in PHP - Step-by-Step Execution

Concept Flow - Static properties and methods

Class Definition

↓

Define static property

↓

Define static method

↓

Access static property/method

↓

Use without creating object

↓

Static property/method used directly

↓

End

Shows how static properties and methods are defined in a class and accessed directly without creating an object.

Execution Sample

PHP

<?php
class Counter {
  public static $count = 0;
  public static function increment() {
    self::$count++;
  }
}
Counter::increment();
echo Counter::$count;
?>

This code defines a class with a static property and method, increments the static count, and prints it.

Execution Table

Step	Action	Static Property Value	Output
1	Class Counter defined with static property count=0	0
2	Call Counter::increment()	1
3	Echo Counter::$count	1	1
4	End of script	1

💡 Script ends after printing static property value 1

Variable Tracker

Variable	Start	After Step 2	Final
Counter::$count	0	1	1

Key Moments - 2 Insights

Why can we access Counter::$count without creating an object?

Because $count is a static property, it belongs to the class itself, not to any object instance. See execution_table step 3.

Why do we use self::$count inside the static method?

Inside the class, self:: refers to the class itself, so self::$count accesses the static property. See execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of Counter::$count after step 2?

A 1

B 0

C 2

D Undefined

💡 Hint

Check the 'Static Property Value' column at step 2 in the execution_table.

At which step is the static method increment() called?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' column in the execution_table for the method call.

If we remove 'static' from the property declaration, what happens when accessing Counter::$count?

A It works the same

B It causes an error

C It prints 0 always

D It prints null

💡 Hint

Static properties must be declared static to be accessed with :: syntax, see variable_tracker and execution_table.

Concept Snapshot

Static properties and methods belong to the class, not objects.
Use 'static' keyword to declare them.
Access with ClassName::$property or ClassName::method().
Inside class, use self::$property or self::method().
No need to create an object to use static members.

Full Transcript

This example shows how to define and use static properties and methods in PHP. The class Counter has a static property $count initialized to 0. The static method increment() increases $count by 1 using self::$count++. We call Counter::increment() without creating an object. Then we print Counter::$count which outputs 1. Static members belong to the class itself, so they can be accessed directly using the class name and :: operator. Inside the class, self:: is used to refer to static members. This allows shared data or behavior across all uses of the class without needing instances.

Practice

1. Which statement about static properties in PHP is true?
class Example { public static $count = 0; }

easy

A. Static properties belong to the class itself, not to any object instance.

B. Static properties can only be accessed through object instances.

C. Static properties cannot hold values.

D. Static properties are private by default.

Solution

1. Step 1: Understand static property ownership

   Static properties belong to the class, not to individual objects.

2. Step 2: Check access rules

   Static properties are accessed using the class name, not object instances.

3. Final Answer:

   Static properties belong to the class itself, not to any object instance. -> Option A

4. Quick Check:

   Static property = class-level data [OK]

Hint: Static means class-level, not per object [OK]

Common Mistakes:

• Thinking static properties belong to objects
• Trying to access static properties via objects
• Assuming static properties can't hold values

2. Which of the following is the correct syntax to call a static method show() of class Test?

easy

A. $obj->show();

B. $obj::show();

C. Test->show();

D. Test::show();

Solution

1. Step 1: Recall static method call syntax

   Static methods are called using the class name and double colon (::).

2. Step 2: Check each option

   Test::show(); uses Test::show(); which is correct syntax.

3. Final Answer:

   Test::show(); -> Option D

4. Quick Check:

   Static method call = ClassName::method() [OK]

Hint: Use ClassName::method() to call static methods [OK]

Common Mistakes:

• Using object arrow (->) to call static methods
• Using object variable with :: operator incorrectly
• Using class arrow (->) which is invalid

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

class Counter {
    public static $count = 0;
    public static function increment() {
        self::$count++;
    }
}
Counter::increment();
Counter::increment();
echo Counter::$count;

medium

A. 1

B. 2

C. 0

D. Error

Solution

1. Step 1: Understand static property and method behavior

   Static property $count starts at 0 and is shared by the class.

2. Step 2: Trace method calls

   Each call to increment() increases $count by 1. Two calls increase it to 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   2 increments = 2 count [OK]

Hint: Static property keeps value across calls [OK]

Common Mistakes:

• Thinking static resets per call
• Confusing self:: with $this->
• Expecting error due to static usage

4. Identify the error in this PHP code snippet:

class Sample {
    public static $value = 10;
    public function show() {
        echo self->$value;
    }
}
$object = new Sample();
$object->show();

medium

A. Cannot use echo inside class methods.

B. Static property cannot be accessed inside non-static methods.

C. Using self::$value instead of self->$value inside the method.

D. Missing static keyword before method declaration.

Solution

1. Step 1: Check static property access syntax

   Static properties must be accessed with self::$propertyName, not self->$propertyName.

2. Step 2: Verify method and property usage

   The method is non-static but can access static properties using self:: syntax.

3. Final Answer:

   Using self::$value instead of self->$value inside the method. -> Option C

4. Quick Check:

   Static property access = self::$property [OK]

Hint: Use :: for static properties, not -> or $ [OK]

Common Mistakes:

• Using $ before property name with self::
• Trying to access static property with $this->
• Confusing static and non-static method rules

5. You want to count how many objects of class User have been created using a static property. Which code correctly implements this?

class User {
    public static $count = 0;
    public function __construct() {
        // What goes here?
    }
}

hard

A. self::$count++;

B. $this->count++;

C. User->count++;

D. static->count++;

Solution

1. Step 1: Understand static property increment in constructor

   Each time an object is created, the constructor runs and should increase the static count.

2. Step 2: Use correct syntax to increment static property

   Use self::$count++; inside the constructor to increment the static property.

3. Final Answer:

   self::$count++; -> Option A

4. Quick Check:

   Increment static with self::$property++ [OK]

Hint: Use self::$property to access static inside class [OK]

Common Mistakes:

• Using $this->count++ which accesses instance property
• Using arrow (->) with class name or static keyword
• Trying to increment static property without self::