In php, there is a interface type, so we can define a basic Animal type to print is name, so that any animal that is derived from this interface will have to implement at least the print name function, here is the interface

interface Animal
{
  public function printName();
}

it is very similar to a class structure apart from there is no functional code, just the function definition. To then implement the interface Animal within a class, so that you will know that the printName() function will be implemented you use the “implements” keyword in the class definition as below.

class Cat implements Animal
{....

and then the class Cat will have to define the printName function as

  public function printName()
  {
     echo "Cat class\n";
  }

otherwise if you did not implement it there would be a error on the “compile time” as below.

Fatal error: Class Cat contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Animal::printName)

here is a full code that will do a Cat and Dog class, then you can create a array of different derived Animals interfaces and then just call the printName and you know it will be present.

<?php
interface Animal
{
  public function printName();
}
 
class Cat implements Animal
{
      public function printName()
      {
	echo "Cat class\n";
      }
};
 
class Dog implements Animal 
{
      public function printName()
      {
	echo "Dog class\n";
      }
};
 
$animals = Array(
    new Cat(), new Dog()
    );
 
foreach ($animals as $a)
{
    $a->printName();
}
 
?>

and the output would be

Cat class
Dog class

Polymorphism is great, because you just know that certain functions will be implemented.

In C++ a virtual function would be

virtual void printName() = 0;

the = 0 means to set the virtual function to point to nothing (pure virtual function).

You could put some code within {} and still call it a virtual function, but that is taking away from the interface idea. (Java,C# and PHP use the interface structures)

In the code below, I have a const string (constant string) and as we know a constant string cannot be altered so to define this string when the constructor is called you place the variable name after the constructor and set it up to the constant value, e.g..

class Shape
{
     const string name;
      // constructor
     Shape(const string& constructorName) : name(constructorName) {};
}

This will setup the constant string when the Shape class has been created on the heap (memory allocation).

To call a parent class, Shape in this instance, constructor you just do something very similar to the setting of the constant string, you place it after the constructor in the subclass and put the parent class that you want to call its constructor after the “:” as

class Rectangle 
{
      Rectangle(const string& constructorName) : Shape(constructorName) {}
}

you can place more code into the {} for the Rectangle constructor still, but the “Shape(constructorName) is calling the parent class “Shape” constructor.

If you do not define the virtual pure function within the derived class, when you try to compile the error would be something similar to

poly.cpp:46: error: cannot allocate an object of abstract type ‘Circle’
poly.cpp:21: note:   because the following virtual functions are pure within ‘Circle’:
poly.cpp:11: note:      virtual void Shape::printName()

Because the Circle was not implementing what the parent class has defined as a pure virtual function.

In the code below I have placed some error values if you do not put “public” in the same places. These are typical errors that come from access to the objects internals that you are trying to access.

#include <iostream>
#include <string>
 
using namespace std;
 
class Shape 
{
  public:
      Shape(const string& conName) : name(conName) {}; 
      // create a virtual function so that it is implemented in the subclass
      virtual void printName() = 0;
 
  // protected, so it does not allow direct access, but subclasses can access it.
  protected:
      const string name;
};
 
// need to be "public Shape" otherwise
// error: ‘Shape’ is an inaccessible base of ‘Circle’
// it will not allow access to the Shape class.
class Circle : public Shape
{
  // you need to specify public for Cat to access Animal string name because that is protected
  public :
      Circle (const string& conName) : Shape(conName) {};
      void printName()
      {
	  cout << name << " class" << endl;
      }
};
 
class Rectangle: public Shape
{
  // you need to specify public for Dog to access Animal string name because that is protected
  // error: ‘Rectangle::Rectangle(const std::string&)’ is private
  public: 
      Rectangle(const string& conName) : Shape(conName) {};
      void printName()
      {
	  cout << name << " class" << endl;
      }
};
 
int main()
{
    Shape* shapes[2];
    shapes[0] = new Circle("Cirlce");
    shapes[1] = new Rectangle("Rectangle");
 
    for (int i =0; i < 2 ; i++)
    {
      shapes[i]->printName();
      // clean up the memory space.
      delete(shapes[i]);
    }
    return 0;
}

and here is the output

Cirlce class
Rectangle class

So in the example code above, the polymorphism is when for example the Rectangle class is defining the “interface” code for printName method.