Learn PHP Programming

<?php
class Product {
    private string $name;
    private float $price;
    private int $stock;

    public function __construct(string $name, float $price, int $stock = 0) {
        $this->name  = $name;
        $this->price = $price;
        $this->stock = $stock;
    }

    public function getName(): string {
        return $this->name;
    }

    public function getPrice(): float {
        return $this->price;
    }

    public function isInStock(): bool {
        return $this->stock > 0;
    }

    public function purchase(int $quantity = 1): bool {
        if ($quantity > $this->stock) {
            return false;
        }
        $this->stock -= $quantity;
        return true;
    }

    public function getFormattedPrice(): string {
        return '$' . number_format($this->price, 2);
    }
}

// Creating and using objects
$laptop = new Product('Laptop Pro', 999.99, 15);
echo $laptop->getName();           // Laptop Pro
echo $laptop->getFormattedPrice(); // $999.99
echo $laptop->isInStock();         // true

$laptop->purchase(2);  // Buy 2 units
?>

<?php
class BankAccount {
    private string $owner;        // Only this class can access
    private float $balance = 0;   // Hidden from outside
    protected string $currency;   // This class + child classes

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

    // Public: anyone can call
    public function deposit(float $amount): void {
        if ($amount <= 0) {
            throw new \InvalidArgumentException('Amount must be positive');
        }
        $this->balance += $amount;
        $this->logTransaction('deposit', $amount);
    }

    public function getBalance(): float {
        return $this->balance;
    }

    // Private: only this class can call
    private function logTransaction(string $type, float $amount): void {
        // Internal logging - not accessible from outside
        error_log("{$this->owner}: $type of $amount {$this->currency}");
    }
}

$account = new BankAccount('Alice');
$account->deposit(500.00);
echo $account->getBalance(); // 500.00

// $account->balance;         // ERROR: Cannot access private property
// $account->logTransaction(); // ERROR: Cannot access private method
?>

<?php
class Database {
    private static ?Database $instance = null;
    private \PDO $connection;

    private function __construct(string $dsn) {
        $this->connection = new \PDO($dsn);
    }

    // Static method - called on the class, not an instance
    public static function getInstance(string $dsn = 'sqlite::memory:'): self {
        if (self::$instance === null) {
            self::$instance = new self($dsn);
        }
        return self::$instance;
    }

    public function query(string $sql): array {
        return $this->connection->query($sql)->fetchAll();
    }
}

// Usage - no "new" keyword needed
$db = Database::getInstance('sqlite:app.db');
$results = $db->query('SELECT * FROM users');

// Another example: utility class with static helpers
class StringHelper {
    public static function slugify(string $text): string {
        $text = strtolower(trim($text));
        $text = preg_replace('/[^a-z0-9-]/', '-', $text);
        return preg_replace('/-+/', '-', $text);
    }

    public static function truncate(string $text, int $length = 100): string {
        if (strlen($text) <= $length) return $text;
        return substr($text, 0, $length) . '...';
    }
}

echo StringHelper::slugify('Hello World!'); // hello-world-
?>

<?php
// Traditional way (verbose)
class UserOld {
    private string $name;
    private string $email;
    private string $role;

    public function __construct(string $name, string $email, string $role = 'user') {
        $this->name = $name;
        $this->email = $email;
        $this->role = $role;
    }
}

// PHP 8+ Constructor Promotion (concise)
class User {
    public function __construct(
        private string $name,
        private string $email,
        private string $role = 'user',
        private readonly \DateTimeImmutable $createdAt = new \DateTimeImmutable()
    ) {}

    public function getName(): string { return $this->name; }
    public function getEmail(): string { return $this->email; }
    public function getRole(): string { return $this->role; }
}

// Readonly classes (PHP 8.2+) - all properties are implicitly readonly
readonly class Point {
    public function __construct(
        public float $x,
        public float $y
    ) {}

    public function distanceTo(Point $other): float {
        return sqrt(($this->x - $other->x) ** 2 + ($this->y - $other->y) ** 2);
    }
}

$p1 = new Point(0, 0);
$p2 = new Point(3, 4);
echo $p1->distanceTo($p2); // 5.0
// $p1->x = 10; // ERROR: Cannot modify readonly property
?>