Twitter Flickr Pinterest LinkedIn YouTube Google Maps E-mail RSS
formats

Ventajas de la utilización de clases en php. Caso práctico.

Las clases proporcionan un mecanismo para poder desarrollar  plantillas e instanciar objetos de ellas. Separan los datos (atributos) de los métodos (funciones o procedimientos). Realmente son moldes para la construcción de objetos.

Gracias a las clases, es posible implementar la programación orientada a objetos.La POO u OOP posee numerosas ventajas, entre las que destacan principalmente la reutilización de código, y mejora en el desarrollo de los programas. Para ello es necesario cambiar la manera de pensar, adecuar nuestros programas a la filosofía del objeto y desarrollo de la jerarquía de clases.

Abstraer y modelar la realidad son elementos claves a la hora de crearlas.

Al utilizar clases en php, podemos beneficiarnos de la reutilización de código, puesto que una vez creadas, podemos utilizarlas mediante la inclusión en cualquiera de nuestros proyectos php (web o locales).

En si mismas aceleran el desarrollo, es más, gracias a la herencia podemos aprovechar lo anteriormente programado. La encapsulación, herencia y polimorfismo, características básicas y esenciales enla OPP se consiguen gracias  a la clases.

Otras ventajas que se logran:

Permite crear sistemas programados más complejos.

Relacionar el sistema al mundo real.

Facilita la creación de programas visuales.

Permiten la construcción de prototipos.

Agilizan el desarrollo de software.

 

Además dos características fundamentales en el software que se da hoy en dia:

Facilitan el trabajo en equipo.

Facilitan el mantenimiento del software.

Para finalizar, las clases son la esencia, el elemento principal en todo programa orientado a objetos. Sus elementos programados definirán los futuros objetos creados.

 

Veamos un sencillo caso práctico.

Enunciado ejemplo:

Crear una clase Persona, con atributos nombre, apellido y teléfono. Controlar que el teléfono solo acepte 9 dígitos.

Crear una clase Cuenta, con atributos numeroCuenta, saldo y propietario. El propietario es un objeto tipo Persona.

Crear un constructor con parámetros y otro sin parámetros. Controlar que el saldo de la cuenta no debe ser menor que 0.

Crear un método llamado transaccion que ingrese como parámetros cantidad y tipoTransaccion; tipoTransaccion es “retiro” o “deposito”.Si es un retiro, la cantidad se resta del saldo, y si es deposito la cantidad se incrementa al saldo. El método transacción debe imprimir el tipo de transación y el nuevo saldo.

Crear en una clase llamada Principal, dos cuentas pertenecientes a dos personas distintas y hacer un deposito y un retiro en cada cuenta. Imprimir los valores de las personas, propietarios y transacciones.

Afinar el control de acceso (declaraciones public, private, etc.) de las variables, métodos y clases, para reforzar la separación entre interfaz e implementación de las mismas.

Manos a la obra …

Adjunto las 3 clases llamadas.

persona.inc.php

<?php
class persona
{
	private $nombre;
	private $apellido;
	private $telefono;
 
	// Controlamos el valor de telefono a 9 digitos
 
	function __construct($nombre, $apellido, $telefono)
	{
 
	$this->nombre=$nombre;
	$this->apellido=$apellido;
	$this->telefono=$telefono;
 
     }
 
 
	function set_telefono($telefono)
		{
		if (strlen($telefono) >= 9)
		   {
		   $this->telefono = $telefono;
		   }
		else
		  {
			return " <br/> Ejemplo de error: El valor del telefono es menor de 9 digitos";
		   }
		}
 
	function get_telefono()
	{
	 	return $this->telefono;	
	}
 
	function get_mombre_y_apellido()
	{
	 	return $this->nombre . " ". $this->apellido;	
	}
 
 
 
 
 
}
 
?>

 

cuenta.inc.php

<?php
// En esta clase he encontrado el problema de la sobrecarga de constructores, comento abajo la solución encontrada
class cuenta
{
	private $numerocuenta;
	private $saldo;
	private $propietario;
 
	// He investigado y no he encontrado la forma que PHP 5 soporte sobrecarga de constructores.
	// Por lo que he necesitado emplear un truco para emular la sobrecarga.
 
	function __construct()
		{
		$args = func_get_args();
		$nargs = func_num_args();
		switch($nargs) 
			{
			case 0:
			    // Si no posee parametros ir al constructor1
				self::__construct1();
				break;
 
			case 3:
				// Si posee 3 parametros in al constructor2
				self::__construct2($args[0], $args[1], $args[2]);
				break;
			}
         } 
 
		function __construct1()
			{
				$this->numerocuenta =12345678901234567890;
				$this->saldo = 100;
				$this->propietario = new persona("Carlos","Garcia","900 000 000");
			}
		function __construct2($cuenta, $saldo, $propietario)
			{
				$this->numerocuenta = $cuenta;
				if ($saldo > 0) 
				{
					$this->saldo = $saldo;
				}
				else
				  {
				  echo "El saldo que ha establecido es mejor que 0";
				  return 0;
				  }
				$this->propietario = $propietario;
			}
 
	   function get_datospersona()
	   	   {
			   // Para mostrar los datos de la persona, es curioso el empleo de 2 -> 
			   return $this->propietario->get_mombre_y_apellido();
 
		     }
	   function get_mostrarsaldo()
	       {
			 return $this->saldo; 
		   }
 
