Interfaces and abstract classes in php and the differences between interfaces and abstract classes

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) The methods in the interface and the class that implements it default They are all of public type
2. Abstract class
(1) The use of abstract class is through the keyword extends
(2) It cannot be instantiated, and you can define methods that subclasses 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 as that in the parent class (or more relaxed)
(4) If there is an abstract method in a class, then the class Must be defined as an abstract class
(5) Abstract classes can have constructors
(6) Methods in abstract classes 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 Classified and directly accessed
(2) Static properties cannot be accessed by objects through the -> operator, and are called using the :: method

<?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();

The difference between abstract classes and interfaces

1. The use of the interface 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, and 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.

Recommended tutorial: "PHP Tutorial"

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