Introduction to PHP OPP mechanisms and patterns (abstract classes, interfaces and contract programming)_PHP tutorial

1. Abstract class

In the abstract class mechanism, a common base class is always defined, leaving specific details to the inheritors. By abstracting concepts, you can create scalable architectures in your development projects. Any class must be declared abstract if at least one method in it is declared abstract. A method defined as abstract only declares its calling method (parameters) and cannot define its specific function implementation. A class can be declared abstract by using the abstract modifier in the class declaration.

1.1 Method prototype (prototype)

refers to the signature after removing the method body from the definition of the method. It includes access levels, function keywords, function names, and parameters. It does not contain ({}) or any code inside parentheses. For example, the following code is a method prototype:

Copy code The code is as follows:

public function prototypeName($protoParam)

When inheriting an abstract class, the subclass must define all abstract methods in the parent class; in addition, the access control of these methods must be the same (or more relaxed) as in the parent class.

1.2 About abstract classes

A class must be declared as an abstract class as long as it contains at least one abstract method
Methods declared as abstract must contain the same or lower access level when implemented.
You cannot use the new keyword to create an instance of an abstract class.
A method declared as abstract cannot contain a function body.
If the extended class is also declared as an abstract class, you do not need to implement all abstract methods when extending the abstract class. (If a class inherits from an abstract class, it must also be declared abstract when it does not implement all abstract methods declared in the base class.)

1.3 Using abstract classes

Copy code The code is as follows:

abstract class Car
{ 
  abstract function getMaxSpeend();
}

class Roadster extends Car
{
public $Speend;

public function SetSpeend($speend = 0)
{
$this->Speend = $speend;
}
public function getMaxSpeend()
{
return $ this->Speend;
}
}

class Street
{
public $Cars ;
public $SpeendLimit ;

function __construct( $speendLimit = 200)
{
$this -> SpeedLimit = $speendLimit;
$this -> Cars = array();
}

protected function IsStreetLegal($car)
{
if ($car->getMaxSpeend() < $this -> SpeedLimit)
{
return true;
}
                                                                                                                                                                                                                                                                                                  
public function AddCar($car)
{
if($this->IsStreetLegal($car))
{

echo 'The Car was allowed on the road.';

           $this->Cars[] = $car;
                                                                                                                                        }
}
}

$Porsche911 = new Roadster();
$Porsche911->SetSpeend(340);

$FuWaiStreet = new Street(80);
$FuWaiStreet->AddCar($Porsche911);

/**
 *

 * @result

 *
 * The Car is too fast and was not allowed on the road.[Finished in 0.1s]

 *

 */
?>

2. Object interface

Using an interface, you can specify which methods a class must implement, but you do not need to define the specific content of these methods.

The interface is defined through the interface keyword, just like defining a standard class, but all methods defined in it are empty.

All methods defined in the interface must be public. This is a characteristic of the interface.

An interface is a class-like structure that can be used to declare the methods that must be declared to implement a class. For example, interfaces are often used to declare an API without defining how to implement the API.

Most developers choose to prefix the interface name with a capital letter I to distinguish it from the class in code and generated documentation.

2.1 Usage interface

Unlike integrating abstract classes that require the extends keyword, implementing interfaces uses the implements keyword. A class can implement multiple interfaces. In this case, we need to separate them with commas. If a class is marked as implementing an interface but does not implement all of the interface's methods, an error will be thrown.

2.2 Cases of using interfaces

Copy code The code is as follows:

abstract class Car
{ 
  abstract function SetSpeend($speend = 0);
}

interface ISpeendInfo
{
function GetMaxSpeend();
}

class Roadster extends Car implements ISpeendInfo
{

public $Speend;

public function SetSpeend($speend = 0)
{
$this->Speend = $speend;
}

public function getMaxSpeend()
{
return $this->Speend;
}
}

class Street
{

public $Cars ;
public $SpeendLimit ;

function __construct( $speendLimit = 200)
{
$this -> SpeedLimit = $speendLimit;
$this -> Cars = array();
}

protected function IsStreetLegal($car)
{
if ($car->getMaxSpeend() < $this -> SpeedLimit)
{
return true;
}
                                              else
public function AddCar($car)
{
if($this->IsStreetLegal($car))
{

echo 'The Car was allowed on the road.';

           $this->Cars[] = $car;
                                                                                                                                        }
}
}


$Porsche911 = new Roadster();
$Porsche911->SetSpeend(340);

$FuWaiStreet = new Street(80);
$FuWaiStreet->AddCar($Porsche911);

/**

 *

 * @result
 *
 * The Car is too fast and was not allowed on the road.[Finished in 0.1s]

 *

 */
?>

3.instanceof operator

The instanceof operator is a comparison operator in PHP5. It accepts left and right parameters and returns a boolean value. This operator is used to determine whether an instance of an object is of a specific type, inherits from a type, or implements a specific interface of the class.

Copy code

The code is as follows:

echo $Porsche911 instanceof Car;

//result: 1

echo $Porsche911 instanceof ISpeendInfo;//result: 1

4. Contractual Programming

Contract programming refers to a programming practice that implements a declared interface before writing a class. This method is very useful in ensuring the encapsulation of classes. Using contract programming techniques, we can define the functionality of a view before creating an application, much like an architect draws a blueprint before building a building.

5. Summary

Abstract classes are classes declared using the abstract keyword. By marking a class as abstract, we can defer implementation of the declared methods. To declare a method as abstract, simply remove the method entity containing all curly braces and end the line of code where the method is declared with a semicolon.

Abstract classes cannot be instantiated directly, they must be inherited.

If a class inherits from an abstract class, it must also be declared abstract when it does not implement all abstract methods declared in the base class.

In an interface, we can declare a method prototype without a method body, which is very similar to an abstract class. The difference between them is that interfaces cannot declare any methods with method bodies; and the syntax they use is also different. In order to force uncovering rules on a class, we need to use the implements keyword instead of the extends keyword.

In some cases we need to determine whether a class is a type of a specific class, or whether it implements a specific interface. instanceof is suitable for this task. instanceof checks three things: whether the instance is of a specific type, whether the instance inherits from a specific type, and whether the instance or any of its ancestor classes implement a class-specific interface.

Some languages ​​have the ability to inherit from multiple classes, this is called multiple inheritance. PHP does not support multiple inheritance. The idea is that it provides the function of declaring multiple interfaces for a class.

Interfaces are useful for declaring rules that a class must follow. Contractual programming technology uses this feature to enhance encapsulation and optimize workflow.

http://www.bkjia.com/PHPjc/781037.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/781037.htmlTechArticle1. Abstract class The abstract class mechanism always defines a public base class, leaving specific details Leave it to the heirs to implement. Extensibility can be created in development projects through abstract concepts...