		// Pedido en la práctica
		function transaccion ($cantidad, $tipotransaccion)
			{
				switch ($tipotransaccion)
				{
			 		case "retiro":
						$this->saldo = $this->saldo - $cantidad;
						echo "<br/> El tipo de transaccion es de retiro, y el nuevo saldo es : " . $this->saldo;
						break;
					case "deposito":
						$this->saldo = $this->saldo + $cantidad;
						echo "<br/> El tipo de transaccion es de depósito, y el nuevo saldo es : " . $this->saldo;
						break;
					default:
						echo "<br/> El parámetro pasado como tipo no es válido </br>"; 
				}
 
			}
}
?>

principal.inc.php

<?php
class principal
{
	private $persona1;
	private $persona2;
	private $micuenta1;
	private $micuenta2;
 
 
	function __construct()
		{
	 		$this->persona1= new persona("Juan", "de la Cuesta", "645000000");
			$this->persona2= new persona("Pedro", "de la Cuesta", "652000000");
			$this->micuenta1=new cuenta("20106758947584",200,$this->persona1);
			$this->micuenta2=new cuenta("2011758947584",300,$this->persona2);
			$this->micuenta1->transaccion(100,"retiro");
			$this->micuenta1->transaccion(200,"deposito");
			// Despues de esto en micuenta1 tiene que existir 300
			$this->micuenta2->transaccion(100, "retiro");
			$this->micuenta2->transaccion(200, "deposito");
			// Despues de esto en micienta2 tiene que existir 400
		}
 
		// Mostramos el resultado.
	function set_mostrardatos()
		{
			echo "<br/> Mostramos datos detallados <Br/>";
			echo "Nombre y apellidos: " . $this->micuenta1->get_datospersona();
			echo ", posee un saldo de : " . $this->micuenta1->get_mostrarsaldo();
			echo "<br/>";
			echo "Nombre y apellidos: " . $this->micuenta2->get_datospersona();
			echo ", posee un saldo de : " . $this->micuenta2->get_mostrarsaldo();
		}
 
 
}
 
?>

 

Programa llamador principal.php

<?php
/* 
 
Esta no es la clase principal , sino un probador y lanzador de lo creado.
Ejecuta además la clase principal al final de la página.
Probador de clases 
 
*/
include ("clases/persona.inc.php");
include ("clases/cuenta.inc.php");
include ("clases/principal.inc.php");
?>
<html>
<head>
<title>Probador del funcionamiento de clases</title>
<head>
<body>
<?php
echo "<b>He cargado en memoria las 3 clases: persona, cuenta, principal. </b> <br/>";
 
echo "<br/><b>---------------- Prueba de la primera clase ----------------- </b>";
// instanciamos la clase persona
$oscar = new persona("oscar","de la Cuesta", "979000000");
 
// creamos metodo tipo set para cumplir ley de demeter
echo $oscar->set_telefono("97900000");
 
// Ahora probamos que el metodo set, da error solo introducidos el prefijo.
echo $oscar->set_telefono("979");
/* rescatamos que el valor se ha introducido correctamente, pero no accediendo
 directamente sino mediante metodo para lograr encapsulacion tal y como dice
 el enunciado, afinando el tipo de acceso */
 
echo "<br/>El telefono del objeto tipo persona oscar es: ". $oscar->get_telefono();
// en vez de: echo $oscar->telefono esto no es correcto inclumple el data hidding
//echo $oscar->telefono;
// El error marcado seria, Cannot access private property persona.
echo "<b><br/><br/> -------------- Prueba la Segunda clase Cuenta --------------- </b>";
 
// Mostramos los parametros por defecto, llamada a constructor
$micuenta=new cuenta();
 
echo " <br> Mostramos los datos por defecto la cuenta: " . $micuenta->get_datospersona();
// El otro ejemplo parametros sobrecargados, se crea otro objeto demo cuenta pero con parametros en la llamada.
$vero= new persona("vero", "de la Cuesta", "666666666");
 
// Pasamos puntero del objeto vero para meterlo dentro de la propiedad persona del objeto micuenta2
$micuenta2=new cuenta("20106758947584",100,$vero);
 
echo " <br> Mostramos los datos:  " . $micuenta2->get_datospersona() . "<br/>";
// Creamos otro objeto tipo cuenta pero vemos que  falla si el saldo es mejor que 0
$micuenta3=new cuenta("20106758947584",-100,$vero);
 
echo $micuenta3->get_mostrarsaldo();
 
echo "<br/><b> ---------------- Prueba de la Clase Principal ----------------- </b>";
$Objeto_Principal = new principal();
echo $Objeto_Principal->set_mostrardatos();
 
?>
</body>
</html>

Deja un comentario

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Home Formacion Ventajas de la utilización de clases en php. Caso práctico.
© www.palentino.es, desde el 2012 - Un Blog para compartir conocimientos ...

Uso de cookies en mi sitio palentino.es

Este sitio web utiliza cookies para que tengamos la mejor experiencia de usuario. Si continúas navegando estás dando tu consentimiento para la aceptación de las mencionadas cookies y la aceptación de la política de cookies

ACEPTAR
Aviso de cookies