Real World Examples of Advanced OOP Features for PHP

I am trying to improve my knowledge of OOP in PHP and have been researching abstract classes and interfaces.

What I have learned

• They are both classes that cannot be instantiated themselves but can olny be extended (implemented in the case of interfaces)
• Abstract classes provide methods and properties for other classes that extend them.
• If a class uses an abstract method then the class itself must also be abstract.
• If an abstract method is defined within an abstract class, all child classes must define the details of that method. Methods not defined as abstract can be used in the same way as normal methods.
• Interfaces define what methods a class that implements it must have. The functionality of the methods are not defined in the interface, the interface just offers a list of methods that must be included in the child class.
• An interface does not define any properties.
• Classes can implement as many interfaces as they want to but they must define a method for every one of the interfaces they implement

I think that covers the basics. Please feel free to add to that if you think there's anything I have missed.

What I would like to know is if there are any real world examples of implementation of these classes, especially the interface class. Does anyone know of any open source applications that use them that I can browse to better understand them and开发者_如何学运维 see where and when they are used effectively? I have come across book examples which use animals which fails to demonstrate the importance of these classes.

The final keyword prevents the class being extended by other classes, example:

class Parent
{
}

class Mother extends Parent
{
}

final class Brother extends Mother /* - This class cannot be extended - */
{
}

class Pet extends Brother
{
}

The Pet class will throw an error stating: Fatal error: Class Pet may not inherit from final class (Brother)

This is also available for methods, so if you do not want to allow the methods to be inherited causing the child class to have the same method acting as an override.

http://php.net/manual/en/language.oop5.final.php

Yo used that you would like some real world examples of what interfaces can be used for, well a database abstraction layer

You have 1 base class which provides the basic methods to iterate your database data, but that would use a sub class for the the database type, such as MySql,MsSql etc, each database type would have its own class, but for the base class to make sure that it has these methods they would all implement the same interface.

Example

interface IDatabaseLayer
{
    public function connect();
    public function query();
    public function sanitize();
    //...
}

So the base class knows that MySql and MsSql have the above methods, thus reducing errors and being more organized.

When passing in objects to classes you want to be sure that the Object is of a certain type, PHP5 allows you to define what type of object should be passed into the methods as params.

lets say you have 3 classes

• DatabaseCredentials
• DatabaseConnection
• DatabaseQuery

you can specifically define in the constructuin of DatabaseConnection that you require a DatabaseCredentials class like so:

class DatabaseConnection implements Connectable
{
    public function __construct(DatabaseCredentials $ConnectionDetails)
    {
        $this->Connect($ConnectionDetails->BuildDSN());
    }
}

A good way to really get started is by reading here:

• http://php.net/manual/en/language.oop5.php

Another feature of PHP5 you may wish to look at is name spaces, this will allow you to keep your code organized, have multiple objects with the same name, makes auto loading more efficiently

Small Example:

namespace Database\MySql
{
    class Database{}
}

namespace Database\MsSql
{
    class Database{}
}

And you can just use like:

use Database;
$Database = new MySql\Database();

PHP comes with few interfaces predefinded by default: http://www.php.net/manual/en/reserved.interfaces.php

PHP also contains Standard PHP Library (SPL), which defines more:

• interfaces http://www.php.net/manual/en/spl.interfaces.php
• classes, including abstract ones: http://www.php.net/manual/en/spl.datastructures.php

Zend Framework is also very good example where such concepts are used. http://framework.zend.com/

Not a real world example as such, but one Design Pattern where you usually encounter interfaces and abstract classes is the Command Pattern. See link for example code.

In general, "programming against an interface" is considered good OO practise, because it decouples concrete implementations and let you more easily change them for other implementations, e.g. instead of asking for a specific class

public function fn(ConcreteClass $obj)
{
    $obj->doSomething()
}

you just ask that it provides a certain set of methods

public function fn(MyInterface $obj)
{
    $obj->doSomething()
}

Interfaces also help teasing apart large inheritance structures. Because PHP supports only Single Inheritance, you'll often see hierarchies like this:

BaseClass -> Logger -> Auth -> User

where each of these contains specific aspects used inside these classes. With an interface, you just do

User implements Loggable, Authenticable

and then include that specific code via Strategy Patterns or Composition/Aggregation, which is ultimately much more maintainable.

For a list of predefined interfaces in PHP see my answer to:

• where to find "template" interfaces?.

You may follow the "PHP patterns" series by Giorgio Sironi in dzone or directly in his blog, really interesting if you are interested patterns and OOP.

Also you could take a look to the Best PHP programming book in stackoverflow if you're in need of a good PHP book.

We can say that interface is purely 100% abstract class but abstract is not. Because many time we defines function in abstract class. But in interface class we always declare function.