PHP Classes and Objects — $this Error in Static Context

Every serious PHP application you've ever used — Laravel, WordPress, Symfony — is built on one foundational idea: objects. Not arrays. Not loose functions scattered across files. Objects. The reason experienced developers reach for OOP isn't because it sounds fancy; it's because real-world problems naturally map to things that have both data and behaviour. A user doesn't just have a name — a user can also log in, update their profile, and reset their password. Bundling that data and those actions together is exactly what classes let you do.

Before OOP, PHP code tended to sprawl. You'd have a users.php with fifty functions, half of them needing the same $db variable passed around, half of them accidentally sharing global state. Bugs were hard to trace because data lived everywhere. Classes solve this by giving each concept in your application its own fenced-off space — its own properties to hold data and its own methods to act on it. Change the internals of a class without breaking anything outside it. That's the deal.

By the end of this article you'll understand not just how to define a class and instantiate an object, but why the constructor exists, what visibility keywords actually protect, how to tell a class method from an instance method, and the patterns senior developers use daily. You'll also walk away knowing the mistakes that trip up 80% of beginners so you can skip straight past them.

What PHP Classes and Objects Actually Are

PHP classes are blueprints for objects — they define properties and methods that instances will hold. Objects are runtime instances of a class, each with its own memory space for property values. The core mechanic: a class declares structure; the new keyword materializes it into a live object.

When you call a method on an object, PHP automatically injects $this as a reference to that specific instance. This is how methods access an object's own properties and other methods. Static methods, declared with the static keyword, belong to the class itself, not any instance — they cannot use $this because there is no object context. Calling a non-static method statically (e.g., ClassName::method()) triggers a deprecation warning in PHP 7 and an error in PHP 8, because $this is undefined.

Use classes and objects when you need to model entities with state and behavior — users, orders, HTTP requests. In real systems, this is the foundation for encapsulation, dependency injection, and testable code. Without objects, you end up with global state and procedural spaghetti that breaks under any non-trivial load.

Defining a Class: Blueprint Before You Build Anything

A class is a template. It describes what a thing looks like (its properties) and what a thing can do (its methods). Nothing actually exists in memory until you instantiate it with 'new'. This is the most important mental model shift: writing a class doesn't create a user, it defines what a user is.

Properties are variables that belong to the class. Methods are functions that belong to the class. Both live inside the class body, and both can be marked as public, protected, or private — more on that shortly.

The constructor is a special method named __construct(). PHP calls it automatically the moment you use 'new ClassName()'. Its job is to set the object up in a valid state. If you're building a BankAccount, the constructor should insist on an opening balance. You shouldn't be able to create a BankAccount that starts in an undefined, broken state — the constructor is your gatekeeper.

Notice in the example below how $this refers to the specific object being worked with. It's the object saying 'my own property'. Every object has its own copy of properties, which is why two BankAccount objects can have different balances without interfering with each other.

<?php

class BankAccount
{
    // Properties — data the object holds
    // 'private' means ONLY code inside this class can touch these directly
    private string $ownerName;
    private float  $balance;

    // The constructor runs automatically when you write: new BankAccount(...)
    // It guarantees the object starts in a valid, known state
    public function __construct(string $ownerName, float $openingBalance)
    {
        if ($openingBalance < 0) {
            // Throw early — never let broken data into your object
            throw new InvalidArgumentException('Opening balance cannot be negative.');
        }

        $this->ownerName = $ownerName;       // $this means THIS specific object
        $this->balance   = $openingBalance;
    }

    // A method that changes internal state
    public function deposit(float $amount): void
    {
        if ($amount <= 0) {
            throw new InvalidArgumentException('Deposit amount must be positive.');
        }
        $this->balance += $amount;  // Update THIS object's own balance
    }

    // A method that reads and returns state
    public function getBalance(): float
    {
        return $this->balance;
    }

    public function getSummary(): string
    {
        return "{$this->ownerName}'s account — Balance: £{$this->balance}";
    }
}

// --- Instantiation: pressing the cookie cutter ---

$aliceAccount = new BankAccount('Alice', 500.00);  // Creates one object
$bobAccount   = new BankAccount('Bob',   250.00);  // Creates a SEPARATE object

// Alice deposits — only her object changes
$aliceAccount->deposit(150.00);

