PHP OPP and patterns (1)_PHP tutorial

PHP Advanced Programming Study Notes 2014.06.09

This article will introduce abstract classes, interfaces, and a technique called contractual programming. Using these OPP mechanisms, the code you write is not limited to calculating or outputting content. These mechanisms can define the rules of interaction between classes at a conceptual level, and also provide a basis for application extension and customization.

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, if at least one method in it is declared as abstract, then this class must be declared as 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:

<span>public</span> <span>function</span> prototypeName(<span>$protoParam</span>)

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 as in the parent class (Or looser).

1.2 About abstract classes

1.3 Using abstract classes

<?<span>php
</span><span>abstract</span> <span>class</span><span> Car
{    
    </span><span>abstract</span> <span>function</span><span> getMaxSpeend();
}

</span><span>class</span><span> Roadster extends Car
{
    </span><span>public</span> <span>$Speend</span><span>;

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

</span><span>class</span><span> Street
{
    </span><span>public</span> <span>$Cars</span><span> ;
    </span><span>public</span> <span>$SpeendLimit</span><span> ;

    </span><span>function</span> __construct( <span>$speendLimit</span> = 200<span>)
    {
        </span><span>$this</span> -> SpeendLimit = <span>$speendLimit</span><span>;
        </span><span>$this</span> -> Cars = <span>array</span><span>();
    }
    
    </span><span>protected</span> <span>function</span> IsStreetLegal(<span>$car</span><span>)
    {
        </span><span>if</span> (<span>$car</span>->getMaxSpeend() < <span>$this</span> -><span> SpeendLimit)
        {
            </span><span>return</span> <span>true</span><span>;
        }
        </span><span>else</span><span>
        {
            </span><span>return</span> <span>false</span><span>;
        }
    }

    </span><span>public</span> <span>function</span> AddCar(<span>$car</span><span>)
    {
        </span><span>if</span>(<span>$this</span>->IsStreetLegal(<span>$car</span><span>))
        {
            </span><span>echo</span> 'The Car was allowed on the road.'<span>;
            </span><span>$this</span>->Cars[] = <span>$car</span><span>;
        }
        </span><span>else</span><span>
        {
            </span><span>echo</span> 'The Car is too fast and was not allowed on the road.'<span>;
        }
    }
}

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

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

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

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

<?<span>php
</span><span>abstract</span> <span>class</span><span> Car
{    
    </span><span>abstract</span> <span>function</span> SetSpeend(<span>$speend</span> = 0<span>);
}

</span><span>interface</span><span> ISpeendInfo
{
    </span><span>function</span><span> GetMaxSpeend();
}

</span><span>class</span> Roadster <span>extends</span> Car <span>implements</span><span> ISpeendInfo
{

    </span><span>public</span> <span>$Speend</span><span>;

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

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

</span><span>class</span><span> Street
{

    </span><span>public</span> <span>$Cars</span><span> ;
    </span><span>public</span> <span>$SpeendLimit</span><span> ;

    </span><span>function</span> __construct( <span>$speendLimit</span> = 200<span>)
    {
        </span><span>$this</span> -> SpeendLimit = <span>$speendLimit</span><span>;
        </span><span>$this</span> -> Cars = <span>array</span><span>();
    }

    </span><span>protected</span> <span>function</span> IsStreetLegal(<span>$car</span><span>)
    {
        </span><span>if</span> (<span>$car</span>->getMaxSpeend() < <span>$this</span> -><span> SpeendLimit)
        {
            </span><span>return</span> <span>true</span><span>;
        }
        </span><span>else</span><span>
        {
            </span><span>return</span> <span>false</span><span>;
        }
    }

    </span><span>public</span> <span>function</span> AddCar(<span>$car</span><span>)
    {
        </span><span>if</span>(<span>$this</span>->IsStreetLegal(<span>$car</span><span>))
        {
            </span><span>echo</span> 'The Car was allowed on the road.'<span>;
            </span><span>$this</span>->Cars[] = <span>$car</span><span>;
        }
        </span><span>else</span><span>
        {
            </span><span>echo</span> 'The Car is too fast and was not allowed on the road.'<span>;
        }
    }
}


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

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

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

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.

<span>echo</span> <span>$Porsche911</span><span> instanceof Car;
</span><span>//</span><span>result：1</span>

<span>echo</span> <span>$Porsche911</span><span> instanceof ISpeendInfo;
</span><span>//</span><span>result：1</span>

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/780762.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/780762.htmlTechArticlePHP Advanced Programming Study Notes 2014.06.09 This article will introduce abstract classes, interfaces and a method called contract programming technology. Using these OPP mechanisms, the code you write is not limited to just counting...