You may use interfaces in PHP to define which methods a class should implement. Interfaces make it easy to use several classes at the same time. The term "polymorphism" refers to when two or more groups share the same interface.
- The names and arguments of methods can be specified by an interface, but not their contents.
- All classes that implement an interface must implement all of the interface's methods.
- Multiple interfaces can be implemented by a single class.
- The keyword "interface" is used to declare an interface.
- Non-abstract methods cannot be maintained by interfaces.
What Is an Interface in PHP?
An interface in PHP establishes a contract that a class must adhere to. An interface is a blueprint for classes, just as a PHP class is for objects. In terms of what can be called, how it can be called, and what will be returned, any class implementing a given interface can be expected to behave the same way.
interface <interface_name> { // declare constant fields // declare methods that abstract // by default. }
Users may build programs by defining the public methods that a class must implement, without having to worry about the nuances and specifics of how the methods are implemented. The next level of abstraction is what it is known as. It is similar to abstract processes and abstract groups. An interface is classified as a class, except the class keyword is replaced by the interface keyword, and only the feature prototypes are defined. There are no data variables in the gui. The gui guarantees that all of the methods a programmer wishes to operate on are cataloged in a proper manner.
Programmers benefit from interfaces in various ways.
- They give a developer the opportunity to refer to objects in a more abstract way.
- Interfaces also allow you to switch out implementations much more quickly and easily than you could if you were programming to a concretion.
- Finally, interfaces can be used in our code to implement contracts. When a class implements our interface, we can decide specifically what behaviours, or methods, it should have.
- At the end of the day, almost any SOLID concept involves the use of an interface in some way, so understanding how interfaces operate is beneficial.
Interfaces help in fulfilling goals:
- They allow referring to objects (for example, var vehicle : Vehicle may refer to any car, truck, or other vehicle) (and not care what type it is.) This happens during "program time."
- The correct function associated with the real object is used when the vehicle.start engine() function is called. This happens during "run time."
- When an implementing class implements an Interface, they enable the programmer to construct unique functions that are required in that class.
- This allows all objects in a "collection" of similar objects to be handled according to the "high level" type of the set rather than the particular type of each individual object.
Creating an Interface
Let us look at an example on how you can create interface in PHP:
<?php
interface MyInterfaceName {
public function methodA();
public function methodB();
}
?>
Example:
<?php
interface MyInterfaceName{
public function method1();
public function method2();
}
class MyClassName implements MyInterfaceName{
public function method1(){
echo "Method1 Called" . "\n";
}
public function method2(){
echo "Method2 Called". "\n";
}
}
$obj = new MyClassName;
$obj->method1();
$obj->method2();
?>
Output
Characteristics of an Interface
The following are some of the characteristics of an interface in PHP:
- An interface in PHP is made up of methods that don't have any implementations, so they're called abstract methods.
- All methods in interfaces must be visible to the public.
- Interfaces vary from classes; a class can only inherit from one class, while an interface can be implemented by a class.
Advantages of PHP Interface
- Interfaces have a versatile base/root framework that classes don't.
- Unrelated classes can implement the same methods using an interface, regardless of their place in the class inheritance hierarchy.
- Since a class can implement multiple interfaces but only extend one, an interface can model multiple inheritances.
- The introduction of inheritance would save the caller from having to enforce any of the object methods and instead concentrate on the object's interface, leaving the caller interface unchanged.
- Through implementing interfaces, the object's caller is only concerned with the object's interface, not the implementation of the object's methods.
Interesting Features of PHP Interface
- A class cannot implement two interfaces with the same method name, resulting in method uncertainty.
- The same keyword "extends" can be used to define an inheritance relationship between interfaces and classes.
Example 1:
<?php
interface i1
{
public function fun1();
}
interface i2
{
public function fun2();
}
class cls1 implements i1,i2
{
function fun1()
{
echo "javatpoint";
}
function fun2()
{
echo "SSSIT";
}
}
$obj= new cls1();
$obj->fun1();
$obj->fun2();
?>
Output
Conclusion
PHP is considered to be one of the most effective languages when it comes to developing websites. It offers the users a platform where they can create appealing web pages that will keep the audience hooked for a long time. If you are in love with developing and designing websites, then you must have a good knowledge of interface in PHP language.
Want to learn the language in a professional way? Enroll yourself in Simplilearn and elevate your career as a software developer through Post Graduate Program in Full Stack Web Development course. This course will teach you the concepts in the best manner.