PHP

<?php
abstract class AbstractClass
{
    // Force extending classes to define these methods
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // Common method
    public function printOut()
    {
        print $this->getValue() . "<br>";
    }
}
class ConcreteClass1 extends AbstractClass
{
    protected function getValue()
    {
        return "ConcreteClass1";
    }
    public function prefixValue($prefix)
    {
        return "{$prefix}ConcreteClass1";
    }
}
class ConcreteClass2 extends AbstractClass
{
    public function getValue()
    {
        return "ConcreteClass2";
    }
    public function prefixValue($prefix)
    {
        return "{$prefix}ConcreteClass2";
    }
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . "<br>";
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . "<br>";
?>

<?php
interface Shape
{
    const UNITS = "cm";
    public function area(): float;
    public function name(): string;
}
interface Printable
{
    public function printDetails(): void;
}
class Circle implements Shape, Printable
{
    public function __construct(private float $r) {}
    public function area(): float { return round(M_PI * $this->r ** 2, 2); }
    public function name(): string { return "Circle"; }
    public function printDetails(): void
    {
        echo $this->name() . " area = " . $this->area() . " sq " . self::UNITS . "<br>";
    }
}
class Rectangle implements Shape, Printable
{
    public function __construct(private float $l, private float $w) {}
    public function area(): float { return $this->l * $this->w; }
    public function name(): string { return "Rectangle"; }
    public function printDetails(): void
    {
        echo $this->name() . " area = " . $this->area() . " sq " . Shape::UNITS . "<br>";
    }
}
$shapes = [new Circle(3), new Rectangle(4, 5)];
foreach ($shapes as $s) {
    $s->printDetails();
}
var_dump($shapes[0] instanceof Shape);
?>

<?php
trait Loggable
{
    public function log(string $msg): void
    {
        echo "[" . static::class . "] $msg<br>";
    }
}
final class Invoice
{
    use Loggable;
    final public function total(): int { return 1180; }
}
class User
{
    use Loggable;
}
(new Invoice())->log("Invoice created, total " . (new Invoice())->total());
(new User())->log("User logged in");
?>

public __set(string $name, mixed $value): void
public __get(string $name): mixed
public __isset(string $name): bool
public __unset(string $name): void

<?php
class PropertyTest
{
    /** Location for overloaded data. */
    private $data = array();
    /** Overloading not used on declared properties. */
    public $declared = 1;
    /** Overloading only used on this when accessed outside the class. */
    private $hidden = 2;

    public function __set($name, $value)
    {
        echo "Setting '$name' to '$value'\n";
        $this->data[$name] = $value;
    }
    public function __get($name)
    {
        echo "Getting '$name'\n";
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];
        }
        $trace = debug_backtrace();
        trigger_error('Undefined property via __get(): ' . $name .
            ' in ' . basename($trace[0]['file']) . ' on line ' . $trace[0]['line'], E_USER_NOTICE);
        return null;
    }
    public function __isset($name)
    {
        echo "Is '$name' set?\n";
        return isset($this->data[$name]);
    }
    public function __unset($name)
    {
        echo "Unsetting '$name'\n";
        unset($this->data[$name]);
    }
    /** Not a magic method, just here for example. */
    public function getHidden()
    {
        return $this->hidden;
    }
}
echo "<pre>\n";
$obj = new PropertyTest;
$obj->a = 1;
echo $obj->a . "\n\n";
var_dump(isset($obj->a));
unset($obj->a);
var_dump(isset($obj->a));
echo "\n";
echo $obj->declared . "\n\n";
echo "Let's experiment with the private property named 'hidden':\n";
echo "Privates are visible inside the class, so __get() not used...\n";
echo $obj->getHidden() . "\n";
echo "Privates not visible outside of class, so __get() is used...\n";
echo $obj->hidden . "\n";
echo "</pre>";
?>

public __call(string $name, array $arguments): mixed
public static __callStatic(string $name, array $arguments): mixed

