Bienvenidos sean a este post, hoy hablaremos sobre las clases en este lenguaje.
Pero que es una clase? podemos definirla como un molde porque esta nos servira para crear objetos en base a esta, en general poseen funciones que se denominan metodos y variables que se denominan propiedades, su sintaxis es la siguiente:
class nombreClase
{
... propiedades ...
... metodos ...
}Como pueden ver es bastante simple dado que usaremos la palabra clave class seguida del nombre que la identificara, dentro del bloque tenemos las propiedades las cuales son las variables como mencionamos antes y los metodos que son las funciones, para crear un objeto de esta clase o molde debemos usar la palabra new y su sintaxis es la siguiente:
$variable = new nombreClase();Como ven es similar a definir una variable pero despues del igual utilizamos a new que se encargara de crear el objeto en memoria y en ese espacio de memoria almacenaremos todos los elementos de la clase y cada vez que utilicemos a dicho objeto en realidad estaremos accediendo a este bloque de memoria, lo bueno de trabajar de esta forma es que podemos generar multiples objetos de esta clase y como cada uno tendra su espacio de memoria no interferira con el otro y no se modificaran los datos entre si, para entender este concepto vamos a crear un ejemplo simple, para ello haremos un nuevo archivo llamado clases.php y le agregaremos el siguiente codigo:
clases.php
<?php
class alumnos
{
public $nombre;
public $apellido;
public $edad;
public $apodo;
}
$tinchicus = new alumnos();
$tinchicus->nombre = "Martin";
$tinchicus->apellido = "Miranda";
$tinchicus->edad = 44;
$tinchicus->apodo = "tinchicus";
echo $tinchicus->nombre . " " . $tinchicus->apellido . "\n";
?>En este codigo tenemos varias partes pero que nos vendran bien para lo basico, la primera parte es la clase que se llamara alumnos, en ella tenemos cuatro propiedades o variables que seran para almacenar el nombre, apellido, edad y apodo respectivamente, esto hara que trabaje como un array bidimensional porque cada objeto que crearemos tendra estos mismos parametros, asi como la primera de las dos dimensiones de cuando hablamos sobre ese tema en este post, con esto tenemos la clase lo siguiente sera el objeto que crearemos para ello sera una variable llamada tinchicus y usamos a new para generar el espacio en memoria seguido de la clase, nuestro siguiente paso sera cargar los datos de cada una de las propiedades, para ello analicemos una de las lineas:
$tinchicus->nombre = "Martin";Primero pasaremos el objeto en cuestion luego usamos un operador para indicarle que debemos enviar a la propiedad que le informemos, nombre para este caso, el valor que se encuentra despues del igual, observen que para este caso no usamos el signo de pesos ($) sino solamente el nombre de la misma, esto lo hacemos con cada uno de las propiedades, por ultimo mostraremos el valor almacenado en las propiedades nombre y apellido, observen que volvemos a usar el mismo operador que para cargar los valores, probemos y veamos su salida:
tinchicus@dbn001vrt:~/lenguajes/PHP$ php clases.php
Martin Miranda
tinchicus@dbn001vrt:~/lenguajes/PHP$Podemos ver que funciono perfectamente dado que nos devolvio los valores agregados, vamos a hablar sobre de uno de los metodos mas practicos en este y muchos lenguajes como son los constructores, estos metodos tienen la particularidad de permitirnos establecer valores en las propiedades o llamar a metodos en el momento de crear el objeto en base a esta clase, esta es su conducta mas basica pasemos a ver su sintaxis:
public function __construct(argumentos)
{
... instrucciones ...
}A diferencia de cuando hablamos de las funciones en este caso tenemos una palabra nueva llamada public, en un momento lo explicamos, seguido de la palabra function como antes para decir que va a ser una funcion o metodo, seguido del nombre __construct y este es obligatorio a diferencia de lo que dijimos en este post dado que es el identificador del constructor, despues tenemos los argumentos que siguen siendo opcionales, despues en el bloque tendremos las instrucciones que necesitemos, pasemos a hablar de public.
La palabra public indica que la funcion o propiedad son de acceso total tanto para la clase como para el objeto creado a partir de esta clase, su contraparte es private que transformara a cualquiera de los elementos que le pasemos como privados y solo podran ser accedidos en la clase y no por los objetos creados a partir de esta, usualmente se los denomina limitadores pero ya veremos esto en accion un poco mas adelante, con esto comentado pasemos a modificar el codigo anterior de la siguiente manera:
<?php
class alumnos
{
public $nombre;
public $apellido;
public $edad;
public $apodo;
public function __construct($nombre,
$apellido,
$edad,
$apodo)
{
$this->nombre = $nombre;
$this->apellido = $apellido;
$this->edad = $edad;
$this->apodo = $apodo;
}
}
$tinchicus = new alumnos("Martin","Miranda",44,"Tinchicus");
echo $tinchicus->nombre . " " . $tinchicus->apellido . "\n";
?>Hablemos de los primeros cambios, el primero es el nuevo metodo que hablamos anteriormente:
public function __construct($nombre,
$apellido,
$edad,
$apodo)
{
$this->nombre = $nombre;
$this->apellido = $apellido;
$this->edad = $edad;
$this->apodo = $apodo;
}Observen que usamos la nomenclatura que dijimos anteriormente, en los argumentos recibiremos cuatro datos que se llamaran igual (esto no es necesario pero es practico tener las mismas referencias) a las distintas propiedades de nuestra clase, luego usaremos a $this, esto equivale al apuntador this de otros lenguajes, cuya unica funcion es tener como referencia al objeto que contendra dicho valor porque si no lo hacemos asi este dato se pasara a la clase y modificara los valores de todos los objetos creados a partir de esta clase, con esto nos aseguramos que solamente dicho objeto sea modificado, despues sigue el operador para decirle la propiedad y el valor que recibio la funcion, esto implica que no debemos asignar los valores en el codigo por lo tanto se elimino todas esas lineas y reemplazamos la creacion del objeto con la siguiente:
$tinchicus = new alumnos("Martin","Miranda",44,"Tinchicus");Es exactamente lo mismo al primer codigo pero ahora pasamos los datos que corresponderan a cada propiedad, por lo tanto gracias al constructor estos datos se asignaran automaticamente a cada propiedad, probemos para ver su salida:
tinchicus@dbn001vrt:~/lenguajes/PHP$ php clases.php
Martin Miranda
tinchicus@dbn001vrt:~/lenguajes/PHP$Como podemos ver trabajo de la misma forma, vamos a hacer una pequeña demostracion de public y private, para ello modificaremos el codigo anterior de la siguiente manera:
<?php
class alumnos
{
private $nombre;
private $apellido;
private $edad;
private $apodo;
public function __construct($nombre,
$apellido,
$edad,
$apodo)
{
$this->nombre = $nombre;
$this->apellido = $apellido;
$this->edad = $edad;
$this->apodo = $apodo;
}
}
$tinchicus = new alumnos("Martin","Miranda",44,"Tinchicus");
echo $tinchicus->nombre . " " . $tinchicus->apellido . "\n";
?>La unica modificacion fue cambiar las propiedades de public a private, el resto sigue trabajando de la misma forma, probemos para ver su salida:
tinchicus@dbn001vrt:~/lenguajes/PHP$ php clases.php
PHP Fatal error: Uncaught Error: Cannot access private property alumnos::$nombre in /home/tinchicus/lenguajes/PHP/clases.php:25
Stack trace:
#0 {main}
thrown in /home/tinchicus/lenguajes/PHP/clases.php on line 25
tinchicus@dbn001vrt:~/lenguajes/PHP$Observen que ahora no funciono y la excepcion o error nos informa que no se puede acceder a la propiedad nombre de la clase alumnos, tal como dije antes nos impide el acceso a traves del objeto creado pero como podemos acceder a dicha propiedad desde el objeto? Aca entran en accion los metodos getter and setter, para ello vamos a modificar el codigo anterior de la siguiente manera:
<?php
class alumnos
{
private $nombre;
private $apellido;
private $edad;
private $apodo;
public function __construct($nombre,
$apellido,
$edad,
$apodo)
{
$this->nombre = $nombre;
$this->apellido = $apellido;
$this->edad = $edad;
$this->apodo = $apodo;
}
public function getNombre() { return $this->nombre; }
public function getApellido() { return $this->apellido; }
public function getEdad() { return $this->edad; }
public function getApodo() { return $this->apodo; }
}
$tinchicus = new alumnos("Martin","Miranda",44,"Tinchicus");
echo $tinchicus->getNombre() . " " . $tinchicus->getApellido() . "\n";
?>Observen que agregamos cuatro funciones, si bien no es necesario para saber que son de tipo getter le agregamos la palabra get al nombre del metodo, seguido de la propiedad que recupera, si recuerdan cuando hable de public y private dije que private solo es accedido dentro de la clase, por lo tanto si a este metodo lo hacemos public este sera accesible desde el objeto y este si podra acceder al valor de la propiedad porque esta dentro de la misma clase, en todos los casos usamos a return para que devuelve el valor y nuevamente a $this para indicarle que sea del objeto en cuestion y no de la clase, lo mismo es para las cuatro funciones pero para cada propiedad, veamos el ultimo cambio:
echo $tinchicus->getNombre() . " " . $tinchicus->getApellido() . "\n";Ahora en lugar de acceder directamente a la propiedad lo hacemos por el metodo que creamos para cada una de ellas, si lo probamos debe funcionar correctamente pero que sucede si necesitamos modificar el valor? en ese caso entran en accion los metodos setter que no vimos todavia para ello modificaremos el codigo de la siguiente manera:
<?php
class alumnos
{
private $nombre;
private $apellido;
private $edad;
private $apodo;
public function __construct($nombre,
$apellido,
$edad,
$apodo)
{
$this->nombre = $nombre;
$this->apellido = $apellido;
$this->edad = $edad;
$this->apodo = $apodo;
}
public function getNombre() { return $this->nombre; }
public function getApellido() { return $this->apellido; }
public function getEdad() { return $this->edad; }
public function getApodo() { return $this->apodo; }
public function setNombre($nombre) { $this->nombre = $nombre; }
public function setApellido($apellido)
{
$this->apellido = $apellido;
}
public function setEdad($edad) { $this->edad = $edad; }
public function setApodo($apodo) { $this->apodo = $apodo; }
}
$tinchicus = new alumnos("Martin","Miranda",44,"Tinchicus");
echo $tinchicus->getNombre() . " " . $tinchicus->getApellido() . "\n";
$tinchicus->setNombre("Martin H.");
$tinchicus->setEdad(45);
$tinchicus->setApodo("tinchicus");
echo $tinchicus->getNombre() . " ". $tinchicus->getApellido() . " " .
$tinchicus->getEdad() . " " . $tinchicus->getApodo() . "\n";
?>En este caso agregamos cuatro metodos nuevos, como sucedia con get lo iniciamos con set y esto no es obligatorio pero es una buena practica para identificar que se usara para establecer o «setear» el valor en la propiedad relacionada a la funcion, observen que cada funcion tiene el nombre de cada una de las propiedades, en este caso recibiremos un argumento para establecer el nuevo valor en la propiedad de cada funcion, al igual que en get son tambien de tipo public para poder ser accedido desde el objeto, tambien usamos a $this para indicar cual es el objeto donde trabajaremos y no mucho mas, pasemos a ver los cambios por fuera de la clase, para esta ocasion despues de mostrar los valores de nombre y apellido agregamos este bloque:
$tinchicus->setNombre("Martin H.");
$tinchicus->setEdad(45);
$tinchicus->setApodo("tinchicus");En este caso usaremos a tres metodos de los agregados, para establecer primero un nuevo nombre, luego la nueva edad y por ultimo un «nuevo» apodo, en este caso lo hice en minusculas nada grave pero en los otros si modifique los valores, la siguiente linea o lineas la usaremos para mostrar los cuatros valores de las propiedades, por medio de las funciones getter, con todo esto comentado veamos su nueva salida:
tinchicus@dbn001vrt:~/lenguajes/PHP$ php clases.php
Martin Miranda
Martin H. Miranda 45 tinchicus
tinchicus@dbn001vrt:~/lenguajes/PHP$Observemos como nos muestra la salida anterior y la nueva salida con los datos modificados, con esto completamos tanto las clases, como los delimitadores y los metodos getter and setter, estos ultimos tambien nos posibilita hacer otras trabajos antes de modificar o recuperar la informacion, desde verificaciones hasta permitir o no dependiendo la informacion enviada, por ultimo vimos que disponemos de constructores para trabajar de forma mas dinamica con nuestras clases, esto es algo muy basico pero les dara una buena base para trabajar con las clases en sus codigos.
En resumen, hoy hemos visto las clases, como son, para que sirven, como se componen, como podemos restringuir sus accesos, como podemos acceder a pesar de las restricciones y otras particularidades, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.
Donación
Es para mantenimento del sitio, gracias!
$1.50
El blog de Tinchicus 