echo $aliceAccount->getSummary() . PHP_EOL;
echo $bobAccount->getSummary()   . PHP_EOL;

// Demonstrate the constructor guard
try {
    $brokenAccount = new BankAccount('Eve', -100);
} catch (InvalidArgumentException $e) {
    echo 'Caught: ' . $e->getMessage() . PHP_EOL;
}

Visibility Keywords: public, protected, and private Actually Enforced

Visibility is the mechanism that lets you separate what an object exposes to the world from what it keeps to itself. Most beginners mark everything public because it's easier. That's a trap — it means any code anywhere in your codebase can reach in and mangle your object's state without going through your methods.

Think of it like a car dashboard. The steering wheel and pedals are public — they're designed to be used by the driver. The engine internals are private — you're not meant to reach in and adjust the fuel injectors directly while driving. That encapsulation is what makes the car safe to use.

public means anyone, anywhere can access it. protected means only this class and any class that extends it can access it (useful for inheritance). private means only code inside this exact class can access it.

The real-world pattern most PHP developers use: make all properties private, then expose only what outside code genuinely needs through carefully designed public methods. This is called encapsulation and it's one of OOP's four pillars. The payoff is that you can completely rewrite how a class stores its data internally without breaking any code that uses the class — as long as the public methods keep working the same way.

<?php

class UserProfile
{
    private string $email;          // Never exposed directly — change format internally anytime
    private string $passwordHash;  // Must NEVER be public
    private int    $loginCount = 0; // Internal bookkeeping only

    public function __construct(string $email, string $plainTextPassword)
    {
        $this->setEmail($email);  // Reuse validation logic via a private method
        // Hash immediately — plain text NEVER gets stored on the object
        $this->passwordHash = password_hash($plainTextPassword, PASSWORD_BCRYPT);
    }

    // Public setter — validates before accepting data (the only door in)
    public function updateEmail(string $newEmail): void
    {
        $this->setEmail($newEmail);  // Centralised validation
    }

    // Public getter — returns a safe view of internal data
    public function getEmail(): string
    {
        return $this->email;
    }

    // Public behaviour method — records the action internally
    public function recordLogin(): void
    {
        $this->loginCount++;
    }

    public function getLoginCount(): int
    {
        return $this->loginCount;
    }

    // Private — internal helper, NOT part of the public API
    // Outside code has no business calling this directly
    private function setEmail(string $email): void
    {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException("Invalid email address: {$email}");
        }
        $this->email = strtolower(trim($email)); // Normalise on the way in
    }
}

$user = new UserProfile('  Alice@Example.COM  ', 'hunter2');

$user->recordLogin();
$user->recordLogin();

echo $user->getEmail()      . PHP_EOL;  // Normalised automatically
echo $user->getLoginCount() . PHP_EOL;

// This line would cause a Fatal Error — uncomment to see it
// echo $user->passwordHash;  // Cannot access private property

try {
    $user->updateEmail('not-an-email');
} catch (InvalidArgumentException $e) {
    echo 'Caught: ' . $e->getMessage() . PHP_EOL;
}

Static Methods and Properties: When the Class Itself Needs to Know Things

Every object you've seen so far has its own independent copy of its properties. That's usually what you want. But sometimes a piece of data or behaviour belongs to the class itself — not to any one instance of it. That's what static is for.

A classic example is a counter tracking how many objects of a class have been created. You can't store that on any single object because no single object knows about the others. The class needs to hold it centrally.

Another common use case is factory methods — static methods that construct and return a new instance with a specific configuration. Laravel and many modern PHP frameworks use this pattern heavily: User::create([...]), Carbon::now(), Response::json(...).

Access static members with the :: operator (called the scope resolution operator), not ->. Inside the class, use self:: to refer to the class itself rather than $this. Using $this inside a static method is a fatal error because there is no 'this' — no object is involved.

Use static sparingly. Overusing it leads you back toward procedural code with global state. The sweet spot is factory methods and genuine class-level metadata like the counter below.

<?php

class DatabaseConnection
{
    // Static property — belongs to the CLASS, shared across all instances
    private static int    $connectionCount = 0;
    private static ?self  $primaryInstance = null;  // For the singleton pattern

    private string $dsn;
    private bool   $isConnected = false;

