<?php
interface I
{
    // 実装クラスは、public に読み取り可能なプロパティを持つ必要があります。
    // public に書き込み可能かどうかは制限されません。
    public string $readable { get; }

    // 実装クラスは、public に書き込み可能なプロパティを持つ必要があります。
    // public に読み取り可能かどうかは制限されません。
    public string $writeable { set; }

    // 実装クラスは、public に読み書き可能なプロパティを持つ必要があります。
    public string $both { get; set; }
}

// このクラスは、3つのプロパティをすべてフックのない通常のプロパティとして実装しています。
// これは問題ありません。
class C1 implements I
{
    public string $readable;

    public string $writeable;

    public string $both;
}

// このクラスは、3つのプロパティすべてを、要求されたフックのみを使って実装しています。
// これも問題ありません。
class C2 implements I
{
    private string $written = '';
    private string $all = '';

    // get フックのみ使い仮想プロパティを作成しています。
    // 「public に読み取り可能」という要件を満たします。
    // 書き込みはできませんが、インターフェイスからは要求されていません。
    public string $readable { get => strtoupper($this->writeable); }

    // インターフェイスはこのプロパティが「書き込み可能」であることのみ要求しています。
    // ここに get の動作も含めることは全く問題ありません。
    // この例では仮想プロパティを作成しています。
    public string $writeable {
        get => $this->written;
        set {
            $this->written = $value;
        }
    }

    // このプロパティは「public に読み書き可能」でなければならないため、
    // get と set の両方を実装する必要があります。
    // デフォルトの動作のままでも問題ありません。
    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)
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)
    {
    }
}

// これは動作せず、fatal error となります。
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 = 'Interface constant';
}

// Interface constant と表示します。
echo A::B;


class B implements A
{
    const B = 'Class constant';
}

// Class constant と表示します。
// 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
{
    /* ... */
}
?>