¿Qué es la Programación Orientada a Objetos? (15 minutos)
Explicación:
La Programación Orientada a Objetos (POO) organiza el código en clases y objetos, modelando entidades del mundo real con datos (propiedades) y comportamientos (métodos).
Conceptos clave:
- Clase: Plantilla que define propiedades (datos) y métodos (funciones).
- Ejemplo: Una clase "Coche" define cómo es un coche.
- Objeto: Instancia de una clase.
- Ejemplo: Un coche específico (un Toyota rojo) es un objeto.
- Propiedades: Variables dentro de una clase (por ejemplo, $color).
- Métodos: Funciones dentro de una clase (por ejemplo, acelerar()).
- Herencia: Una clase puede heredar propiedades y métodos de otra, extendiendo su funcionalidad.
Ventajas de la POO:
- Modularidad: Código organizado y reutilizable.
- Mantenibilidad: Fácil de actualizar.
- Escalabilidad: Ideal para proyectos grandes, como Laravel.
Analogía:
- Una clase es como el plano de una casa (define estructura).
- Un objeto es una casa construida (instancia concreta).
Por qué es importante:
- En Laravel, los modelos, controladores, y servicios usan POO para estructurar la lógica (por ejemplo, un modelo User representa a un usuario).
Ejemplo básico:
<?php
class Coche {
public $marca = "Toyota";
public function mostrarMarca() {
echo "El coche es un $this->marca.";
}
}
$miCoche = new Coche();
$miCoche->mostrarMarca(); // Salida: El coche es un Toyota.
?>
Punto clave: La POO permite modelar entidades complejas, una práctica esencial en aplicaciones modernas con PHP.
Actividad rápida (3 minutos):
Piensa en una entidad del mundo real (por ejemplo, un libro). Escribe en papel 1 propiedad y 1 método que tendría su clase. Ejemplo:
- Propiedad: $titulo.
- Método: abrir().
Clases, objetos, propiedades, y métodos (30 minutos)
Explicación:
Aprendamos a crear y usar clases y objetos en PHP, definiendo propiedades y métodos.
Definir una clase:
- Usa class NombreClase {}.
- Propiedades: Variables con visibilidad (public, private, protected).
- Métodos: Funciones dentro de la clase.
Crear un objeto:
- Usa new NombreClase().
- Accede a propiedades y métodos con ->.
Visibilidad:
- public: Accesible desde cualquier lugar.
- private: Solo accesible dentro de la clase.
- protected: Accesible en la clase y clases hijas (herencia).
Ejemplo práctico (como pide la lección):
Clase "Coche" con métodos como "acelerar":
<!DOCTYPE html>
<html lang="es">
<head>
<title>Clase Coche</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 20px auto;
text-align: center;
}
h1 {
color: #2c3e50;
}
.resultado {
margin-top: 15px;
font-size: 1.1rem;
}
</style>
</head>
<body>
<h1>Prueba de Coche</h1>
<?php
class Coche {
public $marca;
public $velocidad = 0;
public function __construct($marca) {
$this->marca = $marca;
}
public function acelerar() {
$this->velocidad += 10;
return "El $this->marca acelera a $this->velocidad km/h.";
}
public function frenar() {
if ($this->velocidad > 0) {
$this->velocidad -= 10;
return "El $this->marca frena a $this->velocidad km/h.";
}
return "El $this->marca está detenido.";
}
}
$miCoche = new Coche("Toyota");
echo "<p class='resultado'>" . $miCoche->acelerar() . "</p>";
echo "<p class='resultado'>" . $miCoche->acelerar() . "</p>";
echo "<p class='resultado'>" . $miCoche->frenar() . "</p>";
?>
</body>
</html>
Cómo funciona:
- class Coche: Define la clase con propiedades $marca y $velocidad.
- __construct($marca): Constructor que inicializa $marca.
- acelerar(): Aumenta $velocidad y devuelve un mensaje.
- frenar(): Reduce $velocidad con validación.
- $miCoche = new Coche("Toyota"): Crea un objeto.
- echo $miCoche->acelerar(): Llama a métodos y muestra resultados.
Salida esperada:
- El Toyota acelera a 10 km/h.
- El Toyota acelera a 20 km/h.
- El Toyota frena a 10 km/h.
Cómo probarlo:
- Con XAMPP:
- Guarda como coche.php en htdocs.
- Accede: http://localhost/coche.php.
- Con Repl.it: Pega el código y ejecuta.
- Verifica en el navegador y usa var_dump($miCoche) para depurar si es necesario.
Punto clave: Clases y objetos estructuran código reutilizable, como los modelos en Laravel.
Actividad rápida (5 minutos):
Modifica el ejemplo (en papel o editor) para añadir un método detener() que ponga $velocidad a 0. Solución sugerida:
public function detener() {
$this->velocidad = 0;
return "El $this->marca está detenido.";
}
Herencia (20 minutos)
Explicación:
La herencia permite que una clase (hija) herede propiedades y métodos de otra (padre), usando extends. Esto fomenta la reutilización de código.
Sintaxis:
class Padre {
public $propiedad;
}
class Hija extends Padre {
public function metodoHija() {
return $this->propiedad;
}
}
Ejemplo:
Extender la clase "Coche" para un "CocheElectrico":
<?php
class Coche {
public $marca;
public function __construct($marca) {
$this->marca = $marca;
}
public function acelerar() {
return "$this->marca acelera.";
}
}
class CocheElectrico extends Coche {
public $bateria = 100;
public function cargar() {
$this->bateria = 100;
return "$this->marca está cargado al $this->bateria%.";
}
}
$tesla = new CocheElectrico("Tesla");
echo $tesla->acelerar() . "<br>"; // Tesla acelera.
echo $tesla->cargar(); // Tesla está cargado al 100%.
?>
Cómo funciona:
- CocheElectrico extends Coche: Hereda $marca y acelerar().
- $bateria y cargar(): Nuevos en la clase hija.
- $tesla: Objeto que usa métodos de ambas clases.
Punto clave: La herencia organiza jerarquías, como en Laravel donde los modelos heredan de una clase base (Model).
Actividad rápida (5 minutos):
Escribe en papel o editor una clase CocheDeportivo que herede de Coche y añada un método turbo(). Solución sugerida:
class CocheDeportivo extends Coche {
public function turbo() {
return "$this->marca activa el turbo.";
}
}
Resumen y preparación para la tarea (25 minutos)
Resumen:
- POO: Organiza código en clases y objetos.
- Clases y objetos: Plantillas (class) e instancias (new).
- Propiedades y métodos: Datos ($variable) y funciones dentro de clases.
- Herencia: extends para reutilizar código.
- Ejemplo: Clase "Coche" con acelerar() y frenar().
- Estos conceptos son la base para modelos y controladores en Laravel.
Preparación para la tarea:
La tarea pide crear una clase Usuario con métodos para registrar y mostrar datos.
- Estrategia:
- Define una clase Usuario con propiedades como $nombre y $email.
- Crea un método registrar($nombre, $email) para asignar valores.
- Crea un método mostrarDatos() para devolver los datos.
- Usa un constructor para inicializar (opcional).
- Muestra los resultados en una página HTML.
- Lógica básica:
class Usuario { public $nombre; public $email; public function registrar($nombre, $email) { $this->nombre = $nombre; $this->email = $email; } public function mostrarDatos() { return "Nombre: $this->nombre, Email: $this->email"; } }
Punto clave: La tarea refuerza la creación de clases y métodos, habilidades esenciales para modelar entidades en Laravel.
Tarea práctica: Crea una clase “Usuario” con métodos para registrar y mostrar datos
Instrucciones:
- Crea un programa PHP que defina una clase Usuario con:
- Propiedades: $nombre y $email (al menos).
- Método registrar($nombre, $email): Asigna valores a las propiedades.
- Método mostrarDatos(): Devuelve una cadena con los datos del usuario.
- Usa:
- Una página HTML para mostrar los resultados.
- Al menos un objeto de la clase Usuario.
- echo para mostrar el resultado de mostrarDatos().
- Asegúrate de:
- Usar visibilidad public para propiedades y métodos (por simplicidad).
- Incluir estilos básicos con CSS.
- Probar con al menos dos usuarios diferentes.
- Usa el siguiente código como guía:
<!DOCTYPE html>
<html lang="es">
<head>
<title>Clase Usuario</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 20px auto;
text-align: center;
}
h1 {
color: #2c3e50;
}
.usuario {
background-color: #f9f9f9;
padding: 15px;
margin: 10px 0;
border-radius: 5px;
}
</style>
</head>
<body>
<h1>Registro de Usuarios</h1>
<?php
class Usuario {
public $nombre;
public $email;
public function registrar($nombre, $email) {
$this->nombre = $nombre;
$this->email = $email;
}
public function mostrarDatos() {
return "Nombre: $this->nombre, Email: $this->email";
}
}
// Crear usuarios
$usuario1 = new Usuario();
$usuario1->registrar("Ana López", "ana@correo.com");
echo "<div class='usuario'>" . $usuario1->mostrarDatos() . "</div>";
$usuario2 = new Usuario();
$usuario2->registrar("Luis García", "luis@correo.com");
echo "<div class='usuario'>" . $usuario2->mostrarDatos() . "</div>";
?>
</body>
</html>
- Prueba el archivo:
- Con XAMPP:
- Guarda como usuario.php en htdocs.
- Accede: http://localhost/usuario.php.
- Con Repl.it: Pega el código y ejecuta.
- Prueba:
- Verifica que se muestren los datos de ambos usuarios.
- Cambia los nombres/emails y confirma que se actualizan.
- Usa var_dump($usuario1) o revisa php_error.log (en XAMPP) para depurar errores.
- Con XAMPP:
Ejemplo de solución esperada:
El código anterior es funcional. En el navegador:
- Una página con título "Registro de Usuarios".
- Dos bloques estilizados que muestran:
- "Nombre: Ana López, Email: ana@correo.com".
- "Nombre: Luis García, Email: luis@correo.com".
Tiempo estimado: 30-40 minutos (puedes hacerlo después de la lección).
Entregable: Archivo usuario.php con una clase Usuario funcional. Puedes compartir el código o describirlo para que lo revise.
Consejo: Prueba añadir una propiedad $edad y un método para verificar si es mayor de edad como mejora opcional.