    // Private constructor — forces use of the factory method below
    private function __construct(string $dsn)
    {
        $this->dsn = $dsn;
        self::$connectionCount++;  // self:: targets the class, not an instance
    }

    // Static factory method — the only way to create an instance from outside
    // This pattern lets you add caching, logging, or validation in one place
    public static function create(string $dsn): self
    {
        return new self($dsn);  // 'new self()' creates an instance of THIS class
    }

    // Singleton factory — returns the same instance every time (common for DB connections)
    public static function getPrimaryConnection(string $dsn): self
    {
        if (self::$primaryInstance === null) {
            self::$primaryInstance = new self($dsn);
        }
        return self::$primaryInstance;  // Returns the SAME object on subsequent calls
    }

    public function connect(): void
    {
        // Simulate connection — real code would use PDO here
        $this->isConnected = true;
        echo "Connected to: {$this->dsn}" . PHP_EOL;
    }

    // Static method — usable without any instance at all
    public static function getTotalConnections(): int
    {
        return self::$connectionCount;
    }
}

// Factory method in action — clean, readable, can validate internally
$readReplica  = DatabaseConnection::create('mysql:host=replica1;dbname=shop');
$writeReplica = DatabaseConnection::create('mysql:host=primary;dbname=shop');

$readReplica->connect();
$writeReplica->connect();

// Access static data via the class name — no object needed
echo 'Total connections created: ' . DatabaseConnection::getTotalConnections() . PHP_EOL;

// Singleton — both variables point to the EXACT same object
$connA = DatabaseConnection::getPrimaryConnection('mysql:host=primary;dbname=shop');
$connB = DatabaseConnection::getPrimaryConnection('mysql:host=primary;dbname=shop');

echo 'Same instance? ' . ($connA === $connB ? 'Yes' : 'No') . PHP_EOL;

Object Cloning and Comparison: Two Gotchas That Bite in Production

Objects in PHP are passed by reference-like handles. This trips up developers who come from a JavaScript or Python background and also those who've only worked with PHP primitives. When you assign an object to a new variable, you don't get a copy — both variables point at the same object. Change it through one variable and the other sees the change too.

To get a true independent copy, you use the clone keyword. PHP then calls the magic __clone() method on the new copy if you've defined one — use that to deep-clone any nested objects the class holds, because clone is shallow by default.

Comparison has its own wrinkle. == checks if two objects have the same class and same property values. === checks if both variables point to the exact same instance in memory. This matters in tests and in any logic where identity (not just equality) matters.

This section pulls together everything from the article — you'll see a class with a constructor, private properties, a public API, and now cloning all working together. Think of this as the capstone example.

<?php

class CartItem
{
    public function __construct(
        public readonly string $sku,
        public int $quantity
    ) {}
}

class ShoppingCart
{
    private array  $items    = [];
    private string $currency;

    public function __construct(string $currency = 'GBP')
    {
        $this->currency = $currency;
    }

    public function addItem(CartItem $item): void
    {
        // Store the item — note: this stores a REFERENCE to the CartItem object
        $this->items[$item->sku] = $item;
    }

    public function getItemCount(): int
    {
        return array_sum(array_column(
            array_map(fn($i) => ['qty' => $i->quantity], $this->items),
            'qty'
        ));
    }

    // __clone is called automatically after PHP does the shallow copy
    // Without this, $cart->items would still point to the SAME CartItem objects
    public function __clone()
    {
        $clonedItems = [];
        foreach ($this->items as $sku => $item) {
            // Deep clone each nested object so the copy is truly independent
            $clonedItems[$sku] = clone $item;
        }
        $this->items = $clonedItems;
    }
}

$originalCart = new ShoppingCart('GBP');
$originalCart->addItem(new CartItem('TSHIRT-RED-M', 2));
$originalCart->addItem(new CartItem('MUG-FORGE', 1));

// Without clone — BOTH variables point to the same object
$sameCart = $originalCart;
$sameCart->addItem(new CartItem('HOODIE-BLUE-L', 3));  // This modifies $originalCart too!

echo 'Same-reference cart items: ' . $originalCart->getItemCount() . PHP_EOL; // 6, not 3

// With clone — completely independent copy
$giftCart = clone $originalCart;  // __clone() fires, deep-copies the items array
$giftCart->addItem(new CartItem('GIFT-WRAP', 1));

