Abstract classes, object interfaces, instanceof and contract programming tutorials in PHP object-oriented

Object-oriented programming (OOP) is a computer programming architecture. One of the basic principles of OOP is that a computer program is composed of a single unit or object that can function as a subroutine. OOP achieves the three main goals of software engineering: reusability, flexibility, and scalability. In order to realize the overall operation, each object can receive information, process data and send information to other objects. 1.

Abstract classes in PHP

PHP 5 supports abstract classes and abstract methods. Classes defined as abstract cannot be instantiated. 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 its declaration.

It can be understood that an abstract class serves as a base class and leaves specific details to its successors. By abstracting concepts, you can create highly scalable architectures in your development projects.

abstract class AbstractClass
{
    code...
}

1.1. Abstract method

Use abstract keyword to define abstract method. Abstract methods only retain the method prototype (the signature after the method body is removed from the method definition), which includes access levels, function keywords, function names and parameters. It does not contain ({}) or any code inside brackets. For example, the following code is an abstract method definition:

abstract 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 Same as in parent class (or more relaxed). In addition, the method calling methods must match, that is, the type and number of required parameters must be consistent. 1.2. About abstract classes

As long as a class contains at least one abstract method, it must be declared as an abstract class

Methods declared as abstract must contain the same or Lower access level.

You cannot use the new keyword to create an instance of an abstract class.
Methods declared as abstract cannot contain function bodies.
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. Use abstract classes

<?php
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 -> SpeendLimit = $speendLimit;
        $this -> Cars = array();
    }
    protected function IsStreetLegal($car)
    {
        if ($car->getMaxSpeend() < $this -> SpeendLimit)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    public function AddCar($car)
    {
        if($this->IsStreetLegal($car))
        {
            echo &#39;The Car was allowed on the road.&#39;;
            $this->Cars[] = $car;
        }
        else
        {
            echo &#39;The Car is too fast and was not allowed on the road.&#39;;
        }
    }
}
$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 interfaceUsing interface (interface), you can specify which methods a class must implement, but you do not need to define the specifics of these methods. content.

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 the 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 Interface implementation (implements)

To implement an interface, use the implements operator (inheriting an abstract class requires using different extends keywords), and the class must implement all methods defined in the interface. Otherwise, a fatal error will be reported. A class can implement multiple interfaces. Use commas to separate the names of multiple interfaces.

When implementing multiple interfaces, methods in the interfaces cannot have the same name.

Interfaces can also be inherited by using the extends operator.

To implement an interface, a class must use the method that is exactly the same as the method defined in the interface. Otherwise a fatal error will result.
Constants can also be defined in the interface. Interface constants are used exactly the same as class constants, but cannot be overridden by subclasses or subinterfaces.
2.2 Cases of using interfaces

<?php
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 -> SpeendLimit = $speendLimit;
        $this -> Cars = array();
    }
    protected function IsStreetLegal($car)
    {
        if ($car->getMaxSpeend() < $this -> SpeendLimit)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    public function AddCar($car)
    {
        if($this->IsStreetLegal($car))
        {
            echo &#39;The Car was allowed on the road.&#39;;
            $this->Cars[] = $car;
        }
        else
        {
            echo &#39;The Car is too fast and was not allowed on the road.&#39;;
        }
    }
}
$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,

Type operator instanceof instanceof operator is a comparison operator in PHP5 . It accepts left and right parameters and returns a boolean value.

Determine whether a PHP variable belongs to an instance of a certain class CLASS

Check whether the object inherits from a certain type

Check whether the object belongs to an instance of a certain class
Determine whether a variable is Not an instance of an object that implements an interface

echo $Porsche911 instanceof Car;
//result：1
echo $Porsche911 instanceof ISpeendInfo;
//result：1

4.Contract Programming

Design by Contract or Design by Contract (DbC) is a design computer software Methods. This method requires software designers to define formal, precise and verifiable interfaces for software components. In this way, a priori conditions, a posteriori conditions and invariants are added to the traditional abstract

data types

. The "contract" or "contract" used in the name of this method is a metaphor because it is somewhat similar to the situation of a business contract.

A programming practice of implementing 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 implements the 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.

The above is the detailed content of Abstract classes, object interfaces, instanceof and contract programming tutorials in PHP object-oriented. For more information, please follow other related articles on the PHP Chinese website!