La principal forma de definir objetos en PHP es mediante unas estructuras especiales llamadas clases.

Las clases son los planos donde se detallan las características de los objetos, y
con solo definir una unica clase se pueden generar muchos objetos, por lo que son muy útiles para
reutilizar código.

Generar objetos a partir de clases se conoce como instanciar y para llevarlo a cabo
se usa la palabra clave de PHP new

class NombreDeLaClase{
}
$object = new NombreDeLaClase;

Para entender como es que esto funciona tenemos que ilustrarlo con código que resuelva problemas
reales.

Pensemos por ejemplo en un producto de una tienda en línea, este producto debería contar con los
siguientes datos:

• Titulo
• Precio
• Existencias
• Descripción

Creemos una clase que represente esto:

class Product
{
    private string $title = 'Pasta dental';
    private string $description = 'Producto de higiene bucal';
    private float $price = 39.9;
    private int $stock = 4;
}

$Product = new Product;

Ahora tenemos una clase producto que agrupa y oculta sus datos, simplemente definimos una variable
para cada dato requerido y declaramos el tipo de dato.

Antes de cada variable usamos la palabra private que es el indicativo de que el dato
debe estar oculto y asi evitar que pueda ser accedido desde el exterior del objeto.

Podríamos haber definido un arreglo asociativo con estos datos, pero ¿como evitas que los datos sean
modificados por tus algoritmos o por otros módulos?, ó ¿como evitas que los valores que sí van a ser
modificados no se corrompan?

En el caso de un producto de una plataforma de comercio, el titulo y la descripción son valores que
no suelen cambiar durante la ejecución del programa.

Por otro lado el precio es un valor que podría variar si se aplican impuestos o descuentos pero tanto
el precio como las existencias son valores que de ser modificados tendrían que seguir algún criterio
(como el de nunca poder ser valores negativos por ejemplo).

Para resolver estas cuestiones crearemos las funciones que definirán el comportamiento interno del
producto, pero antes necesitamos aclarar ciertos detalles técnicos.

Propiedades, Métodos y su Visibilidad/Ocultamiento

Las propiedades de un objeto es como se conoce a las variables que definimos dentro de una clase para
contener los valores principales de un objeto.

Los métodos de una objeto son las funciones que definiremos dentro de una clase para programar el
comportamiento de dichos objetos y se declaran usando el formato que ya vimos para declarar funciones en PHP.

En conjunto las propiedades y métodos de un objeto es lo que se conoce como miembros de un objeto.

Y para controlar el nivel de ocultamiento de los miembros de un objeto se usan los modificadores de
visibilidad Public y Private y con ellos se controla que puede o
no ser accedido desde fuera del objeto.

Lo mas recomendable es por defecto definir todos los miembros como ocultos y solo definir como
visibles desde el exterior a ciertos miembros en particular.

Estos miembros accesibles desde el exterior representan la interfaz del objeto (la superficie de
contacto), y son el medio que usarán otros objetos y el resto del software para interactuar con
ellos.

Encapsulamiento

Los miembros de un objeto están aislados del resto de cosas del programa, pero no están aislados
entre si, ya que forman parte de la misma unidad estos pueden interactuar entre sí.

A esta característica de los objetos de permitir que sus elementos internos puedan referenciarse
entre ellos se le llama encapsulamiento.

Para poder hacer referencia a las propiedades o métodos de un objeto desde dentro del mismo se usa
una pseudovariable llamada $this, la cual es un comodín que hace referencia al
propio objeto.

Este comodín se usa en conjunto con el operador de objeto ->
(Operador flecha simple, el cual se construye con un «guión medio» y el símbolo «mayor que») para
realizar esta interacción entre los miembros de un objeto $this->.

Acceso a las Propiedades del objeto vía Getters

Los Getters son funciones pensados para permitir la lectura de los valores internos de un objeto de
forma controlada, se suelen llamar con el nombre de la propiedad que se desea leer pero precedida
por el prefijo get, por ejemplo getTitle(), getPrice(), getStock(), etc.

Poniendo en practica lo aprendido

Vamos a modificar el código de la clase producto y añadiremos los mecanismos para poder leer los
datos internos del producto
y al final del código vamos a llamarlos para comprobar que realmente estamos accediendo a la
información correcta.

class Product
{
    private string $title = 'Pasta dental';
    private string $description = 'Producto de higiene bucal';
    private float $price = 39.9;
    private int $stock = 4;

    public function getTitle()
    {
        return $this->title;
    }

    public function getDescription()
    {
        return $this->description;
    }

    public function getPrice()
    {
        return $this->price;
    }

    public function getStock()
    {
        return $this->stock;
    }
}

$Product = new Product;
echo '<div>
    <h4>'.$Product->getTitle().'</h4>
    <p>'.$Product->getDescription().'</p>
    <p>Precio: $'.$Product->getPrice().'</p>
    <p>Existencias: '.$Product->getStock().'</p>
</div>';

Este código PHP generará el siguiente código HTML:

<div>
    <h4>Pasta dental</h4>
    <p>Producto de higiene bucal</p>
    <p>Precio: $39.9</p>
    <p>Existencias: 4</p>
</div>

