Detailed explanation of abstract classes and interfaces in PHP

This article mainly shares with you the detailed explanation of abstract classes and interfaces in PHP, hoping to help everyone.

1. Abstract class abstract class

1． An abstract class refers to a class with the abstract keyword added before class and an abstract method (the abstract keyword added before the class method function keyword).

2 . Abstract classes cannot be instantiated directly. The abstract class only defines (or partially implements) the methods required by the subclass. Subclasses can make an abstract class concrete by inheriting it and by implementing all the abstract methods in the abstract class.

3． If a subclass needs to be instantiated, it must implement all abstract methods in the abstract class. If the subclass does not implement all the abstract methods in the abstract class, then the subclass is also an abstract class and must be preceded by the abstract keyword in class and cannot be instantiated.

abstract class A  
{  
    /** 抽象类中可以定义变量 */  
    protected $value1 = 0;  
    private $value2 = 1;  
    public $value3 = 2;  
    /** 也可以定义非抽象方法 */  
    public function my_print()  
    {  
        echo "hello,world/n";  
    }  
    /** 
     * 大多数情况下，抽象类至少含有一个抽象方法。抽象方法用abstract关键字声明，其中不能有具体内容。 
     * 可以像声明普通类方法那样声明抽象方法，但是要以分号而不是方法体结束。也就是说抽象方法在抽象类中不能被实现，也就是没有函数体“{some codes}”。 
     */  
    abstract protected function abstract_func1();  
    abstract protected function abstract_func2();  
}  
abstract class B extends A  
{  
    public function abstract_func1()  
    {  
       echo "implement the abstract_func1 in class A/n";  
    }  
    /** 这么写在zend studio 8中会报错*/  
    //abstract protected function abstract_func2();  
}  
class C extends B  
{  
    public function abstract_func2()  
    {  
       echo "implement the abstract_func2 in class A/n";  
    }  
}

4． If you create a subclass B that inherits from A as follows, but does not implement the abstract method abstract_func():

Class B extends A{};

Then the program will have the following error:

Fatal error: Class B contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (A::abstract_func)

5． If B implements the abstract method abstract_func(), then the access control of the abstract_func() method in B cannot be stricter than the access control of abstract_func() in A, that is to say:

(1) If abstract_func in A () is declared as public, then the declaration of abstract_func() in B can only be public, not protected or private

(2) If abstract_func() in A is declared as protected, then the declaration of abstract_func() in B The declaration can be public or protected, but it cannot be private

(3) If abstract_func() in A is declared as private, hehe, it cannot be defined as private! (Fatal error: Abstract function A::abstract_func() cannot be declared private)

2. Interface interface

1． Abstract classes provide standards for concrete implementation, while interfaces are pure templates. Interfaces only define functions, not implementation content. Interfaces are declared with the keyword interface.

2 . Interface is completely abstract. It can only declare methods, and only public methods. Private and protected methods cannot be declared. Method bodies cannot be defined, and instance variables cannot be declared. However, interface can declare constant variables. But placing constant variables in interface violates the purpose of its existence as an interface, and also confuses the different values ​​​​of interface and classes. If you really need it, you can put it in the corresponding abstract class or Class.

interface iA  
{  
    const AVAR=3;  
    public function iAfunc1();  
    public function iAfunc2();  
}  
echo iA:: AVAR;

3． Any class that implements an interface must implement all methods defined in the interface

class E implements iA  
{  
    public function iAfunc1(){echo "in iAfunc1";}  
    public function iAfunc2(){echo "in iAfunc2";}  
}

abstract class E implements iA{}

Copy after login

interface iB  
{  
    public function iBfunc1();  
    public function iBfunc2();  
}  
class D extends A implements iA,iB  
{  
    public function abstract_func1()  
    {  
       echo "implement the abstract_func1 in class A/n";  
    }  
    public function abstract_func2()  
    {  
       echo "implement the abstract_func2 in class A/n";  
    }  
    public function iAfunc1(){echo "in iAfunc1";}  
    public function iAfunc2(){echo "in iAfunc2";}  
    public function iBfunc1(){echo "in iBfunc1";}  
    public function iBfunc2(){echo "in iBfunc2";}  
}  
   
