Lección 13: Objetos

Con el lanzamiento de PHP 5 se añadió soporte para la Programación Orientada a Objetos (POO). Antes de continuar quiero que sepas que existen 3 paradigmas o formas de organizar su código:

Estructurada: Tal como hemos trabajado hasta ahora. Las instrucciones siguen un orden del principio del archivo hasta el final.
Funcional: funciones que llaman a otras funciones (declaradas o anónimas). Su potencial radica en que se evitan muchos errores. Existen lenguajes mejores que PHP para este fin (Lisp, Elixir, Haskell…).
Objetos: Encapsular variables y funciones.

Los objetos nos permiten mantener en un mismo sitio una gran cantidad de variables y funciones que se pueden fusionar con otros lugares. Tranquilo que no busco que los manejes como un experto pero si que seas capaz de interpretar y crear unos objetos simples.

Clase

En el ejemplo tenemos un objeto que lo hemos llamado Gato. Dentro contiene una variable y una función.

// Declaración
class Gato
{
    // Variables publicas
    public $nombre = 'Felix';

    /**
     * Método para escuchar al gato
     * @return void
     */
    public function maullar(): void
    {
        echo 'Miiiiauuuu';
    }
}

Para utilizarlo se debes instanciarlo. Para ello existe una palabra reservada llamada new.

// Se instancia el objeto Gato
$miGato = new Gato();

Ahora ya se puede utilizar su interior con las flechas ->.

// Se llama a la funcion de Gato
$miGato->maullar();
// echo: Miiiiauuuu
echo $miGato->nombre;
// echo: Felix

Constructor

Los constructores son las funciones que serán ejecutadas al crear el objeto.

Por ejemplo.

// Declaración
class Gato
{
    // Variables publicas
    public $nombre = 'Felix';

    /**
     * Método para escuchar al gato
     * @return void
     */
    function __construct()
    {
        echo 'Miiiiauuuu';
    }
}

new Gato();
// Miiiiauuuu

Uno de sus usos más extendido es definir sus valores al crear el objeto.

// Declaración
class Gato
{
    // Variables publicas
    public string $nombre = '';

    /**
     * @return void
     */
    function __construct(string $nombre)
    {
        $this->nombre = $nombre;
    }
}

$miGato = new Gato('Federico');
echo $miGato->nombre;
// Federico

Puede ser resumida con la siguiente estructura.

// Declaración
class Gato
{
    /**
     * @return void
     */
    function __construct(public string $nombre = '')
    {
        // Nada que hacer, tómate un descanso
    }
}

$miGato = new Gato('Gustavo');
echo $miGato->nombre;
// Gustavo

Además podemos disponer de varios constructores que hagas diferentes funciones.

// Declaración
class Gato
{
    // Variables publicas
    public string $nombre = 'Felix';

    /**
     * Método para escuchar al gato
     * @return void
     */
    function __construct(...$args)
    {
        if (isset($args[0])) {
            $this->nombre = $args[0];
            echo 'Hola ' . $this->nombre;
        } else {
            echo 'Miiiiauuuu';
        }
    }
}

$miGatoFavorito = new Gato();
// Miiiiauuuu
echo $miGatoFavorito->nombre;
// Felix

$miGatoTalVezVivo = new Gato('Schrodinger');
// Hola Schrodinger
echo $miGatoFavorito->nombre;
// Schrodinger

Visibilidad

Una de las características más importantes de los objetos es la visibilidad, o los permisos que puede tener las variables o funciones. Similar a dar privilegios de acceso.

Las posibilidades son:

public: cualquier puede usarlo.
private: solo es accesible desde el propio objeto.
protected: solo es accesible desde el propio objeto o herederos.

Si no se indica lo contrario será public.

/**
 * Definición de Amigo
 */
class Amigo
{
    // Declaración de un constructor public
    public function __construct() { }

    // Declaración de un método public
    public function MyPublic() { }

    // Declaración de un método protected
    protected function MyProtected() { }

    // Declaración de un método private
    private function MyPrivate() { }

    // Esto es public
    function tomarCerveza()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

Herencia

Es posible instanciar un objeto y fusionar las variables y las funciones del otro objeto ya instanciado. Para ello se utiliza la palabra reservada extends.

// Hereda todo el objeto de Gato
class Garfield extends Gato {

    // Variables publicas
    public $nombre = 'Garfield';

    /**
     * Método para expresar la comida favorita
     * @return void
     */
    public function comidaFavorita(): void
    {
        echo 'Lasaña';
    }
}

Instanciamos nuestro gato Garfield.

// Se instancia el objeto Garfield
$miGatoComilon = new Garfield();

Y ya podemos usar todas las variables y funciones tanto de Gato como de Garfield. Pero… ¿que pasa con la variable que tiene el mismo nombre ($nombre)? Como Garfield es el hijo sobrescribe por su valor.

// Se llama a la funcion de Gato
$miGatoComilon->maullar();
// echo: Miiiiauuuu
// Se llama a la funcion de Garfield
$miGatoComilon->comidaFavorita();
// echo: Lasaña
echo $miGatoComilon->nombre;
// echo: Garfield

Se nos queda por el camino muchos conceptos que no veremos.

Sobrecarga.
Estáticos.
Interfaces.
Abstración.
Rasgos (Traits).
…

Por ahora lo dejaremos aquí, no es necesario profundizar mucho más mientras sepamos utilizarlos.

13-1

13-2

Esta obra está bajo una Licencia Creative Commons Atribución-NoComercial-SinDerivadas 4.0 Internacional.

Atribución/Reconocimiento-NoComercial-SinDerivados 4.0 Internacional

¿Me ayudas?

Comprame un café — Pulsa sobre la imagen

No te sientas obligado a realizar una donación, pero cada aportación mantiene el sitio en activo logrando que continúe existiendo y sea accesible para otras personas. Además me motiva a crear nuevo contenido.

Comentarios

{{ comments.length }} comentarios

Nuevo comentario

Nueva replica {{ formatEllipsisAuthor(replyComment.author) }}

Escribe el primer comentario