PHP new self vs new static: Understanding Late Static Binding

By the end of this page, you will understand how self and static behave differently in PHP class methods, especially when inheritance is involved. You will see why new self() creates an instance of the class where the code is written, while new static() creates an instance of the class that was actually called. This distinction is essential when working with parent and child classes, factory methods, and libraries that rely on extensibility.

In PHP, self and static can both refer to classes, but they are not resolved the same way.

• self refers to the class where the method is defined.
• static refers to the class used at runtime to call the method.

This difference matters in inherited code.

new self()

When you write:

return new self($options);

PHP creates an object of the class that contains that code. It does not change based on which subclass called the method.

new static()

When you write:

return new static($options);

PHP uses late static binding. That means PHP waits until runtime and creates an object of the actual called class.

Why this matters

If a base class contains a factory method and a child class inherits it:

Think of self and static like two different ways of reading a label.

• self says: "Use the class name printed in this file."
• static says: "Use the class name of whoever actually called me."

Imagine a blueprint for a vehicle factory:

• With new self(), the blueprint always says: "Build a Vehicle."
• With new static(), the blueprint says: "Build whatever type of vehicle requested this method, such as Car or Truck."

So if Car inherits a method from Vehicle:

• new self() still builds a Vehicle
• new static() builds a Car

That is the key idea behind late static binding.

Here is the basic syntax:

self::methodName();
static::methodName();

new self();
new static();

Example 1: new self()

<?php

class Base {
    public static function make() {
        return new self();
    }
}

class Child extends Base {}

$object = Child::make();
echo get_class($object);

Output:

Base

Even though Child::make() was called, the method is defined in , so creates a object.

Consider this example:

<?php

class Animal {
    public static function build() {
        return new static();
    }
}

class Dog extends Animal {}

$pet = Dog::build();
echo get_class($pet);

Step by step

1. PHP defines the Animal class.

2. PHP defines the Dog class, which extends Animal.

3. The code calls:

   Dog::build();
   

4. PHP looks for build() in Dog.

This difference appears in many real applications.

1. Factory methods

A parent class may provide a helper like create() or make():

class Response {
    public static function make($data) {
        return new static($data);
    }
}

Subclasses such as JsonResponse or XmlResponse can inherit the method and still get the correct type.

2. ORM and Active Record models

Database libraries often use parent model classes:

$user = User::create($row);

If the base model uses new static(), the returned object is a User, not just a generic Model.

In real codebases, developers choose between self and static based on whether inheritance should affect the result.

Use self when the method is intentionally fixed to the base class

class Token {
    public static function internalFactory() {
        return new self();
    }
}

This is appropriate when you do not want subclasses to change the returned type.

Use static when the class is designed for extension

class Collection {
    public static function fromArray($items) {
        return new static($items);
    }
}

This is common in libraries that expect child classes.

Common patterns

1. Assuming self and static are interchangeable

They are not the same when inheritance is involved.

Broken expectation:

<?php

class ParentClass {
    public static function make() {
        return new self();
    }
}

class ChildClass extends ParentClass {}

$obj = ChildClass::make();
echo get_class($obj); // ParentClass, not ChildClass

2. Replacing new static() with new self() during migration without checking subclass usage

This may silently change returned object types.

How to avoid it:

• inspect whether classes are extended
• inspect whether factory methods are inherited
• test returned object types with or

new self() vs new static()

• new self() = create an instance of the class where the code is written
• new static() = create an instance of the class used to call the method
• self does not support late static binding
• static does support late static binding
• new static() requires PHP 5.3+
• Replacing new static() with new self() can change behavior in subclasses

Quick example

class Base {
    public static function a() { return new self(); }
    public static function b() { return new static(); }
}

class Child extends Base {}

(::()); 
(::()); 

Does new self() always return the parent class?

It returns the class where that code is defined. If the method is defined in a parent class, then yes, it returns the parent class.

Does new static() work in PHP 5.2?

No. Late static binding was introduced in PHP 5.3.

Can I safely replace new static() with new self()?

Only if inheritance does not matter for that code path. Otherwise, the returned object type may change.

Why do frameworks and libraries often use static?

Because they are designed to be extended, and they want inherited methods to return subclass instances.

What is late static binding in simple terms?

It means PHP decides the class at runtime based on who made the call, rather than the class where the code was originally written.

Is the same idea true for self::method() and static::method()?

Yes. static::method() uses late static binding, while self::method() refers to the defining class.

What should I do in PHP 5.2 if I need subclass-aware factories?

You may need manual workarounds, such as overriding the method in each subclass or passing class names explicitly.

• Inheritance — self and static behave differently when child classes extend parent classes.
• Late static binding — this is the exact feature behind static runtime resolution.
• Factory methods — new static() is commonly used in factory and named-constructor patterns.
• Static methods — understanding Class::method() helps explain how self:: and static:: differ.
• Constructors in PHP — constructor arguments must still match when using new self() or new static().
• Object-oriented programming in PHP — this topic sits inside basic PHP OOP design.
• Method overriding — child classes may override methods, and static:: interacts with that more dynamically.