<?php
class MethodTest
{
    public function __call($name, $arguments)
    {
        // Note: value of $name is case sensitive.
        echo "Calling object method '$name' " . implode(', ', $arguments) . "<br>";
    }
    public static function __callStatic($name, $arguments)
    {
        echo "Calling static method '$name' " . implode(', ', $arguments) . "<br>";
    }
}
$obj = new MethodTest;
$obj->runTest('in object context');
MethodTest::runTest('in static context');
?>

<?php
class Money
{
    public function __construct(private float $amount) {}
    public function __toString(): string
    {
        return "Rs. " . number_format($this->amount, 2);
    }
}
$price = new Money(2499.5);
echo "The price is $price";
?>

<?php
class MyClass
{
    public $var1 = 'value 1';
    public $var2 = 'value 2';
    public $var3 = 'value 3';
    protected $protected = 'protected var';
    private $private = 'private var';

    function iterateVisible()
    {
        echo "MyClass::iterateVisible:<br>";
        foreach ($this as $key => $value) {
            print "$key => $value<br>";
        }
    }
}
$class = new MyClass();
foreach ($class as $key => $value) {
    print "$key => $value<br>";
}
echo "<br>";
$class->iterateVisible();
?>

<?php
class MyIterator implements Iterator
{
    private $var = array();

    public function __construct($array)
    {
        if (is_array($array)) {
            $this->var = $array;
        }
    }
    public function rewind(): void
    {
        echo "rewinding<br>";
        reset($this->var);
    }
    public function current(): mixed
    {
        $var = current($this->var);
        echo "current: $var<br>";
        return $var;
    }
    public function key(): mixed
    {
        $var = key($this->var);
        echo "key: $var<br>";
        return $var;
    }
    public function next(): void
    {
        $var = next($this->var);
        echo "next: $var<br>";
    }
    public function valid(): bool
    {
        $key = key($this->var);
        $var = ($key !== NULL && $key !== FALSE);
        echo "valid: " . ($var ? "true" : "false") . "<br>";
        return $var;
    }
}
$values = array(1, 2, 3);
$it = new MyIterator($values);
foreach ($it as $a => $b) {
    print "$a: $b<br>";
}
?>

<?php
require "iterator_class.php";

class MyCollection implements IteratorAggregate
{
    private $items = array();
    private $count = 0;

    // Required definition of interface IteratorAggregate
    public function getIterator(): Iterator
    {
        return new MyIterator($this->items);
    }
    public function add($value)
    {
        $this->items[$this->count++] = $value;
    }
}
$coll = new MyCollection();
$coll->add('value 1');
$coll->add('value 2');
$coll->add('value 3');
foreach ($coll as $key => $val) {
    echo "key/value: [$key -> $val]<br><br>";
}
?>

<?php
class Driver_MySQL
{
    public function name() { return "MySQL driver ready"; }
}

<?php
class Example
{
    // The parameterized factory method
    public static function factory($type)
    {
        if (include_once 'Drivers/' . $type . '.php') {
            $classname = 'Driver_' . $type;
            return new $classname;
        } else {
            throw new Exception('Driver not found');
        }
    }
}
// Load a MySQL Driver
$mysql = Example::factory('MySQL');
// Load an SQLite Driver
$sqlite = Example::factory('SQLite');
echo $mysql->name() . "<br>";
echo $sqlite->name();
?>

<?php
class Example
{
    // Hold an instance of the class
    private static $instance;

    // A private constructor; prevents direct creation of object
    private function __construct()
    {
        echo 'I am constructed<br>';
    }
    // The singleton method
    public static function singleton()
    {
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }
        return self::$instance;
    }
    // Example method
    public function bark()
    {
        echo 'Woof!<br>';
    }
    // Prevent users from cloning the instance
    private function __clone() {}
}
$a = Example::singleton();
$b = Example::singleton();     // constructor is NOT called again
$a->bark();
var_dump($a === $b);
echo "<br>";
try {
    $c = new Example();        // not allowed
} catch (Error $e) {
    echo "Error: " . $e->getMessage();
}
?>