class D extends B implements iA,iB  
{  
    public function abstract_func1()  
    {  
       parent::abstract_func1();  
       echo "override the abstract_func1 in class A/n";  
    }  
    public function abstract_func2()  
    {  
       echo "implement the abstract_func2 in class A/n";  
    }  
    public function iAfunc1(){echo "in iAfunc1";}  
    public function iAfunc2(){echo "in iAfunc2";}  
    public function iBfunc1(){echo "in iBfunc1";}  
    public function iBfunc2(){echo "in iBfunc2";}  
}

Copy after login

interface iC extends iA,iB{}  
class F implements iC  
{  
    public function iAfunc1(){echo "in iAfunc1";}  
    public function iAfunc2(){echo "in iAfunc2";}  
    public function iBfunc1(){echo "in iBfunc1";}  
    public function iBfunc2(){echo "in iBfunc2";}  
}

Copy after login
1. 3. Similarities and differences between abstract classes and interfaces
   1. Similarities ：
   (1) Both are abstract classes and cannot be instantiated.
   (2) Both the interface implementation class and the subclasses of abstract class must implement the declared abstract methods.
   2. Differences:
   (1) Interface needs to be implemented, using implements, while abstract class needs to be inherited, using extends.
   (2) A class can implement multiple interfaces, but a class can only inherit one abstract class.
   (3) Interface emphasizes the implementation of specific functions, while abstract class emphasizes the ownership relationship.

   (4) Although both interface implementation classes and abstract class subclasses must implement corresponding abstract methods, the implementation forms are different. Every method in interface is an abstract method, which is only declared (declaration, no method body), and the implementation class must implement it. Subclasses of abstract class can be implemented selectively. This choice has two implications: a) Not all methods in abstract class are abstract. Only those methods with abstract are abstract and must be implemented by subclasses. For those methods without abstract, the method body must be defined in abstract class; b) When a subclass of abstract class inherits it, it can directly inherit or override non-abstract methods; for abstract methods, it can choose to implement or This can be left to its subclasses to implement, but this class must also be declared abstract. Since it is an abstract class, of course it cannot be instantiated.

   (5) Abstract class is the intermediary between interface and class. abstract class plays a connecting role in interface and class. On the one hand, abstract class is abstract and can declare abstract methods to standardize the functions that subclasses must implement; on the other hand, it can define default method bodies for direct use or override by subclasses. In addition, it can define its own instance variables for use by subclasses through inheritance.

   (6) The abstract keyword cannot be added before the abstract method in the interface. The abstract method is implicit by default, and the final keyword cannot be added to prevent the inheritance of abstract methods. In an abstract class, abstract must be added before the abstract method to indicate that it is explicitly declared as an abstract method.

   (7) Abstract methods in interfaces are public by default and can only be public. They cannot be modified with private or protected modifiers. Abstract methods in abstract classes can be modified with public and protected, but cannot be modified with private.

   3. Application occasions of interface

   (1) Classes need specific interfaces for coordination, regardless of how they are implemented.

   (2) It exists as an identifier that can implement a specific function, or it can be a pure identifier without any interface methods.

   (3) It is necessary to treat a group of classes as a single class, and the caller only contacts this group of classes through the interface.

   (4) It is necessary to implement multiple specific functions, and these functions may have no connection at all.

   4. Application occasions of abstract class

   In a word, you can use it when you need both a unified interface and instance variables or default methods. The most common ones are:

   (1) Define a set of interfaces, but do not want to force each implementation class to implement all interfaces. You can use abstract class to define a set of method bodies, or even empty method bodies, and then let subclasses choose the methods they are interested in to cover.

   (2) In some cases, pure interfaces alone cannot satisfy the coordination between classes. Variables representing states in the class are also required to distinguish different relationships. The intermediary role of abstract can satisfy this very well.

   (3) It specifies a set of mutually coordinated methods, some of which are common, independent of state, and can be shared without the need for subclasses to implement them separately; while other methods require each subclass to implement them according to own specific state to achieve specific functions.

   Related recommendations:

   Summary of abstract classes and interfaces

   PHP design pattern 2: abstract classes and interfaces

   The difference between php abstract classes and interfaces

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