8.1 Conceptos Básicos: Clases, Objetos, Propiedades y Métodos

¿Qué es una clase?

Imagina que vas a construir varios tipos de coches. Antes de hacer cada uno, necesitas un plano que te diga cómo debe ser el coche: cuántas puertas tiene, qué motor usa, de qué color será, qué funciones debe tener (como arrancar o frenar), etc. Ese plano es lo que llamamos en programación una clase.

Una clase es básicamente una plantilla. No es un objeto en sí, pero define cómo serán los objetos que creemos a partir de ella. En otras palabras, la clase establece:

• Qué datos tiene un objeto (estas son las propiedades o atributos).
• Qué cosas puede hacer ese objeto (estas son las funciones, llamadas en este contexto métodos).

SanDisk Pendrive 64 GB Ultra Memoria flash USB 3.0 hasta 130 MB/s

5,95€

(SecureAccess Software, Protección de contraseñas) Negro.

Toshiba Canvio Partner 1TB Disco Duro Externo portátil de 2,5», USB 3.2

57,99€

(Toshiba Canvio Partner 1TB Disco Duro Externo portátil de 2,5», USB 3.2, Compatible con Mac y Windows. Xbox, PS4, PS5 (HDTB510EK3AB)

TP-Link LS105G – Switch Ethernet 5 Puertos (10/100/1000Mbps), Switch Gigabit, Switch WiFi

13,00€

TP-Link LS105G – Switch Ethernet 5 Puertos (10/100/1000Mbps), Switch Gigabit, Switch WiFi, Carcasa metálica, Ultraligero, Disipación de Calor, QoS, Ahorro de Energía, Silencioso, No Gestionado, Azul

¿Y por qué necesitamos clases?

Porque trabajar con objetos te permite organizar tu código de forma más lógica y reutilizable. En vez de tener variables sueltas y funciones desordenadas, agrupas todo lo que tiene que ver con una cosa (por ejemplo, un coche, un usuario, un producto).

Estructura general de una clase en PHP

<?php
class NombreDeLaClase {
    // Propiedades
    public $propiedad1;
    public $propiedad2;

    // Métodos
    public function metodo1() {
        // Código del método
    }

    public function metodo2() {
        // Código del método
    }
}
?>

Ejemplo práctico: clase Coche

Vamos a hacer una clase que represente un coche. Un coche tiene atributos como la marca, el modelo o el color. Y tiene acciones como arrancar o detenerse.

<?php
class Coche {
    // Propiedades (características del coche)
    public $marca;
    public $modelo;
    public $color;

    // Método (acción que puede hacer el coche)
    public function arrancar() {
        echo "El coche está arrancando...\n";
    }

    public function detener() {
        echo "El coche se ha detenido.\n";
    }
}
?>

@Tip. Las propiedades son como variables internas del objeto. Los métodos son funciones internas que permiten que el objeto actúe o se comunique.

¿Qué define una clase?

– Nombre de la clase

Como cualquier cosa en programación, una clase tiene un nombre. Debe empezar con letra, puede tener números y guiones bajos, y suele escribirse en PascalCase (primera letra de cada palabra en mayúscula).

class Usuario {}
class FacturaElectronica {}

Propiedades o atributos

Son como variables internas del objeto. Al crear un objeto, cada instancia tendrá sus propios valores para esas propiedades.

public $marca;
private $precio;
protected $anio;

Visibilidad: Puedes controlar el acceso a las propiedades usando public, private o protected. Veremos esto a fondo más adelante, pero por ahora:

• public: accesible desde cualquier parte del código.
• private: solo desde dentro de la clase.
• protected: solo desde la clase o las clases hijas.

Métodos

Son como funciones que viven dentro de la clase. Sirven para realizar acciones con los datos que tiene el objeto o para comunicarse con otras partes del programa.

public function arrancar() {
    echo "Arrancando...";
}

Puedes pasarles parámetros, devolver resultados, manipular las propiedades, etc.

Constructor

Una clase puede tener un método especial llamado constructor (__construct), que se ejecuta automáticamente al crear un objeto con new. Sirve para darle valores iniciales al objeto.

<?php
class Persona {
    public $nombre;

    public function __construct($nombreInicial) {
        $this->nombre = $nombreInicial;
    }
}
?>

¿Qué pasa cuando creamos un objeto?

Cuando usamos new, le estamos diciendo a PHP: “¡Ey! Usa esta clase como plantilla y créame un objeto real con esas características”.

$miCoche = new Coche();

A partir de ese momento, $miCoche es un objeto real que tiene todas las propiedades y métodos definidos en la clase Coche.

Podemos hacer tantas instancias como queramos:

$otroCoche = new Coche();

Y cada una puede tener valores propios:

$miCoche->marca = "Toyota";
$otroCoche->marca = "Ford";

Ventajas de usar clases

• Organización del código: todo lo relacionado con una entidad está agrupado.
• Reutilización: puedes crear tantos objetos como quieras a partir de una sola clase.
• Escalabilidad: puedes ir ampliando la clase con más funciones sin afectar al resto del código.
• Mantenimiento: más fácil de entender, probar y corregir errores.

En resumen

Ahora que entiendes bien qué es una clase, pasaremos al siguiente paso: entender qué es un objeto, cómo usar las propiedades y métodos, y cómo controlar su acceso con encapsulamiento.

8.2 ¿Qué es un objeto?

Ya entendimos que una clase es como una plantilla, ¿cierto?
Pues bien, un objeto es una instancia concreta de ese plantilla. Es decir, un objeto es algo real, vivo en tu programa, construido a partir de una clase.

Podemos decir que una clase no hace nada por sí sola, hasta que se crea un objeto a partir de ella.
Cada objeto que crees tendrá sus propios datos y podrá realizar las acciones que la clase define.

Ejemplo

Imagina que tienes una clase Perro. Define que un perro tiene un nombre, una raza, y puede ladrar().

<?php
class Perro {
    public $nombre;
    public $raza;

    public function ladrar() {
        echo "Guau guau!";
    }
}
?>

Ahora bien, esto es solo una descripción (nuestra definición de clase, o sea, la plantilla). No tenemos perros creados todavía.

Cuando creamos un objeto a partir de esa clase, hacemos un perro real, y para ello, tenemos que hacer uso de la función new():

$miPerro = new Perro();
$miPerro->nombre = "Rocky";
$miPerro->raza = "Labrador";

Ahora $miPerro es un objeto. Ya no es un concepto general, es un perro llamado Rocky, de raza labrador.
Y puede hacer lo que los perros de la clase saben hacer:

$miPerro->ladrar(); // Muestra: Guau guau!

Analicemos el proceso paso a paso

1. Instanciación

Cuando haces esto:

$miPerro = new Perro();

Estás instanciando la clase. O sea, estás diciendo:

“PHP, por favor, crea un nuevo objeto de tipo Perro”.

A este proceso se le llama instanciar una clase, y el resultado es un objeto.

2. Acceso a propiedades

Una vez que tienes el objeto creado, puedes acceder a sus propiedades públicas usando la flecha ->.

$miPerro->nombre = "Rocky";
$miPerro->raza = "Labrador";

Es como decir:

“A este perro, que acabo de crear, le voy a poner nombre y raza”.

Y si quieres ver sus datos:

echo $miPerro->nombre; // Rocky
echo $miPerro->raza;   // Labrador

3. Acceso a métodos

Un método es una acción que el objeto puede realizar. Para ejecutarlo, también usamos la flecha ->, pero como es una función, van los paréntesis:

$miPerro->ladrar(); // Guau guau!

Cada objeto es independiente

Una de las grandes ventajas de trabajar con objetos es que puedes tener varios objetos del mismo tipo, pero con diferentes datos.
Cada uno funciona de manera independiente, aunque todos comparten la misma estructura porque vienen de la misma clase.

$perro1 = new Perro();
$perro1->nombre = "Rocky";

$perro2 = new Perro();
$perro2->nombre = "Luna";

echo $perro1->nombre; // Rocky
echo $perro2->nombre; // Luna

Ambos son objetos de tipo Perro, pero cada uno tiene su propio estado (es decir, sus propios datos).

¿Qué pasa en memoria?

Cuando creas un objeto con new, PHP reserva un espacio en memoria para ese objeto.
Cada vez que usas new, se crea un nuevo espacio, con sus propios valores.

$persona1 = new Persona();
$persona2 = new Persona();

Aunque ambos vengan de la clase Persona, internamente PHP los trata como instancias separadas.

Cómo controlar el acceso a las propiedades (Encapsulamiento)

Encapsulamiento

El encapsulamiento es fundamental en la POO y consiste en ocultar el funcionamiento interno de un objeto y restringir el acceso directo a sus datos.
La idea es proteger los datos para evitar que sean modificados incorrectamente desde fuera de la clase.

Es como decir:

“No puedes meter la mano directamente en el motor, pero te doy un botón para encender el coche”.

Visibilidad

Para aplicar el encapsulamiento, PHP nos da modificadores de visibilidad para las propiedades y métodos:

Ejemplo

class CuentaBancaria {
    private $saldo = 0;

    public function depositar($cantidad) {
        if ($cantidad > 0) {
            $this->saldo += $cantidad;
        }
    }

    public function obtenerSaldo() {
        return $this->saldo;
    }
}

Aquí la propiedad $saldo está marcada como private, lo que significa que no se puede acceder directamente desde fuera:

$cuenta = new CuentaBancaria();
// $cuenta->saldo = 1000; ❌ ERROR: no se puede acceder directamente
$cuenta->depositar(1000); // ✅ Método permitido
echo $cuenta->obtenerSaldo(); // ✅ Muestra 1000

Ventajas del encapsulamiento

• Protege la integridad de los datos.
• Permite definir reglas de validación (ej. no permitir saldos negativos).
• Mejora el mantenimiento y evolución del código.

En proyectos reales, jamás se debería acceder directamente a los datos sensibles. Siempre se debe usar una interfaz controlada de métodos.

¿Qué es el constructor y por qué es tan útil?

¿Qué es un constructor?

El constructor es un método especial que se ejecuta automáticamente cuando se crea un nuevo objeto.
Sirve para inicializar el estado del objeto, es decir, para asignar valores iniciales a sus propiedades.

En PHP, el constructor se llama __construct().

Ejemplo

class Usuario {
    public $nombre;

    public function __construct($nombre) {
        $this->nombre = $nombre;
    }

    public function saludar() {
        echo "Hola, $this->nombre!";
    }
}

Y lo usamos así:

$usuario = new Usuario("Laura");
$usuario->saludar(); // Hola, Laura!

¿Qué está pasando aquí?

• Creamos un objeto con new Usuario("Laura").
• PHP ve que la clase tiene un método __construct(), así que lo ejecuta automáticamente.
• El constructor recibe "Laura" y se la asigna a la propiedad $nombre.

¿Y Por qué es útil?

• Evita tener que asignar propiedades manualmente después de crear el objeto.
• Te permite forzar la inicialización correcta del objeto desde el primer momento.
• Permite que el objeto siempre esté en un estado válido.

Es como si dijéramos: “No puedes tener un usuario sin nombre. ¡Oblígame a ponerlo desde el principio!”

Constructor con múltiples parámetros

class Producto {
    public $nombre;
    public $precio;

    public function __construct($nombre, $precio) {
        $this->nombre = $nombre;
        $this->precio = $precio;
    }

    public function mostrar() {
        echo "$this->nombre cuesta $this->precio €";
    }
}

$prod = new Producto("Camiseta", 19.99);
$prod->mostrar(); // Camiseta cuesta 19.99 €

Qué significa $this y cómo PHP sabe a qué objeto nos estamos refiriendo

¿Qué es $this?

Te habrás fijado por los ejemplos anteriores que dentro de una clase hacemos uso de la plabra reservada $this, Pero ¿qué es $this?. $this es una palabra clave especial en PHP que se utiliza dentro de una clase para referirse al objeto actual.
En otras palabras, es una forma de decir “yo mismo” desde dentro del objeto.

Ejemplo

class Persona {
    public $nombre;

    public function decirNombre() {
        echo "Mi nombre es " . $this->nombre;
    }
}

$p = new Persona();
$p->nombre = "Ana";
$p->decirNombre(); // Mi nombre es Ana

Aquí, $this->nombre significa:

“Accede a la propiedad nombre del objeto que está ejecutando este método”.

¿Cómo PHP sabe qué objeto es $this?

Cuando llamas a un método así:

$usuario1->saludar();

PHP internamente hace esto:

1. Identifica el objeto que está ejecutando el método ($usuario1).
2. Dentro del método, $this apunta a $usuario1.
3. Así, cualquier acceso a $this->algo se refiere a $usuario1->algo.

Si hubieras hecho $usuario2->saludar(), entonces $this sería $usuario2.

@Tip. $this solo se puede usar dentro de métodos de una clase. Si lo usas fuera, dará error porque no hay un objeto actual.

8.2 Herencia, Interfaces y Clases Abstractas en PHP

Pasemos a ver estos tres pilares de la Programación Orientada a Objetos. Estos tres conceptos permiten construir programas modulares, reutilizables y extensibles, lo que es clave en cualquier proyecto serio de PHP (y de cualquier lenguaje orientado a objetos).

Herencia: Reutilizar y extender clases

¿Qué es la herencia?

La herencia es un mecanismo mediante el cual una clase puede heredar las propiedades y métodos de otra clase.
Es como cuando un hijo hereda características de sus padres.

En PHP, se utiliza la palabra clave extends para indicar que una clase hereda de otra.

Ejemplo

class Animal {
    public $nombre;

    public function respirar() {
        echo "$this->nombre está respirando.<br>";
    }
}

class Perro extends Animal {
    public function ladrar() {
        echo "$this->nombre está ladrando.<br>";
    }
}

$miPerro = new Perro();
$miPerro->nombre = "Fido";
$miPerro->respirar(); // Heredado de Animal
$miPerro->ladrar();   // Definido en Perro

🔹 ¿Qué ha pasado aquí?

• La clase Perro hereda de Animal.
• No hemos tenido que volver a escribir el método respirar().
• Perro tiene sus propios métodos (ladrar()) y también los heredados (respirar()).

¿Por qué es útil la herencia?

• Reutilizas código ya escrito.
• Puedes organizar jerarquías de clases (como «Animal → Mamífero → Perro»).
• Facilita la mantenibilidad del código: si mejoras Animal, Perro también mejora.

Sobrescritura de métodos

Puedes redefinir un método heredado si necesitas que se comporte distinto:

class Perro extends Animal {
    public function respirar() {
        echo "$this->nombre jadea como un perro.<br>";
    }
}

Clases Abstractas: Plantillas incompletas

¿Qué es una clase abstracta?

Una clase abstracta es una clase que no puede ser instanciada directamente, y que sirve como modelo base para otras clases.
Se usa cuando quieres definir una estructura común, pero dejando algunos métodos como “pendientes” para que los definan las subclases (o clases hijas).

Se declara con la palabra clave abstract.

Ejemplo

abstract class Figura {
    public $color;

    public function __construct($color) {
        $this->color = $color;
    }

    // Método abstracto: las subclases deben implementarlo
    abstract public function calcularArea();
}

Subclase que implementa la clase abstracta:

class Cuadrado extends Figura {
    public $lado;

    public function __construct($color, $lado) {
        parent::__construct($color);
        $this->lado = $lado;
    }

    public function calcularArea() {
        return $this->lado * $this->lado;
    }
}

$cuadro = new Cuadrado("rojo", 5);
echo $cuadro->calcularArea(); // 25

¿Por qué usar clases abstractas?

• Obligas a que ciertas funciones se implementen sí o sí en las clases hijas.
• Permites definir comportamiento común, sin necesidad de completar todo.
• Es ideal para estructurar jerarquías complejas.

Recuerda

• No puedes hacer: $f = new Figura(); ❌ porque es abstracta.
• Puedes tener métodos completos y también métodos abstractos en la misma clase.

Interfaces

¿Qué es una interfaz?

Una interfaz define un conjunto de métodos que una clase debe implementar, pero sin definir su lógica interna.
Es como un compromiso que dice: “Si implementas esta interfaz, debes cumplir con estas reglas”.

Se usa la palabra clave interface y se implementa con implements.

Ejemplo

interface Operaciones {
    public function sumar($a, $b);
    public function restar($a, $b);
}

Ahora una clase que cumple con la interfaz:

class Calculadora implements Operaciones {
    public function sumar($a, $b) {
        return $a + $b;
    }

    public function restar($a, $b) {
        return $a - $b;
    }
}

$calc = new Calculadora();
echo $calc->sumar(5, 3);  // 8
echo $calc->restar(5, 3); // 2

Reglas de las interfaces

• Todos los métodos de la interfaz deben ser públicos.
• No se pueden definir propiedades en una interfaz (solo métodos).
• Una clase puede implementar múltiples interfaces (a diferencia de la herencia simple).

¿Cuándo usar interfaces y cuándo clases abstractas?

¿Cómo combino todo?

Puedes tener una clase abstracta que implemente interfaces, y luego tener subclases que hereden y desarrollen todo. Veamos un ejemplo completo:

interface Volador {
    public function volar();
}

abstract class Animal {
    public $nombre;

    public function __construct($nombre) {
        $this->nombre = $nombre;
    }

    abstract public function hacerSonido();
}

class Pajaro extends Animal implements Volador {
    public function hacerSonido() {
        echo "$this->nombre canta<br>";
    }

    public function volar() {
        echo "$this->nombre está volando<br>";
    }
}

Resumen

8.3 ESPACIOS DE NOMBRES (NAMESPACES) Y AUTOLOAD EN PHP

¿Qué son los espacios de nombres (namespaces)?

Un espacio de nombres (namespace) es como una carpeta virtual que agrupa clases, funciones y constantes en PHP.
Sirve para organizar el código y evitar conflictos de nombres entre diferentes partes de un proyecto o librerías.

PHP permite tener múltiples clases con el mismo nombre siempre que estén en namespaces distintos.

¿Por qué es necesario?

Imagina que estás trabajando con una librería externa que define una clase Usuario, y tú también tienes una clase Usuario. PHP no sabría cuál usar… ¡a menos que estén en distintos namespaces!

Sintaxis básica de un namespace

<?php
namespace MiProyecto\Modelo;

class Usuario {
    public function saludar() {
        echo "Hola desde la clase Usuario de MiProyecto\\Modelo!";
    }
}
?>

@Tip. El nombre del namespace va al inicio del archivo PHP, antes de cualquier otra instrucción.

Cómo usar esa clase desde otro archivo

Opción 1: Usar el nombre completo (namespace + clase)

$usuario = new \MiProyecto\Modelo\Usuario();
$usuario->saludar();

Opción 2: Usar use para importar el namespace

use MiProyecto\Modelo\Usuario;

$usuario = new Usuario();
$usuario->saludar();

El comando use es como un alias temporal para que no tengas que escribir el nombre completo cada vez.

Namespace y estructura de carpetas

Aunque no es obligatorio, es buena práctica que la estructura de carpetas coincida con los namespaces:

/MiProyecto
    /Modelo
        Usuario.php     → namespace MiProyecto\Modelo;

Esto facilita el uso de autoload (veremos más abajo).

Ejemplo

Supongamos que tenemos dos clases con el mismo nombre, Usuario, pero en distintos contextos:

// archivo: App/Modelo/Usuario.php
namespace App\Modelo;

class Usuario {
    public function info() {
        return "Usuario del sistema";
    }
}

// archivo: App/Autenticacion/Usuario.php
namespace App\Autenticacion;

class Usuario {
    public function info() {
        return "Usuario autenticado";
    }
}

// archivo principal
use App\Modelo\Usuario as UsuarioModelo;
use App\Autenticacion\Usuario as UsuarioAuth;

$modelo = new UsuarioModelo();
$auth = new UsuarioAuth();

echo $modelo->info();  // Usuario del sistema
echo $auth->info();    // Usuario autenticado

Aquí usamos alias con as para distinguir clases con el mismo nombre.

AUTOLOAD: Carga automática de clases

Autoload hace que PHP cargue automáticamente las clases cuando las necesitas, sin tener que usar require o include manualmente para cada archivo.

¿Por qué usarlo?

• Evita tener cientos de require o include.
• Facilita la organización en proyectos grandes.
• Es compatible con namespaces, lo cual lo hace ideal para estructuras modernas.

Método clásico: spl_autoload_register()

spl_autoload_register(function($clase) {
    // Convertir el namespace en ruta de archivo
    $archivo = __DIR__ . '/' . str_replace('\\', '/', $clase) . '.php';
    
    if (file_exists($archivo)) {
        require $archivo;
    }
});

¿Qué hace este código?

• Cuando haces new MiProyecto\Modelo\Usuario(), PHP intenta cargar esa clase.
• spl_autoload_register intercepta esa llamada.
• Reemplaza los \ del namespace por / (para que coincida con las carpetas).
• Busca un archivo con ese nombre (MiProyecto/Modelo/Usuario.php).
• Si existe, lo carga con require.

Uso moderno con Composer (PSR-4)

Cuando usas Composer, puedes declarar namespaces y rutas automáticamente:

Paso 1: Estructura de carpetas

/src
    /Controladores
        UsuarioController.php
    /Modelos
        Usuario.php

Paso 2: Configurar composer.json

{
  "autoload": {
    "psr-4": {
      "App\\": "src/"
    }
  }
}

Paso 3: Ejecutar el autoload

composer dump-autoload

Paso 4: Incluir el autoloader en tu proyecto

require 'vendor/autoload.php';

use App\Modelos\Usuario;
use App\Controladores\UsuarioController;

Resumen General

Buenas prácticas

1. Un archivo = una clase → Facilita el autoload.
2. El nombre de las carpetas debe reflejar el namespace.
3. Evita los require manuales en aplicaciones modernas. Usa autoload o Composer.
4. No uses namespaces si tu proyecto es pequeño, pero sí si crece o trabajas en equipo.

Resumen del Capítulo 8: Programación Orientada a Objetos

En este capítulo hemos aprendido los fundamentos de la programación orientada a objetos en PHP. Hemos comenzamos entendiendo qué son las clases y los objetos, y cómo las propiedades y métodos definen el estado y comportamiento de un objeto. Hemos profundizadoen el uso del constructor (__construct) para inicializar objetos, el uso de $this para referirse al propio objeto, y la importancia del encapsulamiento para proteger los datos.

También hemos explorado conceptos clave como la herencia, que permite reutilizar y extender código; las interfaces, que definen compromisos que las clases deben cumplir; y las clases abstractas, que sirven como base para otras clases. Finalmente, conocimos los espacios de nombres (namespaces) para organizar el código y evitar conflictos, así como el uso del autoloading para cargar automáticamente las clases sin necesidad de múltiples require.

Veamos ahora unos ejercicios prácticos.

<?php
class Libro {
    public $titulo;
    public $autor;
    public $paginas;

    public function __construct($titulo, $autor, $paginas) {
        $this->titulo = $titulo;
        $this->autor = $autor;
        $this->paginas = $paginas;
    }

    public function mostrarInfo() {
        echo "Libro: $this->titulo\n";
        echo "Autor: $this->autor\n";
        echo "Páginas: $this->paginas\n";
    }
}

// Crear objeto
$miLibro = new Libro("Cien años de soledad", "Gabriel García Márquez", 417);
$miLibro->mostrarInfo();
?>

<?php
class Animal {
    public $nombre;

    public function __construct($nombre) {
        $this->nombre = $nombre;
    }

    public function hacerSonido() {
        echo "Sonido genérico\n";
    }
}

class Perro extends Animal {
    public function hacerSonido() {
        echo "Guau guau\n";
    }
}

$animal = new Animal("Animal");
$perro = new Perro("Firulais");

$animal->hacerSonido(); // Sonido genérico
$perro->hacerSonido();  // Guau guau
?>

<?php
// Autoload simple
spl_autoload_register(function ($clase) {
    include $clase . '.php';
});

// Archivo: Imprimible.php
interface Imprimible {
    public function imprimir();
}

// Archivo: Factura.php
class Factura implements Imprimible {
    public function imprimir() {
        echo "Factura N° 001 - Total: $100.00\n";
    }
}

// Código principal
$factura = new Factura();
$factura->imprimir();
?>

Bibliografía de programación en PHP.

• Aprende PHP desde Cero: Todo lo que necesitas para programar en PHP. Autor: Gerardo G. Urtiaga (Editorial: Editorior Independiente)
• PHP y MySQL: Domine el desarrollo de un sitio web dinámico e interactivo. Autor: Olivier Heurtel (Editorial: Ediciones ENI)
• PHP 8: Programación de aplicaciones web en el servidor: Guía paso a paso con ejemplos y proyectos prácticos. Autor: Jose Vicente Cerratlá.

Amazon Fire TV Stick HD (Última generación), con TV en directo gratuita, mando por voz Alexa, controles de Hogar digital y reproducción en streaming HD

44,99€

Tapo C210 – Cámara IP WiFi 360° Cámara de Vigilancia 2K (3MP),Visión nocturna Admite tarjeta SD hasta 512 GB, Detección y seguimiento de movimiento, Control Remoto, Compatible con Alexa

26,99€

Echo Dot (Última generación) | Altavoz inteligente wifi y Bluetooth con Alexa, con sonido más potente y de mayor amplitud | Antracita

64,99€