Clases en PHP

Al sugerirte que pienses en conjuntos preescolares, en realidad estamos introduciendo, por así decirlo, el concepto de clase.

Las clases, en los lenguajes de programación en general, pero aquí en PHP, nos permiten, de hecho, hacer una clasificación de elementos que, en nuestra realidad, tienen características en común. No muy lejos de los conjuntos anteriores, ¿verdad?
Las características comunes, por lo tanto, aseguran que un elemento dado pertenezca a un conjunto y no a otro.
Piénsalo: vivimos todos los días, en nuestra cotidianidad, el concepto de clase y clasificación, cuando vamos a agrupar elementos teniendo en cuenta sus características más evidentes: en el armario guardaremos toda la ropa, en la nevera toda la comida y así sucesivamente.
Al imaginar un grupo de personas, por ejemplo, seguramente podremos encontrar elementos en común entre todos ellos: el nombre, el apellido o la edad, por mencionar algunos.

“Persona”, por tanto, podría convertirse en un excelente ejemplo para definir una clase; nombre, apellido y edad, por otra parte, representarán las características de una persona, comunes a todas las personas.

CLASES PHP: LA SINTAXIS

En el lenguaje PHP, una clase se define por la palabra clave class y su nombre, que, sin embargo, debe respetar ciertas reglas:

• Tiene que ser en inglés;
• Tiene que tener la letra mayúscula inicial;
• Tiene que estar en singular.

<?php
   class Person {}
?>

Veamos la anatomía de una clase.

Una clase, dentro de ella, se compone de tres partes principales:

• Los atributos o propriedad;
• Una función constructora;
• Los métodos o comportamientos.

ATRIBUTOS EN PHP

Los atributos son aquellas características que todos los miembros de esa clase tienen en común y se declaran al comienzo de la misma.
Decíamos anteriormente que cada persona se caracteriza por un nombre, un apellido y una edad. Traduciremos a un código como este:

<?php
   class Person {
     public $name;
     public $surname;
     public $age;
   }
?>

Como puedes ver, hemos especificado que cada objeto de la clase Persona tendrá ciertas características (o atributos).
Sin embargo, la clase, escrita de esta manera, está incompleta, ya que no tenemos la capacidad de crear objetos a partir de ella. Pero, ¿qué es un objeto?

Por objeto entendemos una instancia que pertenece a una clase específica, o un dato que durante la ejecución de un programa está presente en la memoria de nuestra PC como una entidad.
Es por esto que necesitamos una función particular conocida como función constructora, cuya tarea será tomar argumentos reales como entrada y asignarlos a la instancia que estamos creando.

Veámoslo en código:

<?php
   class Person {
     public $name;
     public $surname;
     public $age;

     public function __construct($name, $surname, $age){

       $this->name = $name;
       $this->surname = $surname;
       $this->age = $age;
     }
   }

   $persona = new Person(‘Giuseppe’, ‘Verdi’, 56);
?>

De esta forma, le hemos especificado a nuestro algoritmo cómo deben ir los datos de "Giuseppe" "Verdi" "56" para crear la instancia de la clase Person que guardaremos en $persona.
Analicemos, sin embargo, la función constructora:

• Su nombre necesariamente debe ser "__construct", de lo contrario no será reconocido como constructor. De hecho, esta función se llama cuando el algoritmo encuentra la nueva palabra clave emparejada con el nombre de una clase;

• Al ser una función, el constructor acepta parámetros de entrada, que recordamos como formales, que no serán más que nuestros atributos;

• Muy importante es la pseudovariable $ this que indica el objeto que vamos a crear. De hecho, nunca debemos olvidar que estamos creando, a través de la clase, una mera descripción y no un objeto real.

En pocas palabras, le estamos diciendo a la función que, del objeto de clase Person que vamos a crear, tendrá que capturar el argumento real recibido en el constructor y potenciar el atributo asignado.

Ahora podemos crear instancias ilimitadas de la clase Person, pero dicho objeto construido sigue siendo ineficaz.

Como se mencionó anteriormente, una clase también puede tener métodos o comportamientos relacionados con ella.

MÉTODOS O COMPORTAMIENTOS

Una persona realiza, en su vida diaria, una infinidad de acciones que podemos englobar y describir a través de lo que llamamos métodos o conductas.
Un ejemplo común es la capacidad de una persona para presentarse. Veamos cómo traducir este comportamiento en código:

<?php
   class Person {

      public $name;
      public $surname;
      public $age;

      public function __construct($name, $surname, $age){

         $this->name = $name;
         $this->surname = $surname;
         $this->age = $age;

      }

      public function presentati( ){

         echo “Hola, soy $this->name $this->surname y tengo $this->age años.\n”;

      }
   }

   $persona = new Person(‘Giuseppe’, ‘Verdi’, 56);

   $persona->presentate( );


   //Output
   //Hola, soy Giuseppe Verdi y tengo 56 años.
?>

La función presentada () es un método que permite que todas las instancias de la clase Person se presenten y muestren todos los valores relacionados con sus atributos. No es diferente de las funciones que presentamos en el capítulo dedicado.
Mira la sintaxis. ¿Qué notaste?

Usando la flecha, todo lo que hacemos es ingresar el objeto especificado ($ persona) y capturar lo que sigue (el método presentado (), en nuestro caso).
Este tipo de sintaxis nos permite acceder a todos los elementos de una instancia, ya sean métodos o atributos.

