Learn PHP Programming

<?php
declare(strict_types=1);

class Animal {
    public function __construct(
        protected string $name,
        protected int $age
    ) {}

    public function speak(): string {
        return "{$this->name} makes a sound.";
    }

    public function info(): string {
        return "{$this->name} (age: {$this->age})";
    }

    public function sleep(): string {
        return "{$this->name} is sleeping.";
    }
}

class Dog extends Animal {
    public function __construct(string $name, int $age, private string $breed) {
        parent::__construct($name, $age);  // Call parent constructor
    }

    // Override parent method completely
    public function speak(): string {
        return "{$this->name} barks: Woof!";
    }

    // Override and extend parent behavior
    public function info(): string {
        return parent::info() . " — Breed: {$this->breed}";
    }

    // New method specific to Dog
    public function fetch(string $item): string {
        return "{$this->name} fetches the {$item}!";
    }
}

$dog = new Dog('Rex', 3, 'German Shepherd');
echo $dog->speak();   // Rex barks: Woof! (overridden)
echo $dog->info();    // Rex (age: 3) — Breed: German Shepherd (extended)
echo $dog->sleep();   // Rex is sleeping. (inherited unchanged)
echo $dog->fetch('ball');  // Rex fetches the ball! (new method)
?>

<?php
// Abstract classes cannot be instantiated — they serve as templates
abstract class PaymentProcessor {
    protected array $log = [];

    // Abstract methods: child classes MUST implement these
    abstract public function charge(float $amount): bool;
    abstract public function refund(float $amount): bool;
    abstract public function getProviderName(): string;

    // Concrete method shared by all children
    public function process(float $amount): string {
        $this->log[] = "Processing \${$amount} via " . $this->getProviderName();
        if ($this->charge($amount)) {
            return "Successfully charged \${$amount}";
        }
        return "Payment failed";
    }

    public function getLog(): array {
        return $this->log;
    }
}

class StripeProcessor extends PaymentProcessor {
    public function charge(float $amount): bool {
        // Stripe-specific API call
        return $amount > 0 && $amount < 10000;
    }

    public function refund(float $amount): bool {
        $this->log[] = "Stripe refund: \${$amount}";
        return true;
    }

    public function getProviderName(): string {
        return 'Stripe';
    }
}

class PayPalProcessor extends PaymentProcessor {
    public function charge(float $amount): bool {
        return $amount > 0;
    }

    public function refund(float $amount): bool {
        $this->log[] = "PayPal refund: \${$amount}";
        return true;
    }

    public function getProviderName(): string {
        return 'PayPal';
    }
}

// Cannot do: $p = new PaymentProcessor(); // Fatal error!

$stripe = new StripeProcessor();
echo $stripe->process(49.99);  // Successfully charged $49.99
?>

<?php
// final class — cannot be extended at all
final class ImmutableConfig {
    private array $settings;

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

    public function get(string $key): mixed {
        return $this->settings[$key] ?? null;
    }
}

// class ExtendedConfig extends ImmutableConfig {} // Fatal error!

class BaseService {
    // final method — cannot be overridden in child classes
    final public function validateInput(array $data): bool {
        // Security-critical logic locked down
        foreach ($data as $value) {
            if (empty($value)) return false;
        }
        return true;
    }

    // This method CAN be overridden
    public function execute(array $data): string {
        if (!$this->validateInput($data)) {
            return 'Invalid input';
        }
        return 'Executed';
    }
}

class EmailService extends BaseService {
    // Cannot override validateInput — it is final!

    public function execute(array $data): string {
        parent::execute($data);  // Call parent version first
        return "Email sent to {$data['to']}";
    }
}
?>

<?php
interface Exportable {
    public function toArray(): array;
}

abstract class BaseModel {
    abstract public function getId(): int;
}

class User extends BaseModel implements Exportable {
    public function __construct(private int $id, private string $name) {}
    public function getId(): int { return $this->id; }
    public function toArray(): array {
        return ['id' => $this->id, 'name' => $this->name];
    }
}

class Guest {
    public function __construct(public string $sessionId) {}
}

function processEntity(object $entity): string {
    // Check against class hierarchy
    if ($entity instanceof BaseModel) {
        $result = "Model ID: " . $entity->getId();
    } else {
        $result = "Not a model";
    }

    // Check against interface
    if ($entity instanceof Exportable) {
        $result .= " | Exportable: " . json_encode($entity->toArray());
    }

    return $result;
}

$user = new User(1, 'Alice');
$guest = new Guest('sess_abc');

echo processEntity($user);
// Model ID: 1 | Exportable: {"id":1,"name":"Alice"}

echo processEntity($guest);
// Not a model

var_dump($user instanceof BaseModel);   // true
var_dump($user instanceof Exportable);  // true
var_dump($guest instanceof BaseModel);  // false
?>