Detailed explanation of interfaces, abstract classes and the differences between interfaces and abstract classes in PHP

In php, the interface abstract class, Final, and Static are quite simple and are useful especially for large-scale website architecture. Today we will look at an article about php. Examples of abstract classes, Final, and Static.

1. Interface
(1) The use of the interface is through the keyword implements
(2) The interface cannot define member variables (including class static variables), but can define Constants
(3) Subclasses must implement all methods defined by the interface
(4) The interface can only define but not implement the method
(5) The interface has no constructor
(6) Methods in the interface And the class that implements it is of public type by default
2. Abstract class
(1) The use of abstract class is through the keyword extends
(2) It cannot be instantiated , you can define the methods that the subclass must implement
(3) The subclass must define all abstract methods in the parent class, and the access control of these methods must be the same (or more relaxed) as in the parent class
(4) If there is an abstract method in a class, the class must be defined as an abstract class
(5) An abstract class can have a constructor
(6) Methods in an abstract class can be modified with private, protected, and public.
(7) A class can implement multiple interfaces at the same time, but a class can only inherit from one abstract class.
3. Final class/method
(1) The final class cannot be inherited
(2) The final method cannot be overridden
4. Static class/method
(1) Can not be instanced Transform the class and access it directly
(2) Static properties cannot be accessed by the object through the -> operator, use the :: method to call

Example

<?php
# 接口
interface Human{
    const TEST_CONST = "test const"; // 定义常量
    // public $v; // error，不能定义变量
    // static $count; // error，不能定义变量
    public function speak();
    public function walk();
    public function run();
}
     
# 抽象类
abstract class Father implements Human{
     
    public function construct(){
        echo "father init n";
    }
     
    abstract public function walk(); // 抽象方法
     
    public function speak(){
        echo "father speak skill n";
    }
     
    public function run(){
        echo "father run skill n";
    }
}
     
# 非抽象类
class Mother implements Human{
     
    public function construct(){
        echo "mother init n";
    }
     
    # 这里必须实现walk方法
    public function walk(){
        echo "mother walk skill n"; 
    } 
     
    public function speak(){
        echo "mother speak skill n";
    }
     
    public function run(){
        echo "mother run skill n";
    }
}
     
class Son extends Father{
     
    public function walk(){
        echo "son walk skill. n";
    }
     
    public function speak($name = &#39;&#39;){
        echo "son: ". $name ." speak skill. n";
    }
     
    # 访问控制必须和父类中一样（或者更为宽松）
    protected function sport(){
        echo "son sport skill. n";
    }
     
    final public function notTeach(){
        echo &#39;son has not to teach skill&#39;;
    }
}
     
class Daughter extends Mother{
     
    public function run($name = &#39;&#39;){
        echo "daughter run skill. n";
    }
     
}
     
final class GrandChild extends Son{
         
    # 访问控制必须和父类中一样（或者更为宽松）
    public function sport(){
        echo "GrandChild sport skill. n";
    }
     
    # Cannot override final method Son::notTeach()
    // public function notTeach(){} // error
}
     
#  Class Orphan may not inherit from final class (GrandChild)
// class Orphan extends GrandChild{}  // error
     
$son = new Son();
$son->speak("Suly");
     
$daughter = new Daughter();
$daughter->run(&#39;Lily&#39;);
     
$grandChild = new GrandChild();
$grandChild->sport();

Abstract class The difference with interfaces

1. The use of interfaces is through the keyword implements. The use of abstract classes is through the keyword extends. Of course, interfaces can also be inherited through the keyword extends.
2. Member variables (including class static variables) cannot be declared in the interface, but class constants can be declared. Various types of member variables can be declared in abstract classes to implement data encapsulation. (In addition, the member variables in the JAVA interface must be declared as public static final type)
3. The interface does not have a constructor, but the abstract class can have a constructor.

4. Methods in interfaces are of public type by default, while methods in abstract classes can be modified with private, protected, or public.

5. A class can implement multiple interfaces at the same time, but a class can only inherit from one abstract class.

Abstract class or interface
If you want to create a model that will be adopted by some closely related objects, you can use abstract classes. Use interfaces if you want to create functionality that will be adopted by a number of unrelated objects.
If behavior must be inherited from multiple sources, use interfaces.
If you know that all classes will share a common behavior implementation, use an abstract class and implement the behavior in it.

The above is the detailed content of Detailed explanation of interfaces, abstract classes and the differences between interfaces and abstract classes in PHP. For more information, please follow other related articles on the PHP Chinese website!