Comunidad PHPeros
Lenguajes => PHP => (POO) Programación Orientada a Objetos => Mensaje iniciado por: WarezD@rK en 11 de Febrero de 2010, 01:19:08 am
-
Debido a que un par de foreros me lo han pedido, voy a hacer un pequeño tutorial sobre clases en PHP.
La programación orientada a objetos (POO u OOP en inglés) se usa en muchos lenguajes y en PHP desde su versión 5, cosa que deja una puerta abierta hacia su futuro como lenguaje. Desde mi punto de vista, este tipo de programación es muy importante, teniendo en cuenta que cada vez se utiliza más e ignorar su existencia nos complicaría la vida bastante al querer encontrar trabajo en este campo puesto que estos conocimientos son a veces requeridos.
Las clases agrupan en una misma estructura variables y funciones las cuales pueden ser públicas, privadas o protegidas. Este tutorial pretende ser una introducción, por lo que nos centraremos solo en las públicas y privadas.
La estructura de una clase es muy sencilla:
<?php
class miClase // Nombre de la clase.
{
// Variables a usar en nuestra clase.
var $variable;
// Funciones de nuestra clase.
public function mostrarVariable()
{
$this->variable = "Hola mundo\n";
return $this->variable;
}
}
?>
Y su ejecución (debemos guardar la clase, por ejemplo, como "miClase.php"):
<?php
// Yo utilizo require_once para incluir solo una vez la clase,
// ya que a veces puede ser que necesitemos llamar a una
// clase desde una función y si la ejecutamos más de una vez,
// nos lanzaría un error.
require_once("miClase.php");
$consulta = new miClase(); // Declaramos la variable del tipo "miClase".
echo $consulta->mostrarVariable(); // Mostramos el resultado obtenido de la función.
?>
Si os fijáis, cuando tratamos dentro de nuestra clase las variables, les hacemos referencia con $this->variable, ("variable" es el nombre de nuestra variable sin "$"). Esto es muy útil cuando trabajamos con variables privadas, ya que estas solo pueden ser modificadas internamente, por lo que desde la misma clase controlamos su contenido.
Para declarar una variable privada, solo debemos cambiar "var" por "private" (solo se pueden declarar como privadas las variables de la clase, no las que declaramos dentro de las funciones, puesto que estas por defecto solo son visibles dentro).
Entonces, si son privadas, ¿cómo las podemos modificar?. Pues para ello debemos crear una función para modificar esa variable, por ejemplo, basándonos en el código anterior:
<?php
class miClase
{
private $variable;
public function cambiarVariable($xNuevoValor)
{
$this->variable = $xNuevoValor;
}
public function mostrarVariable()
{
return $this->variable;
}
}
?>
Y su ejecución:
<?php
require_once("miClase.php");
$consulta = new miClase();
$consulta->cambiarVariable("Contenido nuevo");
echo $consulta->mostrarVariable();
?>
Es muy importante tener en cuenta que las funciones de la clase deben ser públicas (public) para poder utilizarlas fuera de ella y decir también que si no indicamos que es pública o privada, por defecto PHP las establece como públicas. Yo personalmente siempre indico el tipo, de esta forma veo con más facilidad qué tipo de funciones estoy creando.
Otra cosa imprescindible en una clase es un constructor. Esto sirve para definir unos valores por defecto al hacer referencia a nuestra clase. El constructor es una función con un nombre estático "__construct" (doble guión bajo):
<?php
class coche
{
private $marca;
private $modelo;
private $color;
private $precio;
// La función _construct se ejecuta automáticamente
// al crear el nuevo objeto.
function __construct()
{
// Estos valores serán los valores
// por defecto de nuestros coches.
$this->marca = "Sin marca";
$this->modelo = "Sin modelo";
$this->color = "Transparente";
$this->precio = 0;
}
public function establecerValores($xMarca, $xModelo, $xColor, $xPrecio)
{
$this->marca = $xMarca;
$this->modelo = $xModelo;
$this->color = $xColor;
$this->precio = $xPrecio;
}
public function mostrarCoche()
{
echo "Marca: ".$this->marca."\n";
echo "Modelo: ".$this->modelo."\n";
echo "Color: ".$this->color."\n";
echo "Precio: ".$this->precio." euros\n";
}
}
?>
Y su ejecución:
<?php
require_once("claseCoche.php");
$coche = new coche();
// Si mostramos ahora nuestro coche,
// obtendríamos los valores por defecto.
$coche->mostrarCoche(); // Esto devuelve:
// Marca: Sin marca
// Modelo: Sin modelo
// Color: Transparente
// Precio: 0 euros
$coche->establecerValores("Opel", "Astra", "Blanco", 24000);
// De esta forma, hemos modificado los valores por defecto.
$coche->mostrarCoche(); // Esto devuelve:
// Marca: Opel
// Modelo: Astra
// Color: Blanco
// Precio: 24000 euros
?>
Tal vez parezca algo laborioso para mostrar unas simple variables, pero esto es solo un ejemplo sencillo para entender su funcionamiento. Ahora os pondré un ejemplo más elaborado de cómo utilizar las clases:
<?php
// Crearemos una clase para modificar el tamaño
// de una imagen usando la librería GD.
class imagenGD
{
// Definimos las variables
// a usar en nuestra clase.
private $imagen;
private $ancho;
private $alto;
private $calidad;
// Creamos el constructor para los valores
// por defecto. Al introducir un argumento,
// obligamos que al llamar a nuestra clase,
// se introduzca directamente.
function __construct($xImagen)
{
// Obtenemos el tipo de imagen.
$tipoImagen= exif_imagetype($xImagen);
// Filtramos el tipo de imagen
// para crear la nueva a partir de
// la indicada.
if($tipoImagen == IMAGETYPE_JPEG)
{
$this->imagen = imagecreatefromjpeg($xImagen);
}
elseif($tipoImagen == IMAGETYPE_GIF)
{
$this->imagen = imagecreatefromgif($xImagen);
}
elseif($tipoImagen == IMAGETYPE_WBMP)
{
$this->imagen = imagecreatefromwbmp($xImagen);
}
elseif($tipoImagen == IMAGETYPE_PNG)
{
$this->imagen = imagecreatefrompng($xImagen);
}
else
{
$this->imagen = imagecreatefromjpeg($xImagen);
}
// Establecemos los valores por defecto
// del resto de atributos.
$this->ancho = 50;
$this->alto = 50;
$this->calidad = 100;
}
// Creamos una función para cambiar el tamaño.
public function nuevoTamano($xAncho, $xAlto)
{
$this->ancho = $xAncho;
$this->alto = $xAlto;
}
// Creamos una función para cambiar la calidad.
public function nuevaCalidad($xCalidad)
{
$this->calidad = $xCalidad;
}
// Creamos una función para mostrar
// la imagen sin guardarla.
public function dibujar()
{
// Creamos la imagen.
$thumb = imagecreatetruecolor($this->$ancho, $this->alto);
// La mostramos sin guardarla.
imagejpeg($thumb);
// Liberamos la memoria usada.
imagedestroy($this->imagen);
}
// Creamos una función para guardar
// la imagen en la ruta indicada.
public function guardar($xDestino)
{
// Creamos la imagen.
$thumb = imagecreatetruecolor($this->$ancho, $this->alto);
// Cambiamos su tamaño.
imagecopyresampled($thumb, $this->imagen, 0, 0, 0, 0, $this->ancho, $this->alto, imagesx($this->imagen), imagesy($this->imagen));
// La guardamos en la ruta especificada.
imagejpeg($thumb, $xDestino, $this->calidad);
// Liberamos la memoria usada.
imagedestroy($this->imagen);
}
}
?>
De esta forma, ya tenemos una clase imagenGD con distintos tipos de ejecución que os pondré a continuación:
1. Mostrar una imagen modificada con tamaño por defecto:
<?php
require_once("claseGD.php");
$miImagen = new imagenGD("carpeta/mi_imagen.jpg");
$miImagen->dibujar();
// Con solo estas dos líneas ya obtendríamos nuestra imagen
// tratada con ancho = 50; alto = 50; y calidad = 100;
// sin introducir nada más que la imagen a tratar y la función
// que la muestra (dibujar).
?>
2. Guardar una imagen modificada con tamaño por defecto:
<?php
require_once("claseGD.php");
$miImagen = new imagenGD("origen/mi_imagen.jpg");
$miImagen->guardar("destino/nueva_imagen.jpg");
?>
3. Mostrar una imagen modificada por completo:
<?php
require_once("claseGD.php");
$miImagen = new imagenGD("origen/mi_imagen.jpg");
$miImagen->nuevoTamano(500, 300);
$miImagen->nuevaCalidad(85);
$miImagen->dibujar();
?>
4. Guardar una imagen modificada por completo:
<?php
require_once("claseGD.php");
$miImagen = new imagenGD("origen/mi_imagen.jpg");
$miImagen->nuevoTamano(500, 300);
$miImagen->nuevaCalidad(85);
$miImagen->guardar("destino/nueva_imagen.jpg");
?>
Solo con una clase hemos obtenido distintos comportamientos y esto solo es un pequeño ejemplo.
Las clases pueden ser mucho más complejas y funcionales y sobretodo, reciclables en otros proyectos. Todo el trabajo que empleéis en construir una clase, si la programáis bien, os lo ahorraréis cuando la necesitéis de nuevo.
Yo os he abierto una puerta, el resto es cosa vuestra.
Un saludo :)
-
Imagino que será conveniente estudiar un poco más lo de las clases... el futuro :/
Por cierto, buen tuto!
-
buenisimo! no te doy +5 porque no puedo, asi que +1
-Pregunta-
Por que en esta lineas:
$thumb = imagecreatetruecolor($this->$ancho, $this->alto);
Pones $ antes del $ancho? No deberia ser sin el $?
EDIT:
Segunda pregunta,
imagejpeg($thumb);
que pasa si no es jpeg?
-
buenisimo! no te doy +5 porque no puedo, asi que +1
-Pregunta-
Por que en esta lineas:
Pones $ antes del $ancho? No deberia ser sin el $?
Muy buena mara, se me ha colado el $. Eso es señal de que lo has leído :)
EDIT:
Segunda pregunta,que pasa si no es jpeg?
No pasa nada, puedes devolver cualquier formato compatible con GD o devolver el mismo formato que creas.
Solo era un ejemplo, puedes amoldar el código a tu gusto.
-
Gracias por esta introducción a las clases.
Ahora me pongo a ejercerla, pero está muy buena, se ve que ya sos uno de los "programadores modernos" xD.
Saludos, y +1 ;)
-
Muy buena mara, se me ha colado el $. Eso es señal de que lo has leído :)
No pasa nada, puedes devolver cualquier formato compatible con GD o devolver el mismo formato que creas.
Solo era un ejemplo, puedes amoldar el código a tu gusto.
Entonces entendí perfecto :D el problema es cuando me lo pongo a hacer "de memoria".
-
Vale ya lo he entendido todo y estoy comenzando a usar las clases en mis proyectos. Lo único que tengo es una pequeña duda:
¿El construct define algo así como los parámetros de la clase?, por ejemplo:
<?php
class prueba
{
private $nombre;
function __construct($xNombre)
{
$this->nombre = $xNombre;
}
function mostrar()
{
echo $this->nombre;
}
}
?>
Ahora en el archivo que lo muestro:
<?php
$name = new prueba("Kevin");
$name->mostrar();
?>
Resumiendo, mi pregunta es si el anterior código funcionaría con algo como así:
<?php
function mostrar($datos)
{
echo $datos;
}
mostrar("Kevin");
?>
En resumen: ¿La función __construct sirve para añadir una especie de "parámetros" a la clase?
Saludos.
-
Hola,
El método (función de una clase) __construct se llama automáticamente al crear el objeto (Es decir, al hacer: $item = new Objeto(); )
También puede tener parámetros (__construct($id, $nombre)) y lo llamas así: $item = new Objeto(3, "Carlos");
Tu puedes hacer con el método __construct lo que te quieras, y lo que mejor te convenga, ya sea darle valores a unas variables como has hecho antes o realizar otras tareas, como por ejemplo hacer un echo, o llamar a otro método de la clase... lo que sea, es al fin y al cabo un método mas, lo único que lo diferencia del resto de métodos es que se llama automáticamente al crear el objeto.
Y si, los códigos que has puesto imprimirían lo mismo en la pantalla.
Saludos!
-
Vale ya la entiendo más, gracias por la explicación TLX ;)
-
Muy buena explicación, me ha servido bastante :)
-
Muy bueno, de verdad!
Mis enhorabuenas ;)
-
Excelente explicación... Muchas gracias a los dos ;)
-
Tengo una duda existencial... ¿Por qué muchos colocan "var" en vez del modo de acceso? ¿Qué función ejerce "var"?
-
Tengo una duda existencial... ¿Por qué muchos colocan "var" en vez del modo de acceso? ¿Qué función ejerce "var"?
Var hace que la variable sea pública, yo creo que lo hacen por pura comodidad.
-
Var hace que la variable sea pública, yo creo que lo hacen por pura comodidad.
En ese caso, si el PHP tomará por default el private, lo tomaría privado.
Yo aconsejaría usar siempre public y private... También para los métodos.
-
Esta bueno el tutorial
aunque no conosco mucho de programacion orientada a objetos
lo que estoy aprendiendo es C# que es casi lo mismo pero
se me dificulta asi que aprendero esto para que se me facilite es casi lo mismo
-
Esta bueno el tutorial
aunque no conosco mucho de programacion orientada a objetos
lo que estoy aprendiendo es C# que es casi lo mismo pero
se me dificulta asi que aprendero esto para que se me facilite es casi lo mismo
C# es un lenguaje orientado a objetos también. La programación orientada a objetos es una "técnica", un "estilo de programar". Si aprendes los fundamentos de la programación orientada a objetos, no te costará manejar ningún lenguaje que sea de este tipo.
-
Muy bueno el tuto me sirvió de gran ayuda :P
-
muy util, la verdad suelo olvidar la sintaxis pues nunca aplico la poo en mis proyectos, gracias.
-
muy util, la verdad suelo olvidar la sintaxis pues nunca aplico la poo en mis proyectos, gracias.
La sintaxis es muy sencilla, es practicarlo ..