- Php code to interface
- implements
- Constants
- Examples
- Готовимся к собеседованию по PHP: Всё, что вы хотели узнать об интерфейсах, совместимости сигнатур и не побоялись узнать
- Что может содержать интерфейс?
- Чего не может содержать интерфейс?
- Совместимость сигнатур методов
- Они полностью совпадают
- B добавляет к A аргументы по умолчанию
- B сужает область значений A
- Наследование интерфейсов
- Если ли в PHP множественное наследование?
- Тонкости реализации интерфейсов
- Интерфейс — это класс? Pro et Contra
- Что почитать в ночь перед ответственным собеседованием?
Php code to interface
Object interfaces allow you to create code which specifies which methods a class must implement, without having to define how these methods are implemented. Interfaces share a namespace with classes and traits, so they may not use the same name.
Interfaces are defined in the same way as a class, but with the interface keyword replacing the class keyword and without any of the methods having their contents defined.
All methods declared in an interface must be public; this is the nature of an interface.
In practice, interfaces serve two complementary purposes:
- To allow developers to create objects of different classes that may be used interchangeably because they implement the same interface or interfaces. A common example is multiple database access services, multiple payment gateways, or different caching strategies. Different implementations may be swapped out without requiring any changes to the code that uses them.
- To allow a function or method to accept and operate on a parameter that conforms to an interface, while not caring what else the object may do or how it is implemented. These interfaces are often named like Iterable , Cacheable , Renderable , or so on to describe the significance of the behavior.
Interfaces may define magic methods to require implementing classes to implement those methods.
Note:
Although they are supported, including constructors in interfaces is strongly discouraged. Doing so significantly reduces the flexibility of the object implementing the interface. Additionally, constructors are not enforced by inheritance rules, which can cause inconsistent and unexpected behavior.
implements
To implement an interface, the implements operator is used. All methods in the interface must be implemented within a class; failure to do so will result in a fatal error. Classes may implement more than one interface if desired by separating each interface with a comma.
A class that implements an interface may use a different name for its parameters than the interface. However, as of PHP 8.0 the language supports named arguments, which means callers may rely on the parameter name in the interface. For that reason, it is strongly recommended that developers use the same parameter names as the interface being implemented.
Note:
Interfaces can be extended like classes using the extends operator.
Note:
The class implementing the interface must declare all methods in the interface with a compatible signature. A class can implement multiple interfaces which declare a method with the same name. In this case, the implementation must follow the signature compatibility rules for all the interfaces. So covariance and contravariance can be applied.
Constants
It’s possible for interfaces to have constants. Interface constants work exactly like class constants. Prior to PHP 8.1.0, they cannot be overridden by a class/interface that inherits them.
Examples
Example #1 Interface example
// Declare the interface ‘Template’
interface Template
public function setVariable ( $name , $var );
public function getHtml ( $template );
>
// Implement the interface
// This will work
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 ( » , $value , $template );
>
// This will not work
// 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 ;
>
>
?>
Example #2 Extendable Interfaces
interface B extends A
public function baz ( Baz $baz );
>
// This will work
class C implements B
public function foo ()
>
public function baz ( Baz $baz )
>
>
// This will not work and result in a fatal error
class D implements B
public function foo ()
>
Example #3 Variance compatibility with multiple interfaces
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 ();
>
>
?>
Example #4 Multiple interface inheritance
interface B
public function bar ();
>
interface C extends A , B
public function baz ();
>
class D implements C
public function foo ()
>
Example #5 Interfaces with constants
// Prints: Interface constant
echo A :: B ;
class B implements A
const B = ‘Class constant’ ;
>
// Prints: Class constant
// Prior to PHP 8.1.0, this will however not work because it was not
// allowed to override constants.
echo B :: B ;
?>
Example #6 Interfaces with abstract classes
interface A
public function foo ( string $s ): string ;
public function bar ( int $i ): int ;
>
// An abstract class may implement only a portion of an interface.
// Classes that extend the abstract class must implement the rest.
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 ;
>
>
?>
Example #7 Extending and implementing simultaneously
// The keyword order here is important. ‘extends’ must come first.
class Two extends One implements Usable , Updatable
/* . */
>
?>
An interface, together with type declarations, provides a good way to make sure that a particular object contains particular methods. See instanceof operator and type declarations.
Готовимся к собеседованию по PHP: Всё, что вы хотели узнать об интерфейсах, совместимости сигнатур и не побоялись узнать
Интерфейсы, впервые появившись в PHP 5, давно уже заняли прочное место в объектно-ориентированной (или всё-таки правильнее «класс-ориентированной»?) части языка.
Казалось бы — что может быть проще интерфейса? «Как бы класс, но и не класс, нельзя создать экземпляр, скорее контракт для будущих классов, содержит в себе заголовки публичных методов» — не правда ли, именно такими словами вы чаще всего отвечаете на собеседовании на дежурный вопрос о том, что такое интерфейс?
Однако не всё так просто, как может показаться начинающему программисту на PHP. Привычные аналогии не работают, руководство по языку вводит вас в заблуждение, в коде таятся неожиданные «подводные камни»…
Что может содержать интерфейс?
Очевидно, что публичные методы, причем без реализации: сразу после заголовка (сигнатуры) метода следует закончить его точкой с запятой:
Чуть менее очевиден (хотя и описан в мануале) тот факт, что интерфейс может содержать константы (разумеется, только публичные!):
interface SomeInterface < public const STATUSES = [ 'OK' =>0, 'ERROR' => 1, ]; > if (SomeInterface::STATUSES['OK'] === $status) < // . >Почему же константы в интерфейсах не получили широкого распространения в промышленном коде, хотя и используются иногда? Причина в том, что их невозможно переопределить в интерфейсе-наследнике или в классе, реализующем данный интерфейс. Константы интерфейсов — самые константные константы в мире 🙂
Чего не может содержать интерфейс?
Больше ничего не может. Кроме заголовков публичных методов и публичных констант.
Нельзя включать в интерфейс:
- Любые свойства
- Непубличные методы
- Методы с реализацией
- Непубличные константы
Совместимость сигнатур методов
Для дальнейшего изучения интерфейсов нам с вами нужно узнать о важнейшем понятии, которое незаслуженно обойдено вниманием в мануале по PHP: о понятии «совместимости сигнатур».
Сигнатура — это описание функции (метода), включающее в себя:
- Модификатор доступа
- Имя функции (метода)
- Список аргументов, где для каждого аргумента указано:
function (); public function foo($arg = null); protected function sum(int $x, int $y, . $args): int; Предположим, что у нас есть две функции, A и B.
Сигнатура функции B считается совместимой с A (порядок важен, отношение несимметрично!) в строгом смысле, если:
Они полностью совпадают
Тривиальный случай, комментировать тут нечего.
B добавляет к A аргументы по умолчанию
function foo($x, $y = null); function foo($x, . $args); B сужает область значений A
// В A допускался возврат любых значений, в B эта область сужена только до целых чисел function foo(int $x): int; Теперь, когда мы ввели эти три простых правила совместимости определений, станет гораздо проще понять дальнейшие тонкости, связанные с интерфейсами.
Наследование интерфейсов
Интерфейсы могут наследоваться друг от друга:
interface First < public const PI = 3.14159; public function foo(int $x); >interface Second extends First < public const E = 2.71828; public function bar(string $s); >assert(3.14159 === First::PI); assert(true === method_exists(First::class, 'foo')); assert(3.14159 === Second::PI); assert(2.71828 === Second::E); assert(true === method_exists(Second::class, 'foo')); assert(true === method_exists(Second::class, 'bar')); Интерфейс-наследник получает от интерфейса-предка в наследство все определенные в предке методы и константы.
В интерфейсе-наследнике можно переопределить метод из родительского интерфейса. Но только при условии, что либо его сигнатура будет в точности совпадать с сигнатурой родительского, либо будет совместима (см. предыдущий раздел):
interface First < public function foo(int $x); >interface Second extends First < // Так можно, но бессмысленно public function foo(int $x); // Так нельзя, фатальная ошибка Declaration must be compatible public function foo(int $x, int $y); // Так можно, потому что эта сигнатура совместима с родительской - мы просто добавили необязательный аргумент public function foo(int $x, int $y = 0); // Так тоже можно, все аргументы после ". " являются необязательными public function foo(int $x, . $args); // И так тоже можно public function foo(int $x, . $args): int; >Если ли в PHP множественное наследование?
Если вам зададут такой вопрос, смело отвечайте: «да». Интерфейс может наследоваться от нескольких других интерфейсов.
interface First < public function foo(int $x); >interface Second < public function bar(string $s); >interface Third extends First, Second < public function baz(array $a); >assert(true === method_exists(Third::class, 'foo')); assert(true === method_exists(Third::class, 'bar')); assert(true === method_exists(Third::class, 'baz')); Правила решения конфликтов сигнатур методов при множественном наследовании точно такие же, как мы уже видели выше:
— либо сигнатуры совпадают полностью
— либо сигнатура метода интерфейса, упомянутого в списке предков первым, должна быть совместима с сигнатурой из второго предка (да, порядок упоминания имеет значение, но это очень редкий кейс, просто не принимайте его никогда во внимание)
Тонкости реализации интерфейсов
Собственно, после всего, что вы уже видели, это уже и не тонкости, а так, мелкие нюансы.
Во-первых действительно, наследование класса от интерфейса называется реализацией. Смысл в том, что вы не просто получаете в наследство методы и константы, но обязаны реализовать те методы, которые заданы сигнатурами, наполнить их кодом:
interface IntSumInterface < public function sum(int $x, int $y): int; >interface IntMultInterface < public function mult(int $x, int $y): int; >class Math implements IntSumInterface, IntMultInterface < public function sum(int $x, int $y): int < return $x + $y; >public function mult(int $x, int $y): int < return $x * $y; >> Важный аспект, который отличает реализацию интерфейса от наследования от другого класса — это возможность реализовать в одном классе несколько интерфейсов сразу.
Как быть, если в разных интерфейсах, которые реализует класс, будет один и тот же метод (с одинаковым названием)? Смотри выше — также, как и при наследовании интерфейсов друг от друга должен соблюдаться принцип совместимости сигнатур.
И да. Не верьте мануалу, который провозглашает:
Сигнатуры методов в классе, реализующем интерфейс, должны точно совпадать с сигнатурами, используемыми в интерфейсе, в противном случае будет вызвана фатальная ошибка.
The class implementing the interface must use the exact same method signatures as are defined in the interface. Not doing so will result in a fatal error.
Всё не так, действует тоже самое правило совместимости:
interface SomeInterface < public function sum(int $x, int $y); >class SomeClass implements SomeInterface < public function sum(int $x, int $y): int или public function sum(int $x, int $y, int $z = 0): int или даже public function sum(int $x, int $y, . $args): int < // реализация метода >> Интерфейс — это класс? Pro et Contra
Вообще-то нет. Интерфейс — это интерфейс, он отличается от класса хотя бы тем, что нельзя создать «экземпляр интерфейса».
И вообще-то да, у них в PHP очень много общего:
- Интерфейсы, как и классы, могут находиться в пространстве имён.
- Интерфейсы, как и классы, можно загружать через механизм автозагрузки. Функции автозагрузки будет передано полное имя интерфейса (с пространством имён).
- В каждом интерфейсе есть предопределенная константа ThisInterface::class, содержащая его полное имя
- Интерфейс, как и класс, может участвовать справа в операторе instanceof
- Интерфейс, как и класс, может быть указан в качестве типа в тайп-хинтинге (указание типа аргумента либо возвращаемого значения функции)
Что почитать в ночь перед ответственным собеседованием?
Разумеется, мануал по языку:
Системный подход к самообразованию в программировании очень важен. И, по моему мнению, неплохо в начале пути в IT помогают структурировать самообучение вебинары и краткосрочные курсы. Именно поэтому я рекомендую (и немного скромно рекламирую) даже опытным разработчикам посещать разовые вебинары и курсы повышения квалификации — результат при грамотном сочетании курсов и самоподготовки всегда налицо!
Успехов на собеседовании и в работе!