Shulou(Shulou.com)06/03 Report--

This article introduces the relevant knowledge of "the concept and usage of abstract classes and interfaces of PHP classes and objects". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Classes and objects: abstract classes, interfaces

Abstract classes and interfaces: abstract classes (Abstract Class) and interfaces (Interface) are special classes that cannot be instantiated.

Abstract classes:

Abstract methods in abstract classes are empty methods without concrete implementation. Abstract classes can be used to set functional definitions for subclasses, so abstract classes force developers to only from specific parent classes

To inherit, and then complete the required specific functionality in the inherited subclasses.

The syntax format for defining an abstract class is as follows:

Abstract class class name {/ / list of member variables of abstract class abstract function member method 1 ([parameter 1], [parameter 2],...) ; abstract function member method 2 ([parameter 1], [parameter 2],...) ; / / other codes}

Like ordinary classes, abstract classes also have member properties and member methods, except that abstract classes cannot be instantiated.

Let's define a simple, complete abstract class:

Abstract class MyClass {/ / define abstract class abstract protected function myFunction ($arg); / / define abstract methods}

PS: the definition of an abstract class must contain at least one abstract method that is decorated with the keyword abstract and has no implementation.

The implementation of an abstract class:

In an abstract class, you can not only define abstract methods, but also, like ordinary classes, define some member methods that can perform specified functions. When subclasses inherit abstract classes, you can

Refer directly to these member methods that can perform the specified function.

Class subclass name extends abstract class name {/ / list of member variables of subclass function abstract method name ([parameter 1], [parameter 2],...) {/ / concrete implementation of abstract methods} / / other code}

PS: when a class inherits from an abstract class, it must include all the methods defined in that abstract class, otherwise it will make an error at run time.

Here is an example of implementing an abstract class:

Abstract class Study {abstract function printStudy ($name,$lang); / / define an abstract method} class OneStudy extends Study {/ / define a concrete implementation of the subclass inheriting from the parent class function printStudy ($name,$lang) {/ / abstract method echo $name. "sorting out". $lang. "." ;} class TwoStudy extends Study {function printStudy ($name,$lang) {echo $name. "sorting out". $lang. "." ;} $first=new OneStudy (); $first- > printStudy ("Soldier", "PHP Basics"); echo ""; $second=new TwoStudy (); $second- > printStudy ("Little Bing", "SEO Basics")

The running result of the program is:

The soldier is sorting out the basics of PHP.

Xiao Bing is sorting out the basic knowledge of SEO.

Define the interface:

An interface is a collection of member method declarations that contains only some empty member methods or class constants that will be implemented by the class that implements the interface.

The keyword interface is required to define the interface. The syntax format is as follows:

Interface interface name {/ / class constant list function member method 1 ([parameter 1], [parameter 2], …) ; function member method 2 ([parameter 1], [parameter 2],...) ; / / other codes}

Because the interface cannot be instantiated, there are no constructors and destructors for the interface, it only needs to give a declaration of a set of member methods to be implemented.

The following defines a simple and complete interface:

Interface class MyClass {/ / define interface public function myFunction ($arg); / / define method}

The implementation process of the interface:

Like classes, interfaces can inherit. An interface can inherit multiple interfaces, but an interface cannot inherit a class. To implement the interface, use the keyword implements.

When using a class to implement an interface, you must include at least all the methods defined in the interface, otherwise an error will occur at run time.

Here is an example of implementing an interface:

Interface IName {/ / define interface IName function setName ($name); function getName ();} interface IAge {/ / define interface IAge function setAge ($age); function getAge ();} class DaBing implements IName,IAge {/ / define private $name; private $age; function setName ($name) {$this- > name=$name;} function getName () {echo "name:". $this- > name. "" } function setAge ($age) {$this- > age=$age;} function getAge () {echo "Age:". $this- > age;}} $obj=new DaBing (); $obj- > setName ("soldier"); $obj- > getName (); $obj- > setAge (25); $obj- > getAge ()

The running result of the program is:

Name: soldier Age: 25

The difference between abstract classes and interfaces:

The use of the interface is achieved through the keyword implements. Operations on abstract classes are achieved by inheriting the keyword extends.

Interfaces have no data members, but abstract classes have data members, and abstract classes can achieve data closure.

Interfaces do not have constructors, and abstract classes can have constructors.

Methods in interfaces are of type public, while methods in abstract classes can be decorated with private, protected, or public.

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

There can be no implementation code for member methods in the interface, and there can be implementation code for member methods in abstract classes.

PS: in an application, if you need to add more behaviors to a class, you can define an interface to combine these behaviors. If you need to reuse the data and behavior of something, you should define an abstract class that encapsulates these variables and functions.

This is the end of the introduction to the concept and usage of abstract classes and interfaces for PHP classes and objects. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.