El cual se verá de la siguiente manera en el navegador:

Hemos definido una función getter para cada propiedad de nuestro objeto y hemos dejado estos métodos
como públicos para permitir su acceso fuera del objeto.

Dentro de cada getter usamos la referencia al objeto contenedor y el operador flecha
$this-> para poder acceder a cada una de las propiedades.

Con todo esto logramos encapsular los datos de un producto de forma que no haya forma de modificar
sus valores, solo tenemos mecanismos para poder leer dichos datos.

Usando solo arreglos, constantes y funciones podemos emular todos estos comportamientos y conceptos,
pero definitivamente no es sencillo, y el código resultante no sería tan compacto como el que nos
permite generar la Programación Orientada a Objetos.

Aunque un problema del código que llevamos escrito hasta aquí es que solo esta definido para un único
producto, pero otra de las razones por las que usamos POO es por la facilidad que nos da para
reutilizar código, por lo que ahora veremos como generar multiples objetos con el mismo código.

Constructores de objetos

Dentro de cada clase podemos definir un método especial conocido como constructor, y este nos permite
proporcionarle a la clase los valores base con los que se creara cada objeto.

Este método especial no puede tener cualquier nombre, en concreto en PHP debe ser una función con el
nombre __construct y solo puede llevar el modificador de visibilidad
public.

A nuestro constructor podemos definirle argumentos de función como a cualquier otra función
convencional

Al estar dicho método especial encapsulado en una clase, podemos interactuar con el resto de miembros
del objeto, por lo que tomaremos los argumentos de la función y directamente los asignaremos a
propiedades del objeto.

De esta forma podemos usar la misma clase para crear multiples objetos con valores diferentes pero
reutilizando el mismo plano, permitiendo de forma elegante reutilizar grandes cantidades de código
para crear estructuras similares.

Modifiquemos nuestra clase Producto para añadir un constructor con un argumento por cada propiedad
del objeto.

class Product
{
    private string $title;
    private string $description;
    private float $price;
    private int $stock;

    public function __construct(
        string $title,
        string $description,
        float $price,
        int $stock,
    )
    {
        $this->title = $title;
        $this->description = $description;
        $this->price = $price;
        $this->stock = $stock;
    }

    public function getTitle()
    {
        return $this->title;
    }

    public function getDescription()
    {
        return $this->description;
    }

    public function getPrice()
    {
        return $this->price;
    }

    public function getStock()
    {
        return $this->stock;
    }
}

Para usar la clase emplearemos ahora una lista de productos, los cuales podrían ser leídos de alguna
base de datos o proporcionados por una interfaz de usuario.

Luego esa lista de productos la recorreremos con un bucle foreach y crearemos un objeto por cada
producto.

$items = [
    [
        'title' => 'Pasta dental',
        'description' => 'Producto de higiene bucal',
        'price' => 39.9,
        'stock' => 4,
    ],
    [
        'title' => 'Crema corporal humectante',
        'description' => 'Producto dermatológico',
        'price' => 50.2
        'stock' => 6,
    ],
    [
        'title' => 'Protector Solar 50+fps',
        'description' => 'Protector solar facial',
        'price' => 50.2
        'stock' => 10,
    ],
    [
        'title' => 'Aspirina',
        'description' => 'Tableta ácido acetilsalicílico',
        'price' => 57
        'stock' => 12,
    ],
    [
        'title' => 'Enjuague bucal',
        'description' => 'Producto de higiene bucal',
        'price' => 57
        'stock' => 12,
    ],
];

$ProductList = [];
foreach($items as $item){
    $ProductList[] = new Product(
        $item['title'],
        $item['description'],
        $item['price'],
        $item['stock'],
    );
}

Con esto ya tendríamos un listado de objetos, que de momento solo es un conjunto de datos donde todos
comparten el mismo comportamiento, lo cual de momento puede parecer mucho código para lo que
realmente sirve.

Para cambiar un poco esto y empezar a tener noción del potencial de la POO modifiquemos nuestro
ejemplo añadiendo más lógica para una situación común.

Para actualizar el comportamiento de todos nuestros objetos tipo producto solo hace falta modificar
una sola pieza del software, que en este caso es la clase Product.

Si tuviésemos que aplicar un impuesto al precio de los productos en la misma clase podríamos definir
en una constante de clase cual es el impuesto fijo a aplicar por ejemplo, o si necesitáramos un
método para imprimir la lista de productos en cierto formato

class Product
{
    const 
    private string $title;
    private string $description;
    private float $price;
    private int $stock;

    public function __construct(
        string $title,
        string $description,
        float $price,
        int $stock,
    )
    {
        $this->title = $title;
        $this->description = $description;
        $this->price = $price;
        $this->stock = $stock;
    }

    public function getTitle()
    {
        return $this->title;
    }

    public function getDescription()
    {
        return $this->description;
    }

    public function getPrice()
    {
        return $this->price;
    }

    public function getStock()
    {
        return $this->stock;
    }
}

En resumen

Con esto ya tenemos la sintaxis básica para trabajar con objetos en PHP, ya que ahora conocemos las
clases, que son los planos que definen y permiten crear objetos y como se definen las propiedades y
los métodos dentro de ellas.