Is PHP strictly OOP?:

To answer this let's check several points:

1) Quoting the PHP documentation:

As of PHP 5, the object model has been rewritten to account for better performance and increased functionality. This was a major change from PHP 4. PHP 5 has a full object model.

According to the documentation, as of PHP 5, we have a full object model:

• Visibility: public, private and protected.
• Lessons
• objects and properties.
• Public and private methods.
• Definition of classes and static properties.
• Magic methods like:
  • __get()
  • __set()
  • __call()
  • __construct()

PHP POO ESTRICTO + 1;

2) Basics of OOP and its role in PHP:

In the OOP we can find characteristics that are fundamental to consider the language as OO, among them:

1) Abstraction

2) Inheritance

3) Encapsulation

3) Concealment

4) Polymorphism

5) Modularity

6) Garbage Collection

According to Lei, OOP theorists focused on the 3 main points (those in bold ) as the fundamentals of OOP.

Now, let's check if PHP meets the fundamentals:

Employing the fundamentals of OOP in PHP:

// Declarar la clase es *encapsulamiento*
// Al usar extends estamos usando "herencia"
Class Entidad extends EntidadMayor
{
    public $atributo;
    //Ocultar las funciones del exterior es *ocultamiento*
    public function obtenerAtributo(){
        return $this->atributo;
    };
}
// Al crear una instancia estamos *abstrayendo*
$objeto = new Entidad();
$objeto->atributo = "valor";
$objeto->obtenerAtributo();

The 3 fundamentals of OOP are fulfilled.

PHP POO ESTRICTO + 1;

3) Magic Methods VS Class Method

To access the properties of a class we have two methods, the classic method and the magic method:

Classic Method : In this method we define our owngettersandsetters:

Class Entidad
{
    public $atributo;
    public function obtenerAtributo() {
        return $this->atributo;
    }
    public function cambiarAtributo($dato) { 
        $this->atributo = $dato;
    }
}
$objeto = new Entidad();
$objeto->atributo = "valor";
$objeto->cambiarAtributo("nuevoValor");
$objeto->obtenerAtributo(); // nuevoValor

Magic Method : In this method we use the magic methods that PHP brings, such as__get()and__set():

Class Entidad
{
    public $atributo;
    public function __get($property) {
        if (property_exists($this, $property)) {
            return $this->$property;
        }
    }
    public function __set($property, $value) {
        if (property_exists($this, $property)) {
            $this->$property = $value;
        }
    }
}
$objeto = new Entidad();
$objeto->set($atributo,"valor");
$objeto->get($atributo); // valor

When do I use what kind of methods?:

The answer is found in the "Overloading" section of the official PHP documentation.

But first let's understand some basic concepts:

What is overload?:

In object-oriented programming , overloading refers to the possibility of having two or more functions with the same name but different functionality, that is, they perform different actions depending on the different number and/or Types of Parameters.

Is there then overloading in PHP? :

NO, let's remember that PHP is not typed:

$entero = 4; // Entero.
$entero = "4"; // String.
$string = array(); // Array.

Therefore, in PHP there is no overloading by parameter types.

Besides we cannot control the number of arguments that are passed to the function, for example Javascript, using arguments[], therefore there is no overloading by number of parameters.

But PHP does not get out of hand, since it creates : "Magic methods" and together with this an overload simulation . (some say this PHP property is misnamed)

Quoting: http://php.net/manual/en/language.oop5.overloading.php

Overloading in PHP provides the means to dynamically create properties and methods.

Overloading methods are invoked when interacting with properties or methods that have not been declared or are not visible in the active scope .

PHP's interpretation of "overloading" is different from that of most object-oriented languages. Overloading traditionally offers the ability to have multiple methods with the same name, but with a different type or number of parameters.

So if overloading doesn't exist in PHP: what role do magic methods play to simulate it?

What are magical methods?:

• They are functions that allow changing the internal functionality of classes through the implementation of certain methods.
• They are automatically called by PHP on certain events.
• So it allows us to execute code when these events occur.
• Thanks to its ability to modify classes, we now have the power to tailor received parameters, types, and the way a class operates, instances, and get/set methods.

We could then say that:

Magic methods were created to be able to simulate overloading. So such functions are not used to go against OOP fundamentals but to make PHP even more OOP-like, adapting its untyped language to the ability to check data types by modifying how the class's accessor methods interact .

