7. Creating first php class for our project
Tutorial para Principiantes: Creando Tu Primera Clase en PHP
📚 Tema del Tutorial:
"Programación Orientada a Objetos (POO) en PHP: Tu Primera Clase desde Cero"
🎯 Objetivo de Aprendizaje
Al final de este tutorial entenderás:
Qué es una clase en PHP y para qué sirve
Cómo crear métodos (funciones) dentro de una clase
Qué es la visibilidad (public, private, protected)
Cómo instanciar objetos desde una clase
La diferencia entre clases, objetos y métodos
📂 Parte 1: ¿Qué es una Clase en PHP?
La Analogía del Molde de Galletas
Imagina que una clase PHP es como un molde para hacer galletas:
text
🏭 MOLDE DE GALLETAS (Clase PHP)
├── 🎨 Forma: Corazón, estrella, círculo
├── 📏 Tamaño: Pequeño, mediano, grande
└── 🛠️ Función: Cortar masa uniformemente
Cada galleta que haces con ese molde:
text
🍪 GALLETA 1 (Objeto 1) = Creada con el molde
🍪 GALLETA 2 (Objeto 2) = Creada con el mismo molde
🍪 GALLETA 3 (Objeto 3) = Creada con el mismo molde
En términos de programación:
Clase = Molde (define características y funciones)
Objeto = Galleta individual (instancia concreta)
Método = Acción que puede hacer (hornear, decorar)
🏗️ Parte 2: Estructura Básica de una Clase
Componentes de una Clase:
text
📁 CLASE PHP
├── 📝 NOMBRE: Whisper (empieza con mayúscula)
├── 🛡️ PROPIEDADES: Variables internas ($error, $DB, etc.)
├── 🏗️ CONSTRUCTOR: __construct() (se ejecuta al crear objeto)
└── ⚙️ MÉTODOS: Funciones (upload(), covert(), etc.)
Creando Nuestra Primera Clase - Paso a Paso:
Paso 1: Crear el archivo de la clase
text
📍 Ubicación: backend/classes/Whisper.php
Código inicial:
php
<?php
class Whisper {
// Aquí dentro van las propiedades y métodos
}
?>
Reglas importantes para nombres de clases:
✅ Empieza con mayúscula: Whisper
✅ Usa PascalCase: MiClase, ClasePrincipal
✅ Nombre relacionado con su función
❌ No usar espacios: Mi Clase (incorrecto)
❌ No empezar con números: 1Clase (incorrecto)
⚙️ Parte 3: Creando Métodos (Funciones) dentro de la Clase
¿Qué es un Método?
Un método es simplemente una función que vive dentro de una clase. Piensa en ello como:
text
🏢 EMPRESA (Clase)
├── 👨💼 EMPLEADO 1 (Método upload()) - Sube archivos
├── 👩💼 EMPLEADO 2 (Método covert()) - Convierte audio
└── 👨💼 EMPLEADO 3 (Método save()) - Guarda en base de datos
Creando el Método upload():
Estructura básica de un método:
php
public function upload($parametro){
// Código que ejecuta el método
return $resultado;
}
Desglose visual:
text
public → 🚪 Puerta abierta (acceso público)
function → 📋 Esto define una función
upload → 🏷️ Nombre del método
($parametro) → 📦 Información que recibe
{ ... } → 🧱 Cuerpo del método (código)
return → 📤 Lo que devuelve al terminar
Nuestro Primer Método Completo:
php
public function upload($file){
return $file; // ← Por ahora solo devuelve lo que recibe
}
🛡️ Parte 4: Visibilidad - Public, Private, Protected
Los 3 Niveles de Acceso (Como una Casa):
text
🏠 CASA (Clase)
├── 🚪 SALÓN (public) - Todos pueden entrar
├── 🛌 DORMITORIO (private) - Solo dueños de casa
└── 🏡 JARDÍN (protected) - Familia y amigos cercanos
Explicación detallada:
🔓 Public (Público):
php
public function upload(){}
Accesible desde cualquier lugar
Cualquier parte del código puede usarlo
Como una librería pública que cualquiera puede usar
🔒 Private (Privado):
php
private function procesarInternamente(){}
Solo accesible DESDE DENTRO de la clase
Otras clases NO pueden usarlo
Como tu diario personal (solo tú lo lees)
🔐 Protected (Protegido):
php
protected function heredar(){}
Accesible desde la clase y clases hijas
Como recetas familiares (solo familia las sabe)
¿Cuándo usar cada uno?
🏭 Parte 5: Instanciando la Clase - Creando Objetos
La Diferencia entre Clase y Objeto:
Clase vs Objeto - Analogía del Plano y la Casa:
text
📐 PLANOS DE CASA (Clase)
├── Define: Número de habitaciones
├── Define: Ubicación de puertas
├── Define: Tamaño de ventanas
└── Es solo un diseño en papel
🏠 CASA CONSTRUIDA (Objeto)
├── Tiene: 3 habitaciones REALES
├── Tiene: Puertas REALES que se abren
├── Tiene: Ventanas REALES con vidrio
└── Es algo concreto que puedes usar
Creando un Objeto desde la Clase:
Código en init.php:
php
<?php
// 1️⃣ Cargar la clase (traer los planos)
require 'classes/Whisper.php';
// 2️⃣ Crear objeto (construir la casa)
$whisperObj = new Whisper();
// 3️⃣ Usar el objeto (vivir en la casa)
$resultado = $whisperObj->upload($archivo);
?>
Explicación del operador ->:
php
$objeto->metodo();
// Se lee como: "El objeto, ejecuta su método"
Comparación con funciones normales:
php
// Función normal (procedimental)
upload($archivo);
// Método de objeto (POO)
$whisperObj->upload($archivo);
🔗 Parte 6: El Archivo init.php - El "Director de Orquesta"
Función de init.php:
init.php es como el director de orquesta de tu aplicación:
text
🎼 DIRECTOR DE ORQUESTA (init.php)
├── 🎻 Violín 1 = Clase DB (base de datos)
├── 🎺 Trompeta = Clase Whisper (procesamiento)
├── 🥁 Batería = Configuraciones
└── 👨✈️ Director = Crea objetos y los prepara
Código completo de init.php:
php
<?php
// 🎻 Traer los "instrumentos" (clases)
require 'classes/DB.php'; // Base de datos
require 'classes/Whisper.php'; // Procesamiento de audio
// 👨✈️ El director prepara los músicos (crea objetos)
$whisperObj = new Whisper(); // Listo para tocar!
?>
Ventajas de usar init.php:
Organización: Todo en un lugar
Reutilización: Solo incluye init.php donde necesites
Mantenimiento: Cambias en un solo lugar
Claridad: Código más limpio y entendible
🧪 Parte 7: Probando Nuestra Clase - El Ciclo Completo
Flujo de Prueba Paso a Paso:
text
[1️⃣ index.php] → Incluye init.php
↓
[2️⃣ init.php] → Carga Whisper.php + Crea $whisperObj
↓
[3️⃣ index.php] → Usuario selecciona archivo
↓
[4️⃣ JavaScript] → Envía formulario automáticamente
↓
[5️⃣ index.php] → POST llega al servidor
↓
[6️⃣ PHP] → $whisperObj->upload($_FILES['file'])
↓
[7️⃣ Whisper.php] → Ejecuta método upload()
↓
[8️⃣ Resultado] → Devuelve información del archivo
Código de prueba en index.php:
php
<?php
include 'backend/init.php';
if($_SERVER['REQUEST_METHOD'] === "POST"){
if(isset($_FILES['file'])){
// Llamar al método upload() de nuestra clase
$resultado = $whisperObj->upload($_FILES['file']);
// Ver qué nos devolvió (para depurar)
var_dump($resultado);
}
}
?>
Lo que deberías ver en el navegador:
php
array(5) {
["name"]=> string(9) "audio.mp3"
["type"]=> string(10) "audio/mpeg"
["tmp_name"]=> string(14) "/tmp/phpX1Y2Z3"
["error"]=> int(0)
["size"]=> int(1024000)
}
Interpretación del resultado:
name = Nombre original del archivo
type = Tipo MIME (audio/mpeg, video/mp4)
tmp_name = Ubicación temporal en el servidor
error = Código de error (0 = éxito)
size = Tamaño en bytes
🎨 Parte 8: Diagrama Visual de la Clase Completa
text
📁 backend/classes/Whisper.php
└── 🏗️ CLASS Whisper
├── 🛡️ PROPIEDADES (variables)
│ ├── 🔴 $error
│ ├── 🟢 $dataType
│ ├── 🔵 $file
│ ├── 🟡 $lang
│ ├── 🟣 $content
│ └── ⚫ $DB (private)
│
├── 🏗️ CONSTRUCTOR __construct()
│ └── 📦 Crea conexión a base de datos
│
└── ⚙️ MÉTODOS (funciones)
├── 🔓 public upload($file)
├── 🔓 public covert()
├── 🔓 public getApiUrl()
├── 🔓 public getHeader()
├── 🔓 public getData()
├── 🔓 public getFile()
└── 🔓 public errors()
🧩 Parte 9: Ejercicio Práctico - Crea Tu Propia Clase
Ejercicio 1: Clase "Calculadora"
Crea Calculadora.php:
php
<?php
class Calculadora {
public function sumar($a, $b){
return $a + $b;
}
public function restar($a, $b){
return $a - $b;
}
public function multiplicar($a, $b){
return $a * $b;
}
public function dividir($a, $b){
if($b == 0){
return "Error: No se puede dividir por cero";
}
return $a / $b;
}
}
?>
Usa la clase en otro archivo:
php
<?php
require 'Calculadora.php';
$calc = new Calculadora();
echo "5 + 3 = " . $calc->sumar(5, 3) . "<br>";
echo "10 - 4 = " . $calc->restar(10, 4) . "<br>";
echo "6 * 7 = " . $calc->multiplicar(6, 7) . "<br>";
echo "15 / 3 = " . $calc->dividir(15, 3) . "<br>";
?>
Ejercicio 2: Clase "Usuario" con Constructor
php
<?php
class Usuario {
private $nombre;
private $email;
// Constructor: Se ejecuta al crear el objeto
public function __construct($nombre, $email){
$this->nombre = $nombre;
$this->email = $email;
}
public function saludar(){
return "Hola, soy " . $this->nombre;
}
public function getEmail(){
return $this->email;
}
private function validarEmail(){
// Método privado: solo se usa dentro de la clase
return filter_var($this->email, FILTER_VALIDATE_EMAIL);
}
}
// Uso:
$usuario1 = new Usuario("Ana", "ana@email.com");
echo $usuario1->saludar(); // "Hola, soy Ana"
?>
🔍 Parte 10: Depuración y Errores Comunes
Problema 1: "Clase no encontrada"
Error: Fatal error: Class 'Whisper' not found
Causa: Ruta incorrecta en require
Solución:
php
// INCORRECTO
require 'Whisper.php';
// CORRECTO (desde init.php)
require 'classes/Whisper.php';
Problema 2: "Método no definido"
Error: Call to undefined method Whisper::upload()
Causas posibles:
Nombre del método mal escrito
Método es private/protected
Olvidaste incluir la clase
Solución:
php
// Verifica que el método existe y es public
public function upload(){ // ← Debe ser public
// código
}
Problema 3: "Fallo al abrir archivo"
Error típico: El nombre del archivo debe coincidir EXACTAMENTE:
text
✅ Whisper.php (con W mayúscula)
✅ require 'classes/Whisper.php'
❌ whisper.php (w minúscula) ← ERROR en Linux/Unix
❌ WHISPER.php (todo mayúscula)
📊 Parte 11: Ventajas de Usar Clases (POO)
Comparación: Procedimental vs Orientado a Objetos
Beneficios específicos para nuestro proyecto:
🧩 Modularidad: Cada clase hace una cosa específica
🔒 Encapsulamiento: Datos protegidos dentro de objetos
🔄 Reutilización: Usa Whisper en cualquier parte del proyecto
🛠️ Extensibilidad: Añade nuevos métodos fácilmente
🐛 Depuración: Errores más fáciles de localizar
❓ Parte 12: Cuestionario de Evaluación
Pregunta 1:
En la analogía del molde de galletas, ¿qué representa la clase?
a) La galleta individual
b) El horno donde se hornean
c) El molde para hacer galletas ✅
d) Los ingredientes de la masa
Explicación: La clase es el molde (el diseño), los objetos son las galletas individuales.
Pregunta 2:
¿Cuál es la diferencia principal entre una función normal y un método?
a) Los métodos son más rápidos
b) Los métodos están dentro de una clase ✅
c) Las funciones pueden recibir parámetros
d) Los métodos no pueden devolver valores
Pregunta 3:
¿Qué significa que un método sea public?
a) Que solo se puede usar dentro de la clase
b) Que se puede acceder desde cualquier lugar ✅
c) Que es invisible para otros archivos
d) Que requiere contraseña para usarse
Pregunta 4:
En esta línea, ¿qué hace la palabra new?
php
$whisperObj = new Whisper();
a) Crea una nueva variable
b) Instancia un objeto desde la clase ✅
c) Borra la clase anterior
d) Cambia el nombre de la clase
Pregunta 5:
¿Para qué sirve el archivo init.php en nuestro proyecto?
a) Para contener los estilos CSS
b) Para cargar clases y crear objetos ✅
c) Para almacenar imágenes
d) Para validar formularios
Pregunta 6:
¿Qué operador se usa para acceder a métodos de un objeto?
a) -> (flecha) ✅
b) . (punto)
c) :: (doble dos puntos)
d) => (flecha gruesa)
Explicación: En PHP usamos -> para objetos, . se usa para concatenar cadenas.
Pregunta 7:
¿Por qué es importante que el nombre del archivo de clase coincida exactamente?
a) Porque PHP es sensible a mayúsculas/minúsculas en Linux/Unix ✅
b) Porque los navegadores lo requieren
c) Porque mejora el rendimiento
d) Porque es una regla de HTML
🏆 Resumen Final - Reglas para Clases PHP
Las 5 Reglas de Oro de las Clases:
🏷️ Nombres con mayúscula: Class MiClase
📁 Un archivo por clase: MiClase.php
🛡️ Define visibilidad: public, private, protected
🏗️ Usa constructor: __construct() para inicializar
🔗 Instancia con new: $objeto = new Clase()
Checklist de tu Primera Clase:
✅ Archivo creado: backend/classes/Whisper.php
✅ Clase definida: class Whisper { }
✅ Método creado: public function upload()
✅ Parámetro recibido: ($file)
✅ Algo devuelve: return $file;
✅ Archivo init.php actualizado: Carga la clase
✅ Objeto instanciado: $whisperObj = new Whisper();
✅ Método llamado: $whisperObj->upload($_FILES['file']);
✅ Resultado mostrado: var_dump($resultado);
🚀 Próximos Pasos - Lo que Viene
En la siguiente lección añadiremos:
Validación real en el método upload()
Verificación de tipos de archivo permitidos
Límites de tamaño máximo
Movimiento seguro del archivo temporal
Manejo de errores apropiado
Ejemplo de cómo evolucionará nuestro método:
php
public function upload($file){
// Validar tipo
if(!in_array($file['type'], $tiposPermitidos)){
$this->error = "Tipo de archivo no permitido";
return false;
}
// Validar tamaño
if($file['size'] > $tamañoMaximo){
$this->error = "Archivo demasiado grande";
return false;
}
// Mover a ubicación permanente
$nuevaUbicacion = 'files/' . uniqid() . '.mp3';
move_uploaded_file($file['tmp_name'], $nuevaUbicacion);
return $nuevaUbicacion;
}
📚 Recursos para Continuar Aprendiendo
Conceptos POO para explorar:
Herencia: class VideoWhisper extends Whisper
Interfaces: interface Procesador { function procesar(); }
Traits: trait Loggeable { function log() { ... } }
Namespaces: namespace MyApp\Audio;
Clases abstractas: abstract class ProcesadorBase
Proyectos para practicar POO:
Sistema de blog con clases: Usuario, Post, Comentario
Carrito de compras: Producto, Carrito, Pedido
Sistema de reservas: Hotel, Habitación, Reserva
Juego simple: Jugador, Enemigo, Item
¡Felicidades! 🎊 Has creado tu primera clase en PHP. Has dado el paso más importante en programación orientada a objetos. ¡Recuerda que la práctica hace al maestro!
💡 Consejo final para principiantes:
Al crear clases, piensa siempre en:
Responsabilidad única: Cada clase debe hacer UNA cosa bien
Nombres descriptivos: Whisper sugiere que procesa audio
Métodos pequeños: Divide funcionalidad en métodos específicos
Prueba cada parte: Verifica que cada método hace lo esperado
🚀 ¡Ahora tienes la estructura base de tu aplicación!
Comentarios
Publicar un comentario