<?php
    class Person {

        //atributos

        public $name;
        public $surname;
        public $age;

        //constructor

        public function __construct($name, $surname, $age) {

            $this->name = $name;
            $this->surname = $surname;
            $this->age = $age;
        }

        //método

        public function presentati(){
            echo "Hola, soy $this->name $this->surname y tengo $this->age años.\n";
        }
    }

    $persona = new Person('Giuseppe','Verdi','56');

    echo $persona->name;


   //Output

   //Giuseppe

?>

También en este caso el uso de la pseudovariable $this hace referencia al objeto que vamos a crear, siempre por el mismo concepto que con la clase no creamos nada sino que solo vamos a describir algo.

ATRIBUTOS Y MÉTODOS ESTÁTICOS

Otros elementos muy utilizados en la programación orientada a objetos son aquellos métodos y atributos definidos como estáticos.
Por definición, los atributos y métodos estáticos no actúan en nombre de un objeto sino directamente en nombre de una clase. ¿Qué significa?
La definición nos dice que podemos llamar atributos y activar métodos sin necesariamente tener que instanciar un objeto específico cada vez.

Veamos un ejemplo:

<?php
    class Person {

        //atributos

        public $name;
        public $surname;
        public $age;

        //atributo estatico

        public static $counter=0;

        //constructor

        public function __construct($name, $surname, $age) {

            $this->name = $name;
            $this->surname = $surname;
            $this->age = $age;

        }

        //metodo

        public function presentate(){

            echo "Hola soy $this->name $this->surname y tengo $this->age años! \n";

        }
    }

    echo Person::$counter;

   //Output
   //0
?>

En el ejemplo hemos creado un atributo estático caracterizado por la palabra clave "static", seguido de la declaración de la variable a la que le hemos asignado un valor inicial de 0.

Creamos este contador con el objetivo de contar cuántos objetos de la clase Persona se habrán creado en un punto determinado de nuestro algoritmo.

Como notamos inmediatamente, en nuestro código, donde queremos mostrar el valor de la variable a través del comando php echo, ya no hemos usado la sintaxis del atributo $objeto-> sino directamente la clase Persona seguida del OPERADOR DE RESOLUCIÓN DE ALCANCE (::), un operador que te permite acceder a métodos o propiedades estáticas, constantes o sobrescritas de una clase.

En nuestro caso, este operador activará la búsqueda de la clase Persona y, dentro de ella, buscará un atributo estático, con nombre correspondiente al indicado, nuestro contador $.
¡Atención! Cuando queremos capturar un atributo estático, después del operador de resolución de alcance debemos usar necesariamente el $

Si iniciamos nuestro programa, veremos que nos da como resultado 0, que es exactamente el valor de $ contador.

Ahora intentemos incrementar este contador creando muchos objetos de la clase Person.
Siendo la función constructora la que "guía" la instanciación de un objeto, es dentro de ella donde tendremos que gestionar el incremento de $ contador.

<?php
    class Person {

        //atributos

        public $name;
        public $surname;
        public $age;

        //atributo estatico

        public static $counter=0;

        //constructor

        public function __construct($name, $surname, $age) {

            $this->name = $name;
            $this->surname = $surname;
            $this->age = $age;

            self::$counter++;
        }

        //metodo

        public function presentate(){

            echo "Hola soy $this->name $this->surname y tengo $this->age años! \n";

        }
    }

    $persona1 = new Person('Giuseppe','Verdi','56');
    $persona2 = new Person('Paolo','Rossi','48');
    $persona3 = new Person('Guglielmo','Bianchi','56');

 
    echo Person::$counter;

    //Output
    //3
?>

En el constructor, hemos insertado el incremento del contador, pero ya no usamos la pseudovariable "$ this" seguida de "->", sino una nueva palabra clave "self".

Si "$ this" se refiere al objeto que vamos a crear, la palabra clave "self" se refiere exactamente a la clase: por lo tanto, cada vez que se llame a la función constructora (a cada nueva Persona en mi algoritmo), diremos el class para recuperar su propio atributo de contador $ estático, aumentándolo en uno.

Si iniciamos el programa, el resultado será 3 que, efectivamente, es el número de objetos Person creados en nuestro algoritmo.
¿Qué pasaría si quisiéramos crear una función que muestre nuestro contador sin capturarlo directamente de la clase?
En ese caso, necesitaríamos un método estático:

<?php
    class Person {

        //atributos

        public $name;
        public $surname;
        public $age;

        //atributo estatico

        public static $counter=0;
 
        //constructor

        public function __construct($name, $surname, $age) {

            $this->name = $name;
            $this->surname = $surname;
            $this->age = $age;

            self::$counter++;

        }

        //metodo

        public function presentate(){

            echo "Hola, soy $this->name $this->surname y tengo $this->age años.\n";

        }

        //metodo estatico

        public static function showCounter(){

            echo self::$counter;

        }
    }

    $persona1 = new Person('Giuseppe','Verdi','56');
    $persona2 = new Person('Paolo','Rossi','48');
    $persona3 = new Person('Guglielmo','Bianchi','56');

    Person::showCounter();


    //Output
    //3

?>

Si ejecutamos nuestro programa, veremos el mismo resultado que en el ejemplo anterior pero, esta vez, hemos utilizado una metodología de escritura de código más elegante, que, sin embargo, esconde una razón real: pronto, de hecho, nos ocuparemos de los access modifiers o indicadores de accesibilidad.

Los modificadores de acceso gestionan la visibilidad de ciertos datos dentro de nuestro algoritmo: veremos que algunos se pueden hacer "privados" y, por lo tanto, invisibles si no se recuperan a través de un método, pero lo trataremos en la siguiente guía, en relación con la herencia. Stay tuned!