NOTE: It should be noted that what we would do with these magic methods would be to be able to modify them to overshadow (shadowing) the default function they have inside the class.

Let's look at an example of overloading using a magic method:

<?php
class MiClase
{
    public function __construct()
    {

        // Almacenamos los argumentos ingresados.
        $parametros= func_get_args();

        // Retornamos el número de argumentos ingresados.
        $numeroParametros = func_num_args();

        // Creamos el constructor con el numero de parametros.
        $constructor ='__construct'.$numeroParametros;

        // Buscamos el metodo dentro de nuestra clase.
        if (method_exists($this,$constructor)) {
            call_user_func_array(array($this,$constructor),$parametros);
        }
    }
    public function __construct0() {
        echo "Cero argumento";
    }
    public function __construct1($x) {
        echo "Una argumento: $x";
    }
    public function __construct2($x, $y) {
        echo "Dos argumentos: $x y $y";
    }
}
$objeto0 = new MiClase("0"); // llamará a construct0
$objeto1 = new MiClase("1"); // llamará a construct1
$objeto2 = new MiClase("1","2"); // llamará a construct2

Using the magic method __construct(), we are overloading the constructor to react based on the passed parameters, calling the same method.

Now let's use another method for example __call():

What function does __call() have?

-Allows you to capture the invocation of non-existent methods.

• This method can be re-defined to meet the needs of the system or, as in this case, provide overloading.

• Taking advantage of this functionality we can control the function we are calling and redirect to the specific function we are referring to.

Let's look at an example:

class Ejemplo {

  // Ejecutaremos Prueba el CUAL NO EXISTE pero gracias a __call lo creamos verificando
  // que este exista en un array.
  // Call lo usamos con este formato: __call($nombreDelMetodo, $argumentos)

  function __call($nombreMetodo, $argumentos) {
    $metodosAceptados = array("Pruebas");
    if(!in_array($nombreMetodo, $metodosAceptados)) {
      echo "$nombreMetodo no existe en los métodos disponibles";
    }
    $numeroArgumentos = count($argumentos);
    if($numeroArgumentos == 0) {
      $this->Pruebas1();
    } else if($numeroArgumentos == 1) {
      $this->Pruebas2($argumentos[0]);
    } else if($numeroArgumentos == 2) {
      $this->Pruebas3($argumentos[0], $argumentos[1]);
    } else if($numeroArgumentos == 3) {
      $this->Pruebas4($argumentos[0], $argumentos[1], $argumentos[2]);
    } else {
      return false;
    }
  }
  function Pruebas1() {
    echo "Hola pasaste cero argumentos<br>";
  }
  function Pruebas2($nombre){
    echo "Hola $nombre, pasaste 1 argumento<br>";
  }
  function Pruebas3($primerNombre, $segundoNombre){
    echo "Hola $primerNombre $segundoNombre, pasaste dos argumentos<br>";
  }
  function Pruebas4($primerNombre, $segundoNombre, $edad){
    echo "Hola $primerNombre $segundoNombre, ya tienes $edad años, pasaste tres argumentos<br>";
  }
}
$objeto = new Ejemplo();
$objeto->Pruebas();
$objeto->Pruebas("John");
$objeto->Pruebas("John", "Smith");
$objeto->Pruebas("John", "Smith", 60);

In this example we overload our class with a different number of parameters and also a different type. In conclusion it is possible to overload (mock) in PHP.

PHP POO ESTRICTO + 1;

WAIT : Wouldn't Polymorphism then be the same as overloading? Why, if so, are you doing polymorphism and not overloading? :

NO , polymorphism refers to a set of methods with the same Name and the same Number of Parameters and Types , but that are defined in different Classes, previously we passed different data types.

Let's look at an example of polymorphism:

// Definimos las clases
class Poligono
{
    function calculo() {
        echo 'El area depende del tipo de polígono';
    }
}
class Cuadrado extends Poligono
{
    function calculo()  {
        echo 'area de un cuadrado : a=l*l<br>';
    }
}
class Rectangulo extends Poligono
{
    function calculo()  {
        echo 'area de un rectangulo : a=b*h<br>';
    }
}
class Triangulo extends Poligono
{
    function calculo()  {
        echo 'area de un triangulo : a=(b*h)/2<br>';
    }
}

