Rimorsoft Online
Blog Foro

Clases y Objetos en PHP


Las clases nos ayudan a definir una estructura manejable y entendible de nuestro sistema, este termino da vida a los que conocemos como programación orientada a objetos (POO en español, OOP en inglés). La teoría dice, "esto significa que tratas a tu código o partes de él como objetos de la vida real y esto podría resultar muy familiar para nosotros porque nos acerca al mundo tal y como lo conocemos". Aunque parece que esto siempre es confuso. Para entender, podríamos empezar con nuestra primera clase.

Clases en PHP

Podemos iniciar con código, definiendo un propósito y pensando en que éste archivo represente algo... Digamos a una persona, aunque pudiera ser un libro, fruta, email, etc. Llamaremos a nuestra clase Person.

<?php

/**
* this class represents a person
*/
class Person 
{
    
}
  • Solo para que puedas familiarizarte con la sintaxis, es bastante similar a una función. Todo su bloque o código está entre { llaves }
  • Todo comienza con la palabra reservada class y luego el nombre de la clase que queremos crear, en este caso Person
  • Lo correcto es crear un archivo solo para tu clase con el nombre de la clase, en este caso nuestro archivo se llamaría Person.php

Es una buena práctica nombrar a las clases con la primera letra en mayúsculas, esto se llama CamelCase y es un estilo de escritura que se aplica a frases o palabras compuestas. El nombre se debe a que las mayúsculas a lo largo de una palabra en CamelCase se asemejan a las jorobas de un camello.

De momento no podemos hacer nada con esta clase pero para que vaya tomando forma podemos crear propiedades. El objetivo de una propiedad es añadir características y en cada una de ellas almacenar datos. Ejemplo: Un libro puede tener título, una persona nombre, una fruta puede tener sabor, un email tiene un asunto y texto, y así...

Vamos a trabajar solo con nombre y apellido.

<?php

/**
* this class represents a person
*/
class Person 
{ 
    var $name;
    var $lastname;
}

Como puedes ver, las propiedades comienzan con la palabra var, en este caso son variables pero las variables de una clase se llaman propiedades. Aquí usaremos var, sin embargo, mas adelante en Rimorsoft conocerás todas las alternativas.

Hasta aquí terminamos con las clases, veamos el siguiente paso:

Instancias

Imagina a una clase como un plano o un molde... A partir de aquí nacen los objetos. Y quiero que solo aprendas esto, instanciar es crear un objeto a partir de una clase, para ello usamos la palabra reservada new. Veamos:

Archivo Person.php

<?php

/**
* this class represents a person
*/
class Person 
{
    var $name;
    var $lastname;
}

Archivo index.php

<?php

require 'Person.php';

$person = new Person;

Crear un objeto o crear una instancia es lo mismo y se logra usando la palabra new, toma en cuenta que esto sucede gracias a que ya contamos con la clase Person. En este ejemplo, nuestro objeto se llama $person... Ya el objeto vive, existe al escribir $person = new Person.

Lo interesante es que ya dentro de $person están disponibles las propiedades y podemos usarlas.

<?php

require 'Person.php';

$person = new Person;
$person->name;

Usar una propiedad solo consiste en hacer uso del operador de objeto ->, que es un guión - seguido por un mayor que > (forma una flechita hacia la derecha). Luego escribimos el nombre de la propiedad que deseamos usar, en este caso name y queda así $person->name;.

NOTA: De momento, al escribir $person->name; no verás nada en el navegador.

Hasta el momento solo sintaxis, aunque intento que sea fácil y ameno, quiero que estés con buena base para los cursos que vienen en el canal.

Método

En una clase, una función común y corriente se le llama método y es donde vamos a colocar nuestro código o lógica. Veamos como se define:

Archivo Person.php

<?php

/**
* this class represents a person
*/
class Person 
{
    var $name;
    var $lastname;
    
    function greet()
    {
        return 'Hola, cómo estás?';
    }
}

Archivo index.php

<?php

require 'Person.php';

$person = new Person;
echo $person->greet();

De nuevo usamos la palabra reservada function, pero en este caso para definir un método. Recuerda: Las funciones en nuestras clases se les llaman métodos, Aquí podemos ver que nuestro método se llama greet() y solo retorna un Hola, cómo estás?.

Al crear un objeto podemos ejecutar al método usando a nuestro operador "flechita" -> (este sirve para acceder a variables, asignar valor y acceder a métodos).

$this

Nuestra clase tiene propiedades y métodos, así que es muy probable que necesitemos acceder a ellas. Y si, están disponibles para nosotros, y podemos acceder a ellas usando al gran $this.

$this es una referencia a la instancia actual, si escribimos $this->name es como decir mi nombre. Su uso es para acceder a propiedades y métodos desde dentro de un método de la clase.

Archivo Person.php

<?php

/**
* this class represents a person
*/
class Person 
{
    var $name;
    var $lastname;
    
