<?php

interface I
{
    // Класс, в котором реализуется свойство, ДОЛЖЕН объявить открытое для чтения свойство,
    // но объявление свойства в интерфейсе не ограничивает объявление доступа на запись свойства в классе
    public string $readable {
        get;
    }

    // Класс, в котором реализуется свойство, должен объявить открытое для записи свойство,
    // но объявление свойства в интерфейсе не ограничивает объявление доступа на чтение свойства в классе
    public string $writeable {
        set;
    }

    // Класс, в котором реализуется свойство, должен объявить свойство,
    // открытое как для чтения, так и для записи
    public string $both {
        get;
        set;
    }
}

// Класс реализует каждое из трёх свойств традиционно, без хуков.
// Такая реализация свойств допустима
class C1 implements I
{
    public string $readable;

    public string $writeable;

    public string $both;
}

// Класс реализует каждое из трёх свойств и определяет только те хуки,
// которые потребовал интерфейс. Такая реализация свойств тоже допустима
class C2 implements I
{
    private string $written = '';
    private string $all = '';

    // Класс реализует только хук для чтения, чтобы создать виртуальное свойство.
    // Такое определение удовлетворяет требованию «публичной открытости для чтения».
    // Свойство недоступно для записи, но интерфейс и не требует открытого доступа для записи
    public string $readable {
        get => strtoupper($this->writeable);
    }

    // Интерфейс требует только того, чтобы класс определил свойство, открытое для записи,
    // но включение хука для операции чтения тоже допустимо.
    // Пример создаёт виртуальное свойство, и это нормально
    public string $writeable {
        get => $this->written;

        set {
            $this->written = $value;
        }
    }

    // Свойство требует как операции чтения, так и операции записи,
    // поэтому потребуется либо реализовать оба хука, либо разрешить операциям чтения и записи
    // поведение по умолчанию
    public string $both {
        get => $this->all;

        set {
            $this->all = strtoupper($value);
        }
    }
}

?>

<?php

// Объявляем интерфейс 'Template'
interface Template
{
    public function setVariable($name, $var);
    public function getHtml($template);
}

// Реализуем интерфейс
// Это сработает
class WorkingTemplate implements Template
{
    private $vars = [];

    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }

    public function getHtml($template)
    {
        foreach ($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }

        return $template;
    }
}

// Это не сработает
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (Template::getHtml)
// (Фатальная ошибка: Класс BadTemplate содержит 1 абстрактный метод
// и поэтому требуется объявить класс абстрактным (Template::getHtml))
class BadTemplate implements Template
{
    private $vars = [];

    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
}

?>

<?php

interface A
{
    public function foo();
}

interface B extends A
{
    public function baz(Baz $baz);
}

// Это сработает
class C implements B
{
    public function foo() {}

    public function baz(Baz $baz) {}
}

// Это не сработает и выдаст фатальную ошибку
class D implements B
{
    public function foo() {}

    public function baz(Foo $foo) {}
}

?>

<?php

class Foo {}
class Bar extends Foo {}

interface A
{
    public function myfunc(Foo $arg): Foo;
}

interface B
{
    public function myfunc(Bar $arg): Bar;
}

class MyClass implements A, B
{
    public function myfunc(Foo $arg): Bar
    {
        return new Bar();
    }
}

?>

<?php

interface A
{
    public function foo();
}

interface B
{
    public function bar();
}

interface C extends A, B
{
    public function baz();
}

class D implements C
{
    public function foo() {}

    public function bar() {}

    public function baz() {}

}
?>

<?php

interface A
{
    const B = 'Константа интерфейса';
}

// Выведет: Константа интерфейса
echo A::B;


class B implements A
{
    const B = 'Константа класса';
}

// Выведет: Константа класса
// До PHP 8.1.0 этот код не сработает,
// поскольку запрещалось переопределять константы
echo B::B;

?>

<?php

interface A
{
    public function foo(string $s): string;

    public function bar(int $i): int;
}

// Абстрактному классу можно реализовывать только часть интерфейса.
// Классы, которыми расширяется абстрактный класс, должны реализовать остальные требования интерфейса
abstract class B implements A
{
    public function foo(string $s): string
    {
        return $s . PHP_EOL;
    }
}

class C extends B
{
    public function bar(int $i): int
    {
        return $i * 2;
    }
}

?>

<?php

class One
{
    /* ... */
}

interface Usable
{
    /* ... */
}

interface Updatable
{
    /* ... */
}

// Порядок ключевых слов здесь важен. Слово extends должно идти первым
class Two extends One implements
    Usable,
    Updatable
{
    /* ... */
}

?>