// Definimos la funcion que hara la llamada polimórfica al método cuadrado
// Es decir adaptaremos la función definida a cualquiera de las clases.

// NOTA: En la definición de la función definimos el tipo parámetro que pasamos por referencia, esto no es obligatorio en PHP, pero nos ayuda a entender el concepto y así poder aplicarlo en otros lenguajes más estrictos.

// Pasamos un objeto de la clase Poligono
function area(Poligono $objeto) {
    $objeto->calculo();
}
// Creamos los objetos necesarios
$cuadrado = new Cuadrado;
$rectangulo = new Rectangulo;
$triangulo = new Triangulo;

// Ejecutamos la función encargada de realizar la llamada polimórfica
area($cuadrado);
area($rectangulo);
area($triangulo);

// La función `area()` nos muestra la fórmula correcta en cada una de sus ejecuciones para cada tipo de figura geometrica, sea este Cuadrado, Rectangulo, Triangulo, pese a que en su definicion inicial hayamos especificado que el objeto es del tipo "Poligono" haciendo referencia a la clase base de cada objeto. 

PHP POO ESTRICTO +1;

4) Our magical methods of interest:

__set()is executed when writing data to inaccessible properties.

__get()is used to query data from inaccessible properties.

Quoting the PHP overload documentation we find this:

Se invoca a los métodos de sobrecarga cuando se interactúa con propiedades o métodos que no se han declarado o que no son visibles en el ámbito activo.

Tenemos dos puntos de interés: Ámbito Activo y Propiedades Inaccesibles

Ambito activo:

El ámbito de una variable es el contexto dentro del que la variable está definida.

Propiedades innacesibles: Son aquellas propiedades que bien estan ocultas, o no estan definidas.

Citando lo anterior, como la sobrecarga usa los metodos magicos, y estos debes de poder acceder a propiedades innacesibles.

Se fundamenta la razón de ser métodos públicos, ya que, te deben permiten obtener valores que no están en tu ámbito, ademas de crearlos dinamicamente si NO existen, cumpliendo su rol, interactuar con métodos/propiedades innacesibles.

Veamos el ejemplo en una clase:

Class Entidad
{
    // defino $atributo como privado.
    private $atributo;
    public function obtenerAtributo() {
        return $this->atributo;
    }
    public function cambiarAtributo($dato) { 
        $this->atributo = $dato;
    }
}

$objeto = new Entidad();
$objeto->atributo = "valor";
$objeto->cambiarAtributo("nuevoValor");
$objeto->obtenerAtributo(); // nuevoValor
$objeto->otroAtributo = "valor";

En este caso al usar obtenerAtributo( ) o cambiarAtributo( ) estamos trabajando bajo atributos que están definidos dentro de la clase. Pero en el último llamado de otroAtributo estamos definiendo un valor que no existe.

Aqui entra el papel de __set y __get, los cuales nos permiten trabajar bajo propiedades o métodos inexistentes:

1) Si los quisiera redifinir para controlar como obtener y cambiar variables usaría:

public function __set($propiedad,$valor) {
            //
        }
public function __get($propiedad) {
            //
        }
public function __call($metodo, $argumentos) {
           //
}

2) Estos métodos nos permiten controlar el acceso o el cambio de propiedades.

3) No son sustitutos de los getters/setters, ya que, nos permiten trabajar en modos que de la forma clásica daría error, más que todo son para manejo de errores, ejemplo obteniendo/cambiando atributos que no existen, comparando con JavaScript podrían usarse como si quisiéramos evitar que se crearan objetos sin new.

4) Podría definirse a los métodos mágicos como los Object Watchers de Javascript, ya que estos crean propiedades inexistentes para funcionar, pero claro esta golpea en el rendimiento del código.

Entonces sabiendo cuando usarlos, ¿Cual es mas eficiente?

Ocurre un problema, son públicos y pueden acceder a mis propiedades privadas, ¿que hago?:

Como es fácil violar la encapsulación en PHP:

Veamos un ejemplo:

class Produccion
{
}
$objeto = new Produccion();
$objeto->hackeado = 'boom';

Tendremos dos soluciones:

1) Si trabajas con mas personas: Documentar.

2) Si no queremos documentar, para evitar usar dichos metodos, haremos lo siguiente, re-declarar los métodos mágicos:

