PHP Classes and Objects — $this Error in Static Context

<?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;
}

<?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;
}

<?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;

<?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!

<?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

// 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;
    }
}

// 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();

// 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();