Programación orientada a objetos
- En programación el paradigma imperativo está basado en funciones y datos.
Programación estructurada y modular
- Los programas los realizamos en un fichero o programa principal, realizando en él las acciones para resolver el problema
- Se llama estructurada ya que todo es una estructura de
#Instrucciones en estructruas secuencias (asignar, invocar, declarar)
#Estructras selectivas (si (condicione) ....)
#Estructuras repetitivas (mientras (condicion) ....
|
- El paradigma orientado a objetos está basado en Objetos.
- Ahora plantearemos los programas desde dos aspectos.
Enfoque Orientado a Objetos
- Tendré un programa principal que va a resolver el problema o a implementar el algoritmo
- Para ello voy a utilizar pequeños componentes de software u objetos que son programas que hacen cosas
|
- Los objetos son el elemento básico y central de la programación orientada a objetos (OOP) o (POO).
- Podemos hablar de universo de discurso como el sistema que queremos automatizar por software
- Un Objeto es una entidad (concreta o abstracta) que presenta una actividad en un entorno concreto, en un determinado universo de discurso.
Definición
Objeto Cada elemento activo que identificamos dentro de un determinado universo de discurso.
- Serán nuestros componentes software para ensamblar nuestros programas
|
|
|
Ejemplo
|
|
|
- En un banco hay cuentas bancarias (objeto)
- Las cuentas bancarias se identifican con un número y un titular (nombre, apellido y dni) atributos
- Las cuentas se pueden dar de alta, de baja, hacer extracciones e ingresos y transferencias... métodos
|
|
|
Ejemplo
|
|
|
- En la gestión de una empresa, a nivel de información tenemos
-
- Empleados
- Nómigas
- Base de datos
- Proveedores
- Facturas
- Pedidos
|
- Puede parecer una forma más complicada de programar, pero es una manera de dividir la naturaleza del problema que estamos estudiando en unidades independientes que pueden interactúar entre ellas.
- Cada una de ellas va a tener una identidad propia asignando valores a sus atributos
- Cada una de ellas va a tener un comportamiento concreto que va a ser lo que sabe hacer para que los demás o el programa principal lo utilice
Pilares básicos de la POO
- Son 4 las características o principios de la programación orientada a objetos
- Encapsulación
- Herecia
- Polimorfismo
- Abstraccion
|
Encapsulación: Acceso a los componentes
- A la hora de definir tanto las propiedades como los métodos, especificaremos el nivel de acceso que se tiene a ese elemento
- Es una buena práctica de programación no dejar acceso directo a los atributos de una clase, sino acceder a ellos a través de los métodos
- La encapsulación es uno de los pilares de la programación orientada a objetos
- permite o restringe la visibilidad de sus componentes
|
Visibilidad
- Visibilidad o alcance de las propiedades no constantes y los métodos de las clases
- Implementa el principio de encapsulación.
- Permite especificar el nivel de acceso que se tienen sobre los elementos
- Visibilidad
- Son tres los tipos de visibilidad que podemos especificar:
- public
- private
- protected
Tip: public tipo de visibilidad asignada por defecto en caso de no especificar.
- En el caso de los atributos hay que declararlo de forma explícita.
- Las funciones podemos no declararlo tomando el valor por defecto public
- Por herencia podemos usar la palabra reservada var para declarar los atributos en cuyo caso son pùblic
- public
- Este tipo de visibilidad es asignada por defecto
- Los elementos públicos pueden ser accesibles en cualquier momento del programa.
- Recordemos que para acceder a un elemento debemos especificar el objeto o clase del que queremos el elemento
- Si el elemento es estático o constante usaremos el operador :: llamado operador de especificación ámbito #::
- Si el elemento es no estático accedemos a través del operador ->
|
|
Ejemplo
|
|
|
- En el código anterior ver el método verFecha() que es públic
- Sin embargo las propiedades dia, mes,year, son private
- Esto implica que en el programa principal puedo hacer
....
$f = new Fecha(5,10,2017)
...
$f->verFecha();
... ....
$f = new Fecha(5,10,2017)
...
$f->dia= 5;
... Tip: En el caso de que las propiedades fueran public, sí podría hacerlo
|
- private
- Los elementos especificado con este modificador de acceso hace que su visibilidad se reduzca al interior de la clase, no pudiendo acceder a ellos desde fuera
- En OOP es una tendencia hacer todos los atributos privados y acceder a ellos por los métodos setter and getter.
<?php
class Usuario {
private $usuario;
private $password;
public function __construct($usuario) {
$this->password = 'passDefecto';
$this->usuario = $usuario;
}
public function __destruct() {
echo 'Me voy......';
}
public function getUsuario(){
return $this->usuario;
}
public function getPass(){
return $this->password;
}
public function setUsuario($user){
this->usuario =$user;
}
public function setPass($pass){
this->password =$pass;
}
}
$usuario = new Usuario('manolo');
//....
$pass = $_POST['pass'];
//....
$usuario->setPass($pass);
//...
unset $usuario; //Ejecutaría el método mágico destroy
?>Tip: A un elemento private de una clase, tampoco podrá acceder desde clases que deriven de ésta
- protected
- Este tipo de visibilidad implica que los elementos así especificados solo son accesible por la propia clase y por las clases derivadas
- Para ello hay que ver la herencia que veremos más adelante dónde propondremos un ejemplo
<?php
class persona{
protected $nombre;
protected $fNac;
//....
}
//.....
class medico extends persona{
private $numColegiado;
public function __construct($nombre, $fechaNacimiento, $colegiado) {
$this->nombre=$nombre;
$this->fNac=$fechaNacimiento;
$this->numColegiado=$colegiado;
}
public function visualiza(){
echo "Medico $this->nombre";
}
}
$medicoPueblo1= new medico("pedro", "1/1/1969","123456");
$medicoPueblo1->visualiza();
?>
Un ejemplo concreto
Clase Fecha
- Vamos a hacer un ejemplo, usando la clase Fecha
- Lo primero que tenemos que saber qué es Fecha va a ser un programa independiente que tiene sus variables y sus acciones
- Procederemos con el ejemplo para aprender a crear clases y objetos
|
Elementos en la programación orientada a objetos
- De lo dicho anteriormente deducimos que tenemos dos elementos:
- Los atributos o características de la clase.
- Los métodos o comportamiento de la clase .
- Para crear objetos, previamente hay que definir su estructura.
- La definición de la estructura (atributos y métodos ) de componentes software se llama clase
Clase
- La descripción y especificación de componentes software para su posterior uso en los programas
- Una clase es la estructura de un tipo concreto de objetos.
- Los objetos son elementos concretos en mi sistema. Instancias de la clase en memoria para ser usadas por un programa
|
- Elementos de la POO
Atributo
- Son las características o datos de un objeto.
- Sus valores nos da el estado de un objeto en un momento dado.
- Normalmente al instanciar un objeto en memoria lo primero que hacemos es dar valores a sus atributos
- Es recomendado que los atributos entén encapsulados solo al objeto (privados)
|
- Elementos de la POO
Métodos
- Especifican el comportamiento de los objetos.
- Permiten modificar y conocer el estado de un objetos (métodos getter and setter).
- Permiten que un objeto haga cosas en el sistema (comunicación entre objetos) .
- Los métodos son las acciones que el objeto sabe hacer, servicios que ofrece
- También son las acciones internas para facilitar las acciones al objeto
|
OPP En php
- PHP no se diseñó como lenguaje orientado a objetos, por lo que muchas de las características de este paradigma se han ido incorporando en las últimas versiones, especialmente a partir de la versión 5.3.
- PHP Almacena el valor de un objeto como una referencia (dirección de memoria), no guarda el valor.
- Esto implica que si queremos pasar un objeto a través de la red, debemos serializarlo, para que viaje también el valor del mismo y no solo la dirección de memoria que en destino carecería de sentido. Veremos este concepto más adelante.
- En php las clases tienen métodos y propiedades
- propiedades: son los atributos o características de la clase.
- métodos: representas el comportamiento de la misma.
- Definir una clase en php
class NombreClase{
//propiedades
//métodos
}
- NombreClase es un identificador válido con la siguiente expresión regular
^[a-zA-Z_][a-zA-Z0-9_]*$
- El nombre de las clases se recomienda que empiece por mayúsculas
- Es recomendable guardar las clases en ficheros cuyo nombre sea el propio de la clase
Los atributos
- Para definir los atributos hay que especificar antes del nombre su visibilidad
- Establece si ese atributo puede ser accedido o no fuera de la clase
- Tenemos tres tipos de visibilidad
- private
Solo se puede acceder al atributo dentro de la propia clase
- public
Se puede acceder al atributo en cualquier sitio donde esté el objeto
- protected
Solo se puede acceder al atributo dentro de la propia clase y de las clases que hereden de ella (ya lo veremos en herencia).
Importante la visibilidad
- Veremos más adelante la visibilidad
- En php es obligatorio especificar la visibilidad de los atributos
- Las buenas prácticas de programación marcan poner private a los atributos (o protected)
- Los métodos por defecto son públicos,public siendo preferible especificarlo de forma explícita
|
Tip: A continuación un posible código iremos viendo más adelante muchos detalles sintácticos aquí expresados
|
|
Ejemplo
|
|
|
Crea una claser Fecha con tres atributos
|
<?php
class Fecha {
private $dia;
private $mes;
private $year;
}}
Los métodos
- Pero solo los atributos no sirven de nada
- Cuando nosotros usemos un objeto de la clase fecha, necesitamos que ese obeto exista, que sea una fecha concreta
- Necesitamos un comportamiento para las clases, es decir, que sepan hacer cosas, para esto están los métodos, que son funciones que vamos a tener en nuestra clase.
El constructor
- Una acción básica el la que se ejecuta cuando construimos o declaramos un objeto de una clase
- Este método se conoce como constructor, y se ejecuta de forma implícita (no hay que invocarlo de manera explícita
- En php este método se llama __construct(...) y le podemos pasar los parámetros que consideremos
|
En php los métodos que se ejecutan cuando ocurre algo que no sea invocarlos se llaman métodos mágicos
|
Tip: __construct() es un método mágico que se ejecuta cuando instancio un objeto de una clase
Tip: Todos los métodos mágicos, ya están definidos por el sistema y empiezan por dos caracteres de subrayado __
public function __construct($d, $m, $y) {
$this->dia = $d;
$this->mes = $mes;
$this->year = $year;
}
- Fíjate en el operador (seudovariable) $this, hace referencia al objeto actual, el que esté en memoria
Pregunta
Qué pasaría si pusiera $dia en lugar de $this->dia
|
- Ver los valores de los atributos
- Para ello podemos crear un método ver_fecha
- Para ello vamos a implementar el método mágico __toString()
- Este método no adminte parámetros
- Tiene que devolver un string
- Se invoca siempre que queramos convertir un objeto en cadena de caracteres
-
- Para esto, inicializar el objeto, tenemos
Declarando objetos: Operador new
- Permite crear instancias de un objeto en memoria.
- Una clase describe lo común de unos determinados objetos, la estructura o composición.
- Las clases en principio no se usan durante la ejecución, salvo si queremos acceder a métodos o propiedades estáticas como veremos un poco más adelante
- Lo que se usa en los programas son los objetos.
- Para ello debemos instanciar objetos de las clases
- Esto se hace con el operador new
- Una vez instanciado ya tenemos la referencia del objeto y lo podemos utilizar
- hay que pensar que en memoria tenemos toda la estructura del la clase por cada objeto
$this
- Accediendo a los atributos de un objeto: seudovariable $this.
- $this es una seudovariable que referencia al objeto del ámbito en el cual se está usado.
- Se utiliza dentro de la definición de la propia clase y hará referencia a un objeto concreto en un momento dado;
Es como decir. cuando exista una instancia de objeto de esta clase, quiero acceder a la propiedad x o ejecutar el método y,,
<?php
class MyClase
{
private $x
...
public function __Construct($valor){
$this->x = $valor;
$this->y();
}
public function y(){
echo "Estoy en el método y ";
- Ejemplo
<?php
class MyClase
{
function ser_estar()
{
if (isset($this)) {
echo '$this Ahora soy por que estoy';
} else {
echo "\$this ni es ni está.\n";
}
}
}
- Podemos probar este código de la siguiente manera en un programa principal
....
require "MyClass.php";
$a = new MyClass();
$a->ser_estar(); //Invocamos al método de un objeto
//Invocamos al método de manera forzada, sin que exista un objeto concreto
MyClass::ser_estar();self
- Cuando queremos acceder a un elemento estático o una constante, éstos son valores que no se establecen en memoria para cada objeto que declare, sino que son compartidos por todos los objetos de la clase, habiendo en memoria un solo valor de los mismos.
Cuando queremos acceder a ellos dentro de la clase (en la declaración de la estructura), los referenciaremos con el operador self', que se podría traducir como yo mismo
- Por ejemplo si tengo una constante declarada
<?php
class Constantes{
const K = 10;
const IVA = 0.21;
function getValores(){
echo "Valor de la constante --".self::K."--<br/>";
echo "Valor del producto de 235 euros base . cuyo iva es ".(self::IVA*235);
}
}
Acceso al contenido del objeto : -> y ::
- Ya hemos visto que para acceder a un elemento de un objeto usamos operadores -> o bien ::
- Operador de indirección ->
- Este operador es un operador de indirección
- Los objetos son direcciones de memoria, cuando se quiere acceder al contenido de una dirección de memoria se usa un operador de indirección, que en el caso de php como en otros muchos lenguajes es -> .
- Observar que se suele acompañar de una variable objeto o de la seudovariable $this , por ese motivo si se quiere acceder a una propiedad del objeto, ya no hay que especificar el $ en el nombre de la propiedad
class Clase1{
public $propiedad1;
....
public function __construct($valor){
//la variable o propiedad de la clase no lleva $ al acceder a ella.
$this->propiedad1 = $valor;
}
....
$obj1 = new Clase1("verde");
$obj1->propiedad1 ="azul";
...
- Operador de resolución de ámbito ::
- nombre de clase,
- nombre del objeto
- self : si es dentro de la misma clase
- parent : si el elemento pertenece a la clase de la que heredo
- static Al igual que self se puede usar la palabra reservada static, para acceder a un elemento estático de la clase.
|
|
Resolución de ámbito
|
|
|
El siguiente código aclara de forma completa estas posibilidades
class Clase1 {
//put your code here
const IVA = 21;
public static $numObj ;
public function __construct() {
self::$numObj++;
echo "En total hay ".Clase1::$numObj." objetos de esta clase e IVA = "
.static::IVA."<br />" ;
}
}
$obj1 = new Clase1();
$obj2 = new Clase1();
$obj3 = new Clase1();
echo "<hr />";
echo "El valor del atributo estático numObj lo
puedo ver desde cualquier objeto de la clase <br />";
echo "NumObj desde obj1 ".$obj1::$numObj. "<br />";
echo "NumObj desde obj2 ".$obj2::$numObj. "<br />";
echo "NumObj desde obj3 ".$obj3::$numObj. "<br />";
echo "NumObj desde en nombre de la clase ".Clase1::$numObj. "<br />";
?>
- La salida que produciría el código sería
En total hay 1 objetos de esta clase e IVA = 21
En total hay 2 objetos de esta clase e IVA = 21
En total hay 3 objetos de esta clase e IVA = 21
El valor del atributo estático numObj lo puedo ver desde cualquier objeto de la clase
NumObj desde obj1 3
NumObj desde obj2 3
NumObj desde obj3 3
NumObj desde en nombre de la clase 3
|
Propiedades
- Al igual que en el código estructurado los valores que almaceno en memoria, las propiedades de los objetos pueden ser.
- Variables
- Constantes
- Constantes
- Para definir constantes se usa la palabra reservada const. Como ya sabemos este valor no puede ser modificado durante la ejecución.
- El identificador de las constantes no empieza por $.
- A una constante hay que asignarle un valor no pudiendo asignar expresiones.
- Todos los objetos de la misma clase comparte el valor de la constante. Por lo que se tomará como un valor estático.
- Antes de la versión 7.1, incluyendo la 7.0, las constantes siempre eran públicas
- A partir de la versión 7.1 se puede especificar la visibilidad (public, protected o private)
- Accediendo al valor de una constante
1.- Dentro de la clase:
2.- En el programa:
- Nombre de la clase
- Nombre de cualquier objeto de la clase
- En ambos casos, junto con el operador de resolución de ámbito ::, seguido del identificador de la constante.
- Vemos un ejemplo de su uso
<?php
class Constantes{
const K = 10;
const IVA = 0.21;
function getValores(){
echo "Valor de la constante --".self::K."--<br/>";
echo "Valor del producto de 235 euros base ".((self::IVA*235)+235);
}
}
$a=new Constantes();
//Mostramos los valores de las constantes
$a->getValores();
echo "<br/>valor de la constante con el nombre de la clase ".Constantes::K;
echo "<br/>valor de la constante con el nombre del objeto".$a::K;
?>
- Variables
- Estas propiedades son como las variables pero de la clase.
- Siguen la misma regla de construcción que vistas anteriormente.
- Las propiedades de la clase al igual que los métodos se les puede especificar una determinada #visibilidad o alcance, siendo el valor por defecto public.
- También puedes ser #static o estáticas;Este especificador establece que estos elementos sean conocidas como propiedades o métidos de la clase, si se especifica con la palabra reservada #static.
Tip: Es importante recordar que para acceder dentro de la clase a los métodos o propiedades de ella, hay que usar la seudovariable #$this'
- Esto es debido a que php es de tipado dinámico, si no lo hiciéramos estaríamos accediendo a una variable local al método
Tip: Recordar que en este caso no podremos el $ delante del nombre de la propiedad.
<?php
class Propiedades{
public $propiedad = "rojo";
public function getPropiedad(){
echo "\$propiedad ahora es una variable local a método y no tiene valor: --$propiedad--<br/>";
$propiedad="azul";
echo "Ahora visualizo el valor de \$propiedad del método: --$propiedad--<br/>";
echo "Ahora visualizo el valor de \$propiedad de la clase: --$this->propiedad--<br/>";
}
}
$a = new Propiedades();
$a->getPropiedad();
?>
Métodos
- Es la forma de especificar el comportamiento de la clase
- Es lo que el objeto va a saber hacer dentro del programa
- Los métodos de detallan usando la palabra reservada function
- En php dentro de la programación orientada a objetos tenemos una serie o tipo de métodos que es muy importante conocer y se llaman #métodos mágicos, que posteriormente estudiaremos.
- Los métodos mágicos son métodos de la clase que son invocados de manera implícita cuando ocurre alguna circunstancia concreto.
- Por ejemplo como vamos a ver en el párrafo siguiente, cuando se instancia un objeto se invoca (si está implementado), al método mágico __construct. a continuación se explica.
métodos contructor y destructor
- En php, al igual que ocurre en Java, podemos tener un método con el mismo nombre que la clase.
- Cuando instanciamos un objeto de una determinada clase, si existe este método se ejecuta y podríamos entenderlo como constructor de la clase.
- Pero realmente el constructor corresponde a un #método mágico llamado __construct()'que es invocado y ejecutado siempre que se instancie un nuevo objeto de la clase (si lo hemos escrito en la clase). En este caso no se ejecutará el método con el nombre de la case si es que existiera.
- El igual que tenemos un método que se ejecuta cuando instanciamos un objeto de la clase, existe otro #método mágico que se ejecuta siempre que se destruya una instancia de una clase u objeto, y es el método __destruct()
- Las implementaciones de estos dos métodos, lógicamente son libre para cada clase,
- Su invocación es transparente para el programador (esto es cómo ocurre en todos los #métodos mágicos y se realiza siempre respectivamente al crear el objeto, y cuando este es destruido,
- En el caso de __construct, podemos pasarle argumentos, que serían los valores que aportamos al construir un objeto de la case
|
|
Usando constructores
|
|
|
class Clase1 {
//put your code here
public function Clase1($m){
echo "Estoy en constructor de Clase1, método Clase1,
y he recibido el paŕametro <strong>$m</strong>";
}
}
$obj1 = new Clase1("Mensaje pasado al constructor ");Estoy en constructor de Clase1, métdo Clase1,
y he recibido el paŕametro Mensaje pasado al constructor
Alternativamente de forma más correcta establecemos el constructor con el método mágico __construct()
class Clase1 {
//put your code here
public function __construct($m){
echo "Estoy en constructor de Clase1, métdo __construct,
y he recibido el paŕametro <strong>$m</strong>";
}
}
$obj1 = new Clase1("Mensaje pasado al constructor ");
?>
- La salida del código anterior
Estoy en constructor de Clase1, métdo __construct,
y he recibido el paŕametro Mensaje pasado al constructor
Tip: El constructor puede recibir parámetros pasados al crear la instancia del objeto con el operador 'new'
|
- En caso de tener los dós métodos, se ejecuta solamente el código del método __construct()
métodos mágicos
- Una serie de métodos cuyos nombres están reservados y se pueden usar con cualquier objeto de cualquier clase.
- Su nombre siempre empieza por __
- Estos métodos que se invocan automáticamente cuando ocurre algo, en php se conocen como métodos mágicos.
- Un ejemplo son el __construct(...) y __destruct(...)
http://php.net/manual/es/language.oop5.magic.php
- Otro ejemplo importante son los métodos __toString() y __call($function, $paramters)
|
|
__toString()
|
|
|
- Este método es invocado si queremos convertir el objeto en un string
- No recibe parámetros , pues no se invoca de forma explícita
- Lo correcto es que retorne un string
class Racional {
//put your code here
private $num;
private $den;
public function __construct($num, $den){
$this->num = $num;
$this->den = $den;
}
public function __toString(){
return ("$this->num/$this->den");
}
}
$r1 = new Racional (8,5);
echo "Valor del objeto r1 = $r1";
?>Valor del objeto r1 = 8/5
|
__call($metodo, $parametros )
- Este método es invocado siempre que invoquemos a un método de la clase que no exista
- Recibe los siguientes parámetros
1.- $metodo es el nombre del método invocado
1.- $parametros es un array indexado con la lista de los parámetros con los que invocamos a la función
|
|
|
uso de __call($metodo, $parametros )
|
|
|
class Racional {
//put your code here
private $num;
private $den;
public function __construct($num, $den){
$this->num = $num;
$this->den = $den;
}
public function __call($funcion, $argumentos){
echo "<h2>Has invocado a un método que no existe en esta clase </h2>";
echo "Nombre de la función <strong>$funcion</strong><br />";
echo "Lista de parámetros<br />";
foreach ($argumentos as $param => $valor){
echo "parámetro <strong>$param</strong> = <strong>".print_r($valor, true).
"</strong> <br />";
//Poner en print_r el segundo parámetro a true,
//hace que esa función en lugar de imprimir, retorna el valor.
}
}
}
}
$r1 = new Racional(5,4);
$r1->metodoInventado1(5,4,5,6,7);
$r1->otroMetodoSinParametros();
$r1->otroMetodo([1,2,3],"parametro2", 5,"ultimo parametro");
?>
|
|
