Unidad 6 – POO
Unidad 6
POO
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
Programación Orientada a Objetos
¿Qué es la Programación Orientada a Objetos?
La programación Orientada a objetos (POO) es una forma especial de programar, más cercana a
como expresaríamos las cosas en la vida real que otros tipos de programación.
Con la POO tenemos que aprender a pensar las cosas de una manera distinta, para escribir
nuestros programas en términos de objetos, propiedades, métodos.
Pensar en términos de objetos es muy parecido a cómo lo haríamos en la vida real. Por ejemplo,
vamos a pensar en un coche para tratar de modelizarlo en un esquema de POO. Diríamos que el
coche es el elemento principal que tiene una serie de características, como podrían ser el color, el
modelo o la marca. Además, tiene una serie de funcionalidades asociadas, como pueden ser
ponerse en marcha, parar o estacionar.
Los cuatro primeros términos, más básicos, que tenemos que aprender cunado pensamos en un
paradigma de programación orientado a objeto son:
• Clase
• Objeto
• Propiedades
• y métodos.
La clase contiene la definición del objeto, indicando cuáles son sus propiedades o atributos y
cuáles son sus funcionalidades o métodos.
En el ejemplo del coche entonces tendríamos por un lado la clase coche que contiene como
propiedades (atributos) el color y la marca, y como métodos (funcionalidades) encender, parar o
estacionar.
Veamos estos términos uno por uno con más ejemplos.
Clases, utilidad y definición
La clase es la base de la POO. La clase es utilizada para definir un objeto. Dentro de una clase
declaramos los atributos (propiedades) y métodos que serán utilizados por el objeto.
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
Así podemos decir que la clase es el conjunto de declaraciones que van a definir los tipos de
objetos que utilizaremos en el futuro.
Este es un ejemplo sencillo para ver como tenemos que definir una clase y cuál es la sintaxis que
tenemos que utilizar.
//definición de la clase polígono
class Forma{
// atributo, propiedad o variable de clase
public $puntas;
public $colores;
// Métodos o funcionalidades
function area()
{
// Código a ejecutar
}
}
Los objetos como instancias de las clases.
Como hemos comentado anteriormente, las clases son tan solo la definición del objeto, así que
para poder trabajar con ellas es necesario instanciarlas mediante la creación de un objeto. Así el
objeto es la representación útil de la clase que lo define.
Para instanciar una clase y así crear el objeto lo haremos de la siguiente forma:
//Implementación de la clase
$rectangulo = new Forma();
$triangulo = new Forma();
__construct y __destruct
A continuación, vamos a hablar de la primera novedad que incorpora se incorpora desde php5, los
métodos: __construct y __destruct.
Son métodos que nos sirven para definir el constructor y destructor en una clase.
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
El constructor de una clase es utilizado para inicializar la misma, así podremos asignar algunos
valores a las propiedades que se crean convenientes en el momento de creación de un objeto.
Puede haber uno solo por clase.
El destructor sin embargo es ejecutado en el momento en el que el objeto deja de existir. Así
aquellas tareas que queramos ejecutar en el momento de liberar un objeto las definiremos en el
destructor de la clase.
Cabe aclarar que ninguno de estos dos métodos es obligatorio, pueden estar como no en la
definición de una clase.
A continuación, vamos a extender nuestro ejemplo anterior con la inclusión del constructor y
destructor.
<?php
//definición de la clase polígono incluyendo el
constructor y destructor
class Forma{
public $puntas;
public $colores;
function __construct($crear=null)
{
if ($crear ==null)
$this-> puntas = 4;
else
$this-> puntas = $crear;
}
function __destruct()
{
echo 'Puntas: '.$this->puntas.' <br>';
}
function muestraVertice()
{
echo $this->puntas;
}
}
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
$rectangulo = new Forma();
$triangulo = new Forma(3);
?>
El operador $this.
Si nos fijamos en el ejemplo anterior podemos encontrar el operador $this, este operador es para
referirse al objeto sobre el que se está ejecutando el método.
Así dentro de una clase para acceder a los métodos y propiedades propios siempre lo haremos a
través de $this->metodo/propiedad
Propiedades y Métodos estáticos
Dentro de una clase podremos definir propiedades y métodos estáticos mediante la palabra clave
"static". Esto quiere decir que estos métodos o propiedades podrán ser accesibles sin necesidad
de instanciar la clase, es decir, que podemos acceder a ellos sin la obligación de crear el objeto
correspondiente.
La forma de definir métodos o propiedades estáticos es sencilla, basta con añadir la palabra clave
static justo después del modificador de acceso en la declaración de dicho método o propiedad.
A continuación, un sencillo ejemplo práctico de su utilización:
<?php
class Mensajes{
(...)
public static function mostrar()
{
echo 'Hemos accedido a este método estático';
}
(...)
}
echo Mensajes::mostrar();
?>
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
Encapsulamiento
El encapsulamiento es una de las características fundamentales en la programación orientada a
objetos.
Así que a continuación vamos a hablar de public, private y protected, que son los modificadores
de acceso a métodos y propiedades incorporados a partir de PHP5.
Vamos a comentar cada uno de los modificadores, analizando sus características y adjuntando un
ejemplo de su implementación.
Modificador public
Este modificador es el más permisivo de los 3, puesto que indica que el método o la propiedad es
accesible desde la clase y desde cualquier otra parte de nuestro programa.
Además, es el modificador aplicado por defecto en caso de que no especifiquemos ningún
modificador.
Modificador private
Este modificador establece el nivel más restrictivo, puesto que las propiedades o métodos que
declaremos como private solo serán accesibles desde el interior de la clase.
Modificador protected
Este modificador establece un nivel de restricción medio, esto quiere decir que las propiedades o
métodos declarados como protected solo serán accesibles desde la clase base o las clases hijas
que hereden de la clase base.
Vamos a ver a continuación el concepto de Herencia para que se pueda entender mejor este
modificador.
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
Herencia
La herencia es otro de los pilares fundamentales dentro de la programación orientada a objetos.
La herencia consiste en la definición de una clase a partir de otra existente, así esta nueva clase se
le llama clase extendida o clase derivada. La importancia de la herencia reside en que cuando
creamos una clase extendida, esta a su vez hereda todos los métodos y propiedades de su clase
base o ancestral, pudiendo a su vez implementar otros métodos o propiedades exclusivos de
nuestra clase extendida.
Vamos a trabajar sobre un ejemplo para que comprendan mejor los conceptos de Herencia y
Encapsulamiento.
Pensemos en un negocio que vende Celulares y Tabletas con distintos Sistemas Operativos como
pueden ser Android y IOS.
Vamos a pensar en una estructura como la siguiente, por un lado, tendremos la clase productos
que tiene las propiedades y métodos comunes a ambos productos, los celulares y las tablets.
Luego tendremos dos clases que extienden a productos que son las clases celulares y tabletas con
las propiedades y métodos particulares de cada tipo de producto.
Comencemos con la definición de la clase productos:
<?php
class productos{
public $nombre;
protected $codigo;
private $precio;
function __construct($nom,$cod,$precio){
$this->nombre = $nom;
$this->codigo = $cod;
$this->precio = $precio;
}
public function precio_sin_iva(){
return $this->precio;
}
public function precio_con_iva(){
return $this->precio * 1.21;
}
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
public function codigo_prod(){
return $this->numero;
}
public function final_prod(){
echo "Producto: <strong>".$this->nombre."</strong><br>";
echo "Código: ".$this->codigo."<br>Precio: " . $this->precio . " (IVA no incluido)";
}
}?>
Solo la propiedad nombre va a poder ser accedida desde fuera de la clase, la propiedad precio
solo se podrá acceder de la clase productos y la propiedad codigo podrá ser accedida tanto de la
clase productos como de las clases celulares y tabletas, ya que como dijimos anteriormente estas
clases extenderán a productos.
Tomemos el script ejemplo_4.php:
<?php
include('[Link]');
$producto1 = new productos("Motorola","E4g",18650);
echo "<b>" . $producto1->nombre . "</b>";
echo "<br>Precio: " . $producto1->precio_sin_iva() . " pesos";
echo "<br>Precio IVA incluido: " . $producto1->precio_con_iva() . " pesos<br><br>";
$producto2 = new productos("Noga","NGA520",15150);
$producto2->final_prod();
echo "<br>Precio IVA incluido: " . $producto2->precio_con_iva() . " pesos";
En él estamos instanciando dos veces la clase productos, quiere decir que estamos creando dos
objetos de la clase productos, 2 veces.
Una vez instanciado el objeto podemos hacer referencia a sus propiedades, siempre que estas se
hayan definido con el modificador public, a través del operado -> como en la línea en la que se
muestra el título:
echo "" . $producto1->nombre. "";
En el caso de las propiedades definidas como private o protected no podremos llevar a cabo esa
instrucción, no podremos hacer por ejemplo desde este script:
echo "" . $producto1->precio . "";
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
En el caso de las propiedades definidas como private como no podemos acceder directamente a la
misma lo que hacemos es definir un método public que nos devuelve el valor de dicha propiedad
como en el caso de los métodos:
$producto1-> precio_con_iva()
$ producto1->precio_sin_iva()
Lo mismo sucedería con los métodos. Es decir, un método definido como private no podrá ser
accedido desde fuera de la clase. Si hubiéramos definido un método como private no sería lícito
invocar a dicho método desde fuera de la clase de la siguiente forma:
$producto1->metodo()
Solo podríamos utilizarlo desde dentro de la clase de la siguiente manera:
$this->metodo()
Veamos ahora la definición de la clase celulares:
<?php
class celulares extends productos{
public $marcas;
private $modelos;
function __construct($nom,$cod,$precio,$marca,$mod){
parent::__construct($nom,$cod,$precio);
$this->marcas = $marca;
$this->modelos = $mod;
}
public function final_prod(){
parent::final_prod();
echo "<br>" . $this->marcas;
echo "<br>" . $this->modelos;
}
}?>
Como dijimos las clases celulares y tabletas extienden a la clase productos eso lo expresamos en
la definición de la clase a través de la palabra extends productos.
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
Esta clase entonces tendrá todas las propiedades y métodos de la clase productos más los
definidos en la clase celulares.
El hecho de que la clase herede las propiedades de productos no implica que el constructor de la
clase productos se ejecute automáticamente cuando se instancia la clase celulares. Es por eso que
en el constructor de la clase celulares se llama al constructor de la clase productos. La sintaxis
para invocar ese método es:
parent::__construct($nom,$cod,$precio);
Indicando que ejecute el constructor de la clase padre.
Lo mismo sucede en el método final_prod(), invoca al método final_prod de la clase padre, es
decir de productos.
Una vez instanciado un objeto celulares será lícito hacer:
$micelular = new celulares('Galaxy','CD5460',25500,'Samsung','A10e');
$micelular->final_prod();
Ya que el método precio_con_iva() es heredado por la clase celulares.
Veamos el código de ejemplo_5.php
<?php
include('[Link]');
include('[Link]');
$micelular = new celulares('Galaxy','CD5460',25500,'Samsung','A10e');
$micelular->final_prod();
?>
De manera similar veamos la definición de la clase tabletas:
<?php
class tabletas extends productos{
public $OS; //Sistema operativo: ej Android
private $cap_min;
private $cap_max;
function __construct($nom,$cod,$precio,$sist,$min_c,$max_c){
parent::__construct($nom,$cod,$precio);
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
$this->OS = $sist;
$this->cap_min = $min_c;
$this->cap_max = $max_c;
}
public function ver_tabletas(){
if ($this->cap_min == $this->cap_max){
echo "<p>Capacidad de almacenamiento: ".$this->cap_min."</p>";
}else{
echo "<p>Capacidad de almacenamiento desde " . $this->cap_min . " hasta ".$this-
>cap_max."</p>";
}
}
public function final_prod(){
echo "<p>Sistema operativo: " . $this->OS . "</p>";
parent::final_prod();
//echo $this->ver_tabletas();
}
}?>
Y de ejemplo_6.php
<?php
include('[Link]');
include('[Link]');
$mitablet = new tabletas("Ipad", 'OS6485', 65000, "IOS",32,256);
$mitablet->final_prod();
//esta línea daría un error porque no se permite acceder a un atributo private del objeto
//habria que crear un método para que acceda a los atributos private
$mitablet->ver_tabletas();
echo "<p>";
$mitablet2 = new tabletas("Galaxy Note", 'GS4521', 49000, "Andoid",64,64);
echo "<b>" . $mitablet2->nombre . "</b>";
$mitablet2->ver_tabletas();
?>
Contacto: consultas@[Link]
Web: [Link]
Unidad 6 – POO
Los invito a que hagan pruebas cambiando los modificadores y agregando llamados a los distintos
métodos y propiedades para que puedan comprobar todos estos conceptos que hemos explicado.
Contacto: consultas@[Link]
Web: [Link]