class Produccion
{
    public function __set($name,$value){
        throw new Exception ('No');
    }
    public function __get($name){
        throw new Exception ('No de nuevo');
    }
    public function __call($name, $arguments) {
        throw new Exception ('Stop');
    }
}
$objeto = new Produccion();
$objeto->hackeado  = 'boom'; //  Uncaught Exception: No
$objeto->hackeado; //  Uncaught Exception: No de nuevo.
$objeto->hackeado(); //  Uncaught Exception: Stop.

A pesar de que estos métodos "crean" propiedades y métodos dinámicos, en ninguno de los casos funcionan como se esperaba porque los redefinimos, así podemos evitar esos posibles "fallos" de encapsulamiento.

¿Y si quiero utilizar mis propios metodos get/set?:

Sencillamente agregamos nuestros propios métodos privados:

    class Produccion
    {
    private $atributo = 4;
        public function __set($name,$value){
            throw new Exception ('No');
        }
        public function __get($name){
            throw new Exception ('No de nuevo');
        }
        public function __call($metodo, $argumentos) {
            $metodosAceptados = array("tus","metodos","get","set");
            if(!in_array($metodo, $metodosAceptados)) {
                 throw new Exception ('Stop');
        }
    }
    private function get(){
        return $this->atributo;
    }
    private function set($valor){
        return $this->atributo = $valor;
    }
}
$objeto = new Produccion();

// Si queremos usar el get y set privados totalmente, los des-habilitamos en el __call, para evitar que los llamen sino queremos que sea así
$objeto->get(); // 4
$objeto->set(60);
$objeto->get(); // 60

Entonces, podemos observar que aunque si pueden generar aberturas de seguridad en el encapsulamiento de PHP, podemos proteger las propiedades, por su misma capacidad de servir (los metodos magicos) como administradores de propiedades y metodos mas adaptables a las necesidades.

PHP POO ESTRICTO + 1;

En conclusión: PHP: SI ES POO ESTRICTO.

1) Cumple con los fundamentos de la POO:

• Herencia.

• Abstracción.

• Encapsulamiento.

2)Tiene los elementos básicos como son:

• Objetos, clases y métodos.

• Visibilidad privada, protegida y pública

• Metodos privados y públicos

• Puede emplear propiedades estáticas

• Sobrecargar sus métodos.

3) Puede ademas tener polimorfismo y sobrecarga (gracias a los métodos mágicos):

4) Tiene métodos mágicos con los que:

• Ampliar las capacidades de PHP como POO.

• Administrar los errores en PHP, y permiten redefinir las propiedades accesoras del objeto (aumentado así la encapsulación).

• Los métodos mágicos se pueden opacar (shadowing).

According to wikipedia the PHP paradigm is:

Multiparadigm: imperative, functional, object-oriented, procedural, reflective.

And the definition of the OOP paradigm is:

Object-oriented programming (POO, or OOP according to its acronym in English) is a programming paradigm that uses objects in their interactions, to design applications and computer programs. It is based on various techniques, including inheritance, cohesion, abstraction, polymorphism, coupling, and encapsulation.

Yes, you can do OOP in the strict sense of the word, but you also have to see that those of us who are starting out in OOP usually mix the different paradigms. Among my projects I continually find jumps between one paradigm and another, especially on small scales. When you work in C everything is imperative and easy to read, so sometimes you write code in Java or PHP following this paradigm. But actually if it is OO. The same thing happens to me in Python. Initially, it did not use its own classes, it did everything with functions, not to mention inheritance or abstraction.

Over time you gain more practice in one or another paradigm. In this case, it does not depend so much on PHP, but on how much you really know the paradigm and how much you know how to apply it. Although in the latter there will be those who differ.

UPDATE

On magical methods. In python everything can be overridden and accessed from anywhere. There are no private, nor public. They exist, but they are mentions about the format of the code. For example, a _VAR variable should not be accessed from outside the class. They are conventions that are reached. This is called concealment and it is one of the features of OOP. JAVA is very strict in this sense, because it is designed for teamwork. A leader, Jr developers, etc. Python no, it's freer. Trust the good practices of the programmer. And then PHP has its chores in these ideas. In any case, when you develop a project in OOP, the least you want is to have to access methods of other classes and override them. Create confusion. Personally, I am only interested in the get and set with the results that it describes. Accessing magic methods has some complications that I don't want.