    function greet()
    {
        return "Hola, {$this->name} cómo estás?";
    }
}

Archivo index.php

<?php

require 'Person.php';

$person = new Person;
echo $person->greet();

La sección interesante de este apartado es return "Hola, {$this->name} cómo estás?"; de la clase Person, ahí vemos claramente la idea y el propósito de $this… Accedemos a la propiedad name desde el método greet().

En este caso no hay mucho sentido, si ejecutas el código no habrá un nombre impreso en pantalla. Pero avancemos, ya verás un nombre en pantalla.

En el método greet() usamos ahora comillas dobles y es porque en el texto hemos incluido una variable.

Constructor - Método especial __construct()

Un constructor forma parte de una serie de métodos especiales. Este se ejecuta al momento de crear una nueva instancia de la clase (al crear un objeto). Lo interesante es que podemos comenzar nuestro objeto con datos básicos, por ejemplo en Person podemos empezar dando de alta el nombre y apellido justo en el momento de instanciar. En otras palabras, es la gran oportunidad de establecer valores a las propiedades de la clase para que nuestra clase tenga con que trabajar.

Archivo Person.php

<?php

/**
* this class represents a person
*/
class Person 
{
    var $name;
    var $lastname;

    public function __construct($name, $lastname)
    {
        $this->name = $name;
        $this->lastname = $lastname;
    }
    
    function greet()
    {
        return "Hola, {$this->name} cómo estás?";
    }
}

Archivo index.php

<?php

require 'Person.php';

$person = new Person('Italo', 'Morales');
echo $person->greet();

Aquí toma en cuenta lo siguiente, usamos el método especial __construct() cuando necesitamos iniciar con algo de datos, ejemplo: La clase email necesita para enviar el mensaje un asunto, un remitente, un destinatario y un texto final... Entonces iniciamos esta clase con estos datos y luego procedemos a enviar el mensaje.

Aquí si veremos un nombre impreso en pantalla, porque lo hemos grabado en la clase justo en el momento en que creamos el objeto $person = new Person('Italo', 'Morales');

Varias instancias, (varios objetos, una clase)

Esto quiere decir, tener varios objetos a partir de una única clase, siguiendo con lo anterior, hablo de dos o mas personas.

Archivo index.php

<?php

require 'Person.php';

$client = new Person('Italo', 'Morales');
echo $client->greet();

$seller = new Person('Luisa', 'Fantone');
echo $seller->greet();

En este caso los objetos se llaman $client y $seller, cada uno es una persona y nacen a partir de la clase Person y eso es reutilización de código, puedes notar que hay una sola clase y dos objetos. ¡Esto es magía!.

Esto es lo que debemos conocer de las clases y objetos.

Resumen

  • Una clase es un molde
  • Un objeto es formado a partir de un molde (una clase)
  • La estructura de una clase es: Inicia con la palabra class, propiedades, constructor y métodos.

Herencia de clases - PHP

Esto lo entendemos mejor si nos vamos a un diccionario y buscamos la palabra heredar, hay muchas definiciones pero la que aplica es la siguiente: > Heredar: Recibir algo de una persona o circunstancia anterior.

Es eso simplemente (tu como hijo recibes, usas y hasta modificas lo que tu padre te deja), y el ejemplo que aquí haremos será con 4 archivos:

  • Index: El archivo a ejecutar cuando accedemos al navegador.
  • Person: Clase principal, también llamada clase madre.
  • Student: También es una persona, pero tiene la entidad o el rol de "Estudiante" (hija de Person).
  • Professor: Es otra persona al igual que Studen, pero tiene otro rol, es un "Profesor o líder de aula" (hija de Person).

Sintaxis extends

A través de un ejemplo veremos cómo desde un archivo podemos heredar y al mismo tiempo aprovechar lo que hemos heredado.

Archivo Person (clase madre)

<?php

/**
* this class represents a person
*/
class Person 
{
    var $name;
    var $lastname;

    function __construct($name, $lastname)
    {
        $this->name = $name;
        $this->lastname = $lastname;
    }

    function greet()
    {
        return "Hola, {$this->name} cómo estas?";
    }
}

Archivo Student (clase hija, heredera de Person)

<?php

/**
* this class represents a person (Student)
*/
class Student extends Person
{
    
}

Nota que no hay nada dentro de ella, pero al escribir extends Person decimos que hereda de Person y por ende cuenta con el método __construct(), propiedades y método greet().

Archivo Professor (clase hija, heredera de Person)

<?php

/**
* this class represents a person (Professor)
*/
class Professor extends Person
{    
    function greet()
    {
        return "Hola profesor {$this->name}, cómo está usted?";
    }
}

Al igual que Student, la clase Professor cuenta con todo lo que tiene su madre Person, pero en Professor hice un cambio... He sobrescrito el método greet(). Para saludar con mayor respeto a los profesores que usen el sistema.

Ahora vamos con el archivo que ejecuta todo esto y le da sentido a nuestro sistema, uso la palabra sentido porque llama y ejecuta en orden todo lo antes escrito.

Archivo Index (archivo principal)

<?php

require 'Person.php';
require 'Student.php';
require 'Professor.php';

$student = new Student('Luisa', 'Fantone');
echo $student->greet();

echo '<br>';

$professor = new Professor('Italo', 'Morales');
echo $professor->greet();

Y tenemos el siguiente flujo

Ciclo o flujo de trabajo

  • Se ejecuta el archivo index.php
  • Se incluyen las clases Person, Student y Professor (en ese orden porque debe ir primero la clase madre)
  • Se crea el objeto $student = new Student('Luisa', 'Fantone');
  • ...y se saluda al estudiante echo $student->greet();
  • Aquí se usa la clase Student y aprovecha todo de la clase Person gracias a la herencia
  • Se crea el objeto $professor = new Professor('Italo', 'Morales');
  • ...y se saluda
  • Aquí hacemos uso de la clase Professor y la misma aprovecha todo lo que hay en la clase Person, sin embargo, observa que he sobrescrito el método greet(), y esto es lo valioso.. Que a pesar de que heredamos y usamos, no estamos obligados a seguir un patrón estricto.

Con esto finalizamos, visita con frecuencia está web para que aprendas aun más cosas de PHP.

Parámetros de tipo objeto en PHP

En Rimorsoft hemos ido descubriendo cómo pasar parámetros y asegurarnos de que los tipos sean correctos. Hemos visto un ejemplo muy interesante en post de funciones anónimas, pero no es lo único que podemos hacer. Aquí veremos cómo pasar a un objeto un parámetro del tipo objeto.

Le he dado muchas vueltas y creo que conseguí la mejor manera de explicarlo. Vamos a crear tres (3) archivos:

  • Index: Archivo principal, y es el que ejecutamos en el navegador.
  • Post: Un objeto que tiene como fin ocuparse de todo lo relacionado con los posts o articulos del sistema.
  • Author: Es el objeto que representa al dueño del post.

La lógica dice que para crear un Post necesitamos si o si a un Author. Comencemos:

Clase Author

<?php

/**
* this class represents a author
*/
class Author 
{
    var $name;
    var $lastname;

    function __construct($name, $lastname)
    {
	$this->name = $name;
	$this->lastname = $lastname;
    }

}

Clase Post

<?php

/**
* this class represents a post
*/
class Post 
{	
    var $author;
    var $title;
    var $body;

    function __construct(Author $author, $title, $body)
    {
	    $this->author = $author;
    	$this->title  = $title;
    	$this->body   = $body;
    }
}

Importante: Nota como el constructor tiene un parámetro del tipo Author, y el resto son solo string (cadena de texto)... Esto nos dice de inmediato que para crear con éxito un Post, necesitamos contar con el Author.

Archivo index.php

<?php

require 'Post.php';
require 'Author.php';

$author = new Author('Italo', 'Morales');
$post   = new Post($author, 'Clases en PHP', 'Las clases nos ayudan...');

echo "Título: {$post->title} <br>";
echo "Contenido: {$post->body} <br>";
echo "Autor: {$post->author->name} <br>";

echo '<pre>'; // structure the output
var_dump($post); // detail of the post object

Resultado

Al ejecutar este código debemos ver lo siguiente:

Título: Clases en PHP
Contenido: Las clases nos ayudan...
Autor: Italo

object(Post)#2 (3) {
    ["author"] => object(Author)#1 (2) {
        ["name"] => string(5) "Italo"
       ["lastname"] => string(7) "Morales"
    }
    ["title"]  => string(13) "Clases en PHP"
    ["body"] => string(24) "Las clases nos ayudan..."
}

Lo interesante es la estructura del objeto, dice claramente que Post es un objeto y que dentro tiene otro objeto llamado Author. Luego vemos los string title y body.

Conceptos

  • Etiqueta pre: Con esta etiqueta logramos ver correctamente el objeto, si no usamos esta etiqueta antes del var_dump($post); veremos todo en una sola línea.
  • Función var_dump: Con esto logramos ver la información de una variable, en este caso me interesa saber que hay dentro de la variable $post. Si escribo echo $post; me dará error porque $post no es un string, es un objeto.

Esto es POO, y la idea es seguir profundizando para convertirte en un gran programador y no en un usuario Laravel. Quiero que veas cualquier cosa fabricada en Laravel y digas ¡Genial, es una clase, hereda de, el parámetro es, y así ....... !

Saber realmente PHP te ayudará a comprender cualquier Framework.

Libro de TDD - Lo que debes saber
Compra el libro
TDD lo que debes saber

Newsletter

Únete a más de 4.000+ personas y no te pierdas nunca más de las nuevas clases, tips, tutoriales y más cada semana.

    No enviamos spam. Puedes darte de baja en cualquier momento.