What Is The Difference Between New Self And New Static in PHP?

New Self Explained

'New self' in PHP creates a new instance of the class where it's defined. It refers to the current class, regardless of where it's called from in the inheritance chain. 'New self' will always create an object of the class it's written in, even if called from a child class.

Here's an example of 'New self' usage:

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

class ChildClass extends ParentClass {}

$instance = ChildClass::getInstance();
echo get_class($instance); // Outputs: ParentClass

In this example, even though we call getInstance() on ChildClass, it returns an instance of ParentClass because 'new self' is defined in ParentClass.

New Static Explained

'New static' implements late static binding in PHP. It creates a new instance of the class that the method is called on, not necessarily the class where it's defined. This allows for more flexible object creation in inheritance scenarios.

Here's an example of 'New static' usage:

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

class ChildClass extends ParentClass {}

$instance = ChildClass::getInstance();
echo get_class($instance); // Outputs: ChildClass

In this case, calling getInstance() on ChildClass returns an instance of ChildClass, not ParentClass. This is because 'new static' refers to the class that called the method, not the class where the method is defined.

abstract class Animal {
    abstract public function speak();

    public static function create() {
        return new static();
    }
}

class Dog extends Animal {
    public function speak() {
        return "Woof!";
    }
}

class Cat extends Animal {
    public function speak() {
        return "Meow!";
    }
}

$dog = Dog::create();
echo $dog->speak(); // Outputs: Woof!

$cat = Cat::create();
echo $cat->speak(); // Outputs: Meow!

Scope of Reference

'New self' and 'new static' differ in their scope within a class hierarchy. 'New self' refers to the defining class, regardless of where it's called from. It creates an instance of the class where the method is defined. 'New static' refers to the called class, which can be a subclass of the defining class. It creates an instance of the class that called the method.

Example:

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

    public static function getStaticInstance() {
        return new static();
    }
}

class ChildClass extends ParentClass {}

$selfInstance = ChildClass::getSelfInstance();
$staticInstance = ChildClass::getStaticInstance();

echo get_class($selfInstance);  // Outputs: ParentClass
echo get_class($staticInstance);  // Outputs: ChildClass

In this code, 'new self' in getSelfInstance() creates a ParentClass instance, while 'new static' in getStaticInstance() creates a ChildClass instance when called on ChildClass.

Inheritance Behavior

The inheritance behavior of 'new self' and 'new static' also differs. With 'new self', inherited methods instantiate the parent class where they were defined. This can lead to unexpected results if you're expecting the method to create an instance of the subclass.

'New static' respects the inheritance chain and instantiates the class that called the method. This allows for more flexible behavior in inherited methods.

Example:

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

    public static function createStatic() {
        return new static();
    }

    public function getSpecies() {
        return "Generic Animal";
    }
}

class Dog extends Animal {
    public function getSpecies() {
        return "Dog";
    }
}

$animal1 = Dog::create();
$animal2 = Dog::createStatic();

echo $animal1->getSpecies();  // Outputs: Generic Animal
echo $animal2->getSpecies();  // Outputs: Dog

In this example, Dog::create() returns an Animal instance because it uses 'new self', while Dog::createStatic() returns a Dog instance because it uses 'new static'. This difference in subclass instantiation can affect how inherited methods behave in your class hierarchy.

Use Cases for New Self

'New self' is used when you want to control object creation within a class hierarchy. It's useful for creating instances of a specific class, regardless of inheritance.

Common use cases for 'new self' include:

1. Implementing the Singleton pattern:

   class Singleton {
   private static $instance;
   
   public static function getInstance() {
       if (self::$instance === null) {
           self::$instance = new self();
       }
       return self::$instance;
   }
   }

2. Creating factory methods that return instances of a specific class:

   class SpecificFactory {
   public static function create() {
       return new self();
   }
   }

Benefits of using 'new self':

• Predictable object creation
• Control over class instantiation

Limitations:

• Less flexible in inheritance scenarios
• May not fit all design patterns

Use Cases for New Static

'New static' is useful in scenarios where you want flexibility in object creation, especially with inheritance. It creates instances of the class that called the method, not necessarily the class where the method is defined.

Common use cases for 'new static' include:

1. Implementing flexible factory methods:

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

class Dog extends Animal {} class Cat extends Animal {}

$dog = Dog::create(); // Creates a Dog instance $cat = Cat::create(); // Creates a Cat instance

2. Creating method chaining with inheritance:
```php
class QueryBuilder {
    public function where($condition) {
        // Add condition logic here
        return new static();
    }
}

class MySQLQueryBuilder extends QueryBuilder {}

$query = (new MySQLQueryBuilder())->where('id = 1');
// $query is an instance of MySQLQueryBuilder, not QueryBuilder

Benefits of using 'new static':

• Flexible object creation in inheritance scenarios
• Allows polymorphic behavior in static methods

Potential drawbacks:

• Can cause unexpected behavior if not used carefully
• May make code harder to understand in complex class hierarchies

class Parent {
    public static function getClassName() {
        return static::class;
    }
}

class Child extends Parent {}

echo Parent::getClassName(); // Outputs: Parent
echo Child::getClassName();  // Outputs: Child