echo 'Original cart items: ' . $originalCart->getItemCount() . PHP_EOL; // Unchanged
echo 'Gift cart items:     ' . $giftCart->getItemCount()     . PHP_EOL; // Has the extra item

// Comparison demo
$anotherRef = $originalCart;           // Same instance
$clonedCopy = clone $originalCart;     // Different instance, same values

echo PHP_EOL;
echo '$anotherRef == $originalCart:  '  . var_export($anotherRef == $originalCart, true)  . PHP_EOL; // true
echo '$anotherRef === $originalCart: '  . var_export($anotherRef === $originalCart, true) . PHP_EOL; // true
echo '$clonedCopy == $originalCart:  '  . var_export($clonedCopy == $originalCart, true)  . PHP_EOL; // true
echo '$clonedCopy === $originalCart: '  . var_export($clonedCopy === $originalCart, true) . PHP_EOL; // false!

Inheritance in PHP: Extending Classes and Method Overriding

Inheritance lets you create a new class based on an existing one. The child class (subclass) inherits all public and protected properties and methods from the parent class (superclass). You can then add new properties and methods, or override existing ones to change behaviour.

PHP supports single inheritance — a class can extend only one parent class. But a parent class can have many children. This is the classic 'is-a' relationship: a Truck is a Vehicle, a Circle is a Shape.

The child class uses the extends keyword. Inside the child, you call parent::method() to invoke the parent's version of a method. Overriding methods must have compatible signatures — PHP enforces this at compile time.

A common mistake is forgetting to call the parent constructor if the parent has mandatory setup logic. A child class must explicitly call parent::__construct() if the parent's constructor is defined and does important work.

Use inheritance when the child class genuinely is a more specific version of the parent. If the relationship is more about sharing behaviour than identity, favour composition or traits instead.

<?php

abstract class Vehicle
{
    protected string $make;
    protected string $model;
    protected int $year;

    public function __construct(string $make, string $model, int $year)
    {
        $this->make  = $make;
        $this->model = $model;
        $this->year  = $year;
    }

    abstract public function getFuelType(): string;

    public function getDescription(): string
    {
        return "{$this->year} {$this->make} {$this->model}";
    }
}

class Car extends Vehicle
{
    private int $doors;

    public function __construct(string $make, string $model, int $year, int $doors)
    {
        parent::__construct($make, $model, $year);
        $this->doors = $doors;
    }

    public function getFuelType(): string
    {
        return 'Petrol';
    }

    public function getDoors(): int
    {
        return $this->doors;
    }
}

class ElectricCar extends Car
{
    private int $batteryCapacity; // kWh

    public function __construct(string $make, string $model, int $year, int $doors, int $batteryCapacity)
    {
        parent::__construct($make, $model, $year, $doors);
        $this->batteryCapacity = $batteryCapacity;
    }

    // Override fuel type — electric doesn't use petrol
    public function getFuelType(): string
    {
        return 'Electric';
    }

    public function getBatteryRange(): int
    {
        // Rough estimate: 6 km per kWh
        return $this->batteryCapacity * 6;
    }
}

$tesla = new ElectricCar('Tesla', 'Model 3', 2024, 4, 75);
echo $tesla->getDescription() . PHP_EOL;  // Inherited from Vehicle
echo 'Fuel type: ' . $tesla->getFuelType() . PHP_EOL;  // Overridden
echo 'Doors: ' . $tesla->getDoors() . PHP_EOL;        // Inherited from Car
echo 'Range: ' . $tesla->getBatteryRange() . ' km' . PHP_EOL;  // ElectricCar specific

Interfaces: The Contract That Saves Your Weekend

Here's a truth that hits hard after a 3AM rollback: production doesn't care about your intents, only your contracts. PHP interfaces enforce a specific set of required methods across unrelated classes. No ambiguity, no "well, we thought it worked."

Why this matters: You define an interface when multiple classes must implement the same behavior, but they implement it differently. Your payment gateway, for example, might have a PayPalStrategy and a StripeStrategy. Both must implement charge(float $amount) and refund(string $transactionId). The interface ensures that when your boss says "add a new processor," you literally cannot forget those methods.

The contract is enforced at compile-time. If a class says implements PaymentGateway but doesn't define charge(), PHP throws a fatal error before your code reaches staging. Not a warning. Not a log. A hard stop.

Inheritance is about sharing implementation. Interfaces are about sharing capability. Use them when you need to guarantee behavior without dictating how it's done.

// io.thecodeforge

interface PaymentGateway
{
    public function charge(float $amount): string; // returns transaction ID
    public function refund(string $transactionId): bool;
}

class StripeStrategy implements PaymentGateway
{
    public function charge(float $amount): string
    {
        // Stripe API call
        return 'txn_' . uniqid();
    }

    public function refund(string $transactionId): bool
    {
        return true; // assume success
    }
}

// Forgetting charge() throws:
// Fatal error: Class PayPalStrategy contains 1 abstract method
class PayPalStrategy implements PaymentGateway
{
    public function refund(string $transactionId): bool
    {
        return true;
    }
}

Abstract Classes: When You Want Partial Answers

An abstract class is the middle ground between a concrete class and an interface. It contains some implemented methods and some placeholders (abstract methods) that child classes must fill. Think of it as a partially-written blueprint with critical gaps your team must complete.

Why reach for this? When you have shared logic across related classes but need to force specific implementations for certain behaviors. Your DataExporter base class might have the export() method fully written, but it requires getData() and formatFile() to be defined by each subclass (CSV, PDF, JSON). The abstract class handles the boilerplate; the subclass handles the unique parts.

In PHP 8.x, abstract classes can have typed properties, named arguments, and full constructor promotion. They're not legacy—they're tactical.

Important: You cannot instantiate an abstract class directly. If someone writes $exporter = new DataExporter(), PHP will throw a fatal error. That's the feature, not a bug. You're forcing your team to think about specialization before execution.

// io.thecodeforge

abstract class DataExporter
{
    protected array $data;

    public function __construct(array $data)
    {
        $this->data = $data;
    }

    // Shared logic, fully implemented
    public function export(): string
    {
        $formatted = $this->formatFile();
        file_put_contents($this->getFilename(), $formatted);
        return $this->getFilename();
    }

    // Must be implemented by child classes
    abstract protected function formatFile(): string;
    abstract protected function getFilename(): string;
}

class CsvExporter extends DataExporter
{
    protected function formatFile(): string
    {
        $lines = [];
        foreach ($this->data as $row) {
            $lines[] = implode(',', $row);
        }
        return implode("\n", $lines);
    }

    protected function getFilename(): string
    {
        return 'export_' . date('Ymd') . '.csv';
    }
}

$exporter = new CsvExporter([['name', 'email']]);
echo $exporter->export();

Traits: Reuse Without Inheritance Hell

PHP single-inheritance model means a class can only extend one parent. That's a hard limit—your ReportGenerator can't extend both PdfRenderer and EmailSender. Traits are the escape hatch: they let you compose behavior into a class without constructing a fragile inheritance pyramid.

Think of a trait as a copy-paste that PHP manages for you. When a class uses a trait, PHP copies the trait's methods directly into the class at compile-time. No diamond problem, no fragile base class syndrome. Just reusable code that lives in its own file.

In PHP 8.x, traits support abstract methods, properties, and even other traits. Use them for cross-cutting concerns like logging, timestamp management, or caching logic that multiple unrelated classes need.

Watch the recall trap: If two traits define the same method, PHP throws a fatal error unless you resolve the conflict with insteadof or as. You'll discover this immediately in CI, not in production.

// io.thecodeforge

trait LoggerTrait
{
    private string $logFile;

    public function log(string $message): void
    {
        $timestamp = date('Y-m-d H:i:s');
        file_put_contents(
            $this->logFile ?? '/var/log/app.log',
            "[$timestamp] $message" . PHP_EOL,
            FILE_APPEND
        );
    }

    abstract public function getIdentifier(): string; // forces class to define
}

trait TimestampTrait
{
    public function getTimestamp(): string
    {
        return date('c');
    }
}

class OrderProcessor
{
    use LoggerTrait, TimestampTrait;

    public function getIdentifier(): string
    {
        return 'order_' . uniqid();
    }

    public function process(): void
    {
        $this->log('Processing started');
        // ...
        $this->log('Processing completed at ' . $this->getTimestamp());
    }
}

$processor = new OrderProcessor();
$processor->process();

Readonly Classes (PHP 8.2) for Immutable DTOs

PHP 8.2 introduced readonly classes, a powerful feature for creating immutable data transfer objects (DTOs). When a class is declared readonly, all its properties are automatically readonly, meaning they can only be initialized once (typically via constructor promotion) and cannot be modified afterward. This eliminates the need to manually mark each property as readonly and ensures the entire object is immutable.

Example: ```php readonly class UserDTO { public function __construct( public string $name, public string $email, ) {} }

$user = new UserDTO('Alice', 'alice@example.com'); // $user->name = 'Bob'; // Error: Cannot modify readonly property ```

Readonly classes are ideal for DTOs, value objects, and configuration objects where immutability is desired. They also support inheritance: a readonly class can extend another readonly class, but not a non-readonly class. Additionally, readonly classes can implement interfaces and use traits.

However, there are limitations: readonly classes cannot have static properties, and property hooks (PHP 8.4) are not allowed on readonly properties. Also, if you need lazy initialization or computed properties, a readonly class may not be suitable.

In production, readonly classes help prevent accidental mutation of data, making code more predictable and easier to debug. They are particularly useful in event sourcing, CQRS, and API response objects.

<?php

readonly class UserDTO {
    public function __construct(
        public string $name,
        public string $email,
        public ?​string $phone = null,
    ) {}
}

$user = new UserDTO('Alice', 'alice@example.com', '+1234567890');
echo $user->name; // Alice

// Uncommenting the next line would cause a fatal error:
// $user->name = 'Bob';

New in Initializers (PHP 8.1) for Cleaner Constructor Defaults

PHP 8.1 introduced "new in initializers," allowing you to use the new keyword directly in default parameter values, property declarations, and attribute arguments. This simplifies code by removing the need for constructors or helper methods to instantiate default objects.

Example without new in initializers: ``php class Logger { private Formatter $formatter; public function __construct(Formatter $formatter = null) { $this->formatter = $formatter ?? new JsonFormatter(); } } ``

With new in initializers: ``php class Logger { public function __construct( private Formatter $formatter = new JsonFormatter(), ) {} } ``

It is particularly useful for dependency injection defaults, test doubles, and configuration objects. However, be cautious: the expression is evaluated only once at the point of definition, not each time the default is used. For objects that need fresh instances, use a factory or a named constructor.

In production, new in initializers reduces boilerplate and makes constructor signatures cleaner. It's especially beneficial in large codebases where many classes have optional dependencies with sensible defaults.

<?php

class JsonFormatter {
    public function format(array $data): string {
        return json_encode($data);
    }
}

class Logger {
    public function __construct(
        private Formatter $formatter = new JsonFormatter(),
    ) {}

    public function log(array $data): void {
        echo $this->formatter->format($data);
    }
}

$logger = new Logger();
$logger->log(['message' => 'Hello']); // {"message":"Hello"}

Property Hooks (PHP 8.4) for Getter/Setter Logic

PHP 8.4 introduced property hooks, allowing you to define getter and setter logic directly on properties without writing separate methods. This brings a more elegant syntax for computed properties, validation, and lazy loading.

Example: ```php class User { public string $name { set => ucfirst(strtolower($value)); get => $this->name ?? 'Guest'; } }

$user = new User(); $user->name = 'aLiCe'; echo $user->name; // Alice ```

Property hooks are defined using curly braces after the property declaration. The get hook runs when the property is read, and the set hook runs when a value is assigned. The set hook receives $value (the assigned value) and must return the value to store (or throw an exception). The get hook returns the computed value.

Hooks can access the property's backing value via $this->propertyName, but be careful to avoid infinite recursion. They work with typed properties, promoted properties, and even readonly properties (though readonly properties only allow get hooks).

Property hooks are a game-changer for reducing boilerplate getter/setter methods. They are especially useful for: - Normalization (e.g., trimming strings) - Validation (e.g., throwing on invalid values) - Lazy loading (e.g., fetching from database on first access) - Computed properties (e.g., full name from first and last)

In production, property hooks make code more readable and maintainable by keeping logic close to the property declaration. However, avoid complex side effects in hooks to keep them predictable.

<?php

class User {
    public string $name {
        set => trim($value);
        get => strtoupper($this->name);
    }

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

$user = new User('  alice  ');
echo $user->name; // ALICE