Diferencia entre revisiones de «Usuario:ManuelRomero/php/opp/introduccion»

De WikiEducator
Saltar a: navegación, buscar
(→‎Métodos)
 
(39 revisiones intermedias por el mismo usuario no mostrado)
Línea 1: Línea 1:
 
{{TEP}}
 
{{TEP}}
 
{{:Usuario:ManuelRomero/php/opp/nav}}
 
{{:Usuario:ManuelRomero/php/opp/nav}}
 +
  
 
<!--__NOEDITSECTION__-->
 
<!--__NOEDITSECTION__-->
Línea 12: Línea 13:
 
[[Imagen:DWES_TituloTema6.png|center]]
 
[[Imagen:DWES_TituloTema6.png|center]]
 
|}
 
|}
−
==Repaso básico de la programación orientada a objetos==
+
__NOTOC__
 +
{{#widget:Slides}}
 +
<!--{{:Usuario:ManuelRomero/php/arrays/nav}}-->
 +
<div class="slides layout-regular template-default">
 +
<div class="slide">
 +
<!--1 -->
 +
 
 +
===Programación orientada a objetos===
 
*En programación el paradigma imperativo está basado en funciones y datos,  
 
*En programación el paradigma imperativo está basado en funciones y datos,  
 
*El paradigma orientado a objetos está basado en Objetos.
 
*El paradigma orientado a objetos está basado en Objetos.
 
*Los '''objetos''' son el elemento básico y central de la programación orientada a objetos (OOP) o (POO)
 
*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 sitema que queremos automatizar por software
+
*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.
 
*Un Objeto es una entidad (concreta o abstracta) que presenta una actividad en un entorno  concreto, en un determinado universo de discurso.
−
{{Definicion| '''Objeto''' Cada '''elemento activo''' que identificamos dentro de un determinado univeso de discurso}}
+
<br/>
 +
</div>
 +
<!--1 -->
 +
<div class="slide">
 +
{{Definicion| '''Objeto''' Cada elemento activo''' que identificamos dentro de un determinado univeso de discurso}}
 +
</div>
 +
<!--1 -->
 +
<div class="slide">
 
{{Ejemplo|
 
{{Ejemplo|
 
;En un banco hay cuentas bancarias  (objeto)
 
;En un banco hay cuentas bancarias  (objeto)
Línea 24: Línea 39:
 
:Las cuentas se pueden dar de alta, de baja, hacer extracciones e ingresos y transferencias... '''''metodos'''''
 
:Las cuentas se pueden dar de alta, de baja, hacer extracciones e ingresos y transferencias... '''''metodos'''''
 
}}
 
}}
−
Una clase es la estructura de un tipo concreto de objetos.
+
</div>
−
Los objetos son elementos concretos en mi sistema.
+
<!--1 -->
−
La estructura común (datos y comportamiento) de los objetos sirven especificar su composición
+
<div class="slide">
−
Esta composición queda descrita y especificada en la clase.
+
*Puede parecer una forma más complicada de programar, pero es una manera de dividir la naturaleza del problema que estamos estudiando en unidades independinetes que pueden  interactúan entre ellas.
−
Una clase tiene dos elementos
+
*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
 +
<!--1 -->
 +
</div>
 +
<!--1 -->
 +
<div class="slide">
 +
===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 .
 +
*Una clase es la estructura de un tipo concreto de objetos.
 +
*Los objetos son elementos concretos en mi sistema.
 +
</div>
 +
<!--1 -->
 +
<div class="slide">
 +
;Elementos de la POO
 +
*La estructura común (datos y comportamiento) de los objetos sirven especificar su composición
 +
*Esta composición queda descrita y especificada en la clase.
 +
*Una clase tiene dos elementos
 
  '''''Atributos''''' ==> Son las características o datos de un objeto
 
  '''''Atributos''''' ==> Son las características o datos de un objeto
 
                         Su valor nos da el estado de un objeto en un momento dado
 
                         Su valor nos da el estado de un objeto en un momento dado
 +
</div>
 +
<!--1 -->
 +
<div class="slide">
 +
;Elementos de la POO
 
  '''''Comportamiento'''''==> permiten modificar el estado de un objetos
 
  '''''Comportamiento'''''==> permiten modificar el estado de un objetos
 
                         Permiten saber como es el estado de un objeto
 
                         Permiten saber como es el estado de un objeto
Línea 37: Línea 74:
 
                         También lo son acciones internas para  facilitar las cosas al objeto
 
                         También lo son acciones internas para  facilitar las cosas al objeto
  
−
[[Archivo:clase.png]]
+
[[Archivo:clase.png|300px]]
−
+
</div>
−
==OPP En php==
+
<!--1 -->
 +
<div class="slide">
 +
===OPP En php===
 
*PHP no se diseñó como lenguaje orientado a objetos, por lo que muchas de las carácterísticas de este paradigma se ha ido incorporando en las últimas versiones, especialemnte a partir de la versión 5.3.
 
*PHP no se diseñó como lenguaje orientado a objetos, por lo que muchas de las carácterísticas de este paradigma se ha ido incorporando en las últimas versiones, especialemnte 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.
 
*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. Veremos este concepto más adelante.
 
*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. Veremos este concepto más adelante.
−
*Los elementos de una clase en php se identifican como  
+
</div>
 +
<!--1 -->
 +
<div class="slide">
 +
;Los elementos de una clase en php se identifican como  
 
#propiedades: son los atributos o carácterísticas de la clase.
 
#propiedades: son los atributos o carácterísticas de la clase.
 
#métodos: representas el comportamiento de la misma.
 
#métodos: representas el comportamiento de la misma.
 +
</div>
 +
<!--1 -->
 +
<div class="slide">
 
;Definir una clase en php
 
;Definir una clase en php
 
<source lang=php>
 
<source lang=php>
Línea 55: Línea 100:
 
*'''''NombreClase''''' es un identificador válido con la siguiente expresión regular
 
*'''''NombreClase''''' es un identificador válido con la siguiente expresión regular
 
   ^[a-zA-Z_][a-zA-Z0-9_]*$
 
   ^[a-zA-Z_][a-zA-Z0-9_]*$
 +
*El nombre de las clases se recomienda que empiece por mayúsculas
 +
</div>
 +
 +
<!--1 -->
 +
<div class="slide">
 
*'''''propiedades''''' son las variables o constantes definidas dentro de la clase.
 
*'''''propiedades''''' son las variables o constantes definidas dentro de la clase.
 
*'''''métodos''''' son las funciones que definirán el comportamiento de la clase.
 
*'''''métodos''''' son las funciones que definirán el comportamiento de la clase.
 +
{{Ejemplo|
 +
Vamos a crear una clase llamada fecha
 +
*Atributos de la clase (dia, mes, year)
 +
*Metodos (obtener la fecha como una cadena de caracteres
 +
}}
 +
</div>
 +
<div class="slide">
 +
===Pilares básicos de la POO===
 +
{{Puntos clave|
 +
;Encapsulación
 +
;Herecia
 +
;Polimorfismo
 +
;Abstraccion
 +
}}
 +
</div>
 +
<div class="slide">
 +
===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 y me permite o restringe la visibilidad de sus componentes
 +
</div>
 +
<div class="slide">
 +
===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
 +
</div>
 +
<div class="slide">
 +
;Visibilidad
 +
*Son tres los tipos de visibilidad que podemos especificar:
 +
;public : tipo de visibilidad asignada por defecto  en caso de no especificar.
 +
;private
 +
;protected
 +
</div>
 +
<div class="slide">
 +
;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 '''''->'''''
 +
</div>
 +
<div class="slide">
 +
;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.
 +
</div>
 +
<div class="slide">
 +
<source lang=php>
 +
<?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);
 +
//...
 +
?>
 +
</source>
 +
</div>
 +
<div class="slide">
 +
;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
 +
</div>
 +
<div class="slide">
 +
<source lang=php>
 +
<?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();
 +
 +
?>
 +
</source>
 +
 +
</div>
 +
<div class="slide">
 +
<!--1 -->
 +
<div class="slide">
 
===Propiedades===
 
===Propiedades===
 
*Al igual que en el código estructurado los valores que almaceno en memoria, las propiedades de los objetos pueden ser.
 
*Al igual que en el código estructurado los valores que almaceno en memoria, las propiedades de los objetos pueden ser.
Línea 67: Línea 240:
 
*A una constante hay que asignarle un valor no pudiendo asignar expresiones.
 
*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.
 
*Todos los objetos de la misma clase comparte el valor de la constante. Por lo que se tomará como un valor estático.
−
*Para acceder al valor de una constante
+
</div>
 +
 
 +
<!--1 -->
 +
<div class="slide">
 +
;Accediendo  al valor de una constante
 
#Dentro de la clase: usaremos el operador [[#self|'''''self''''']] junto con el '''''[[#::|operador de resolución de ámbito  ::''''']]
 
#Dentro de la clase: usaremos el operador [[#self|'''''self''''']] junto con el '''''[[#::|operador de resolución de ámbito  ::''''']]
 
#En el programa: identificando la clase, mediante el nombre de la clase, o bien la variable objeto de esa clase junto con el operador de resolución de ámbito '''''::''''', seguido del identificador de la constante.
 
#En el programa: identificando la clase, mediante el nombre de la clase, o bien la variable objeto de esa clase junto con el operador de resolución de ámbito '''''::''''', seguido del identificador de la constante.
 +
*Vemos un ejemplo de su uso
 
<source lang=php>
 
<source lang=php>
 
<?php
 
<?php
Línea 89: Línea 267:
 
?>
 
?>
 
</source>
 
</source>
 +
</div>
 +
<!--1 -->
 +
<div class="slide">
 +
 +
{{Ejemplo|
 +
Creamos la clase factura
 +
*Constantes IVA
 +
*Atributos Importe Base, fecha, impuestos, Importe bruto, estado (pagada o pendiente)
 +
*Métodos: imprime }}
 +
</div>
 +
<div class="slide">
 
;Variables
 
;Variables
 
*Estas propiedades  
 
*Estas propiedades  
 
*Las variables siguen la misma regla de construcción que vistas anteriormente.
 
*Las variables siguen la misma regla de construcción que vistas anteriormente.
 
*Las propiedades de la clase al igual que los métodos pueden especificárseles una determinada [[#visibilidad]] o alcance, siendo el valor por defecto '''''public'''''.
 
*Las propiedades de la clase al igual que los métodos pueden especificárseles una determinada [[#visibilidad]] o alcance, siendo el valor por defecto '''''public'''''.
−
*También puedes ser [[#static]] o estáticas, también conocidas como variables de la clase, si se epecifica con la palabra reservada '''''[[#static]]'''''
+
*También puedes ser [[#static]] o estáticas, también conocidas como variables de la clase, si se especifica con la palabra reservada '''''[[#static]]'''''.
 
*Dado que php es de tipado dinámico, si dentro de un método de la clase quiero acceder a una propiedad de la misma he de indicarlo usando la seudovariable '''''[[#$this]]''''
 
*Dado que php es de tipado dinámico, si dentro de un método de la clase quiero acceder a una propiedad de la misma he de indicarlo usando la seudovariable '''''[[#$this]]''''
 
*En este caso no  podremos el '''''$''''' delante del nombre de la propiedad
 
*En este caso no  podremos el '''''$''''' delante del nombre de la propiedad
 +
</div>
 +
<div class="slide">
 +
 
<source lang=php>
 
<source lang=php>
 
<?php
 
<?php
 
class Propiedades{
 
class Propiedades{
 
     public $propiedad = "rojo";
 
     public $propiedad = "rojo";
−
     function getPropiedad(){
+
     public function getPropiedad(){
 
         echo "\$propiedad ahora es una variable local a método y no tiene valor: --$propiedad--<br/>";
 
         echo "\$propiedad ahora es una variable local a método y no tiene valor: --$propiedad--<br/>";
−
         $propiedad="Valor local de \$propiedad en el método getPropiedad()<br>";
+
         $propiedad="azul";
−
        echo "Ahora visualizo el valor de \$propiedad de la clase:  --$this->propiedad--<br/>";
+
 
         echo "Ahora visualizo el valor de \$propiedad del método:  --$propiedad--<br/>";
 
         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/>";
 
     }  
 
     }  
 
}
 
}
Línea 110: Línea 302:
 
$a = new Propiedades();
 
$a = new Propiedades();
 
$a->getPropiedad();
 
$a->getPropiedad();
−
?></source>
+
?>
 +
</source>
 +
</div>
 +
<div class="slide">
 +
 
 +
 
 
===Métodos===
 
===Métodos===
 
*Es la forma de especificar el comportamiento de la clase
 
*Es la forma de especificar el comportamiento de la clase
Línea 116: Línea 313:
 
*Los métodos de detallan usando la palabra reservada '''''function'''''
 
*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 conviene conocer y que posteriormente estudiaremos
 
*En php dentro de la programación orientada a objetos tenemos una serie o tipo  de métodos que conviene conocer y que posteriormente estudiaremos
 +
</div>
 +
<div class="slide">
 +
 
;[[#métodos contructor y destructor]]
 
;[[#métodos contructor y destructor]]
 
*son el método __construct(..) y __destruct(..)
 
*son el método __construct(..) y __destruct(..)
 
*Su implementación es libre para cada clase,  
 
*Su implementación es libre para cada clase,  
 
*Su invocación es transparente para el programador y se realiza siempre respectivamente al crear el objeto, y cuando este es destruido
 
*Su invocación es transparente para el programador y se realiza siempre respectivamente al crear el objeto, y cuando este es destruido
 +
*El nombre es __construct y __destruct respectivamente, si bien, la lista de argumentos que pueden recibir, así como las acciones que pueden realizar es libre de implementar.
 +
*Estos métodos que se invocan automáticamente cuando ocurre algo, en php se conocen como métodos mágicos.
 +
</div>
 +
<div class="slide">
 +
 
;[[#métodos mágicos]]
 
;[[#métodos mágicos]]
 
*Una serie de métodos cuyos nombres están reservados y se pueden usar con cualquier objeto de cualquier clase.
 
*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 __
 
*Un ejemplo son el __construct(...) y __destruct(...)
 
*Un ejemplo son el __construct(...) y __destruct(...)
 
  http://php.net/manual/es/language.oop5.magic.php
 
  http://php.net/manual/es/language.oop5.magic.php
−
;[[#métodos abstractos]]
+
</div>
−
Son métodos que no tienen código y su implementación se establece al crear una clase que derivada de  la clase que contiene el método abstracto.
+
<div class="slide">
−
#[[#métodos estáticos ]]
+
−
*También llamados métodos de la clase, solo se crea una instancia, la cual es compartida por todos los objetos de la misma clase.
+
−
*Para poder acceder a un método estático, al igual que en las propiedades estáticas o en las constantes, hay que usar el operador de resolución de ambito [['''''#::''''']]
+
−
<source lang=php>
+
−
class Lock
+
−
{
+
−
    private $isLocked = false;
+
−
+
−
    public function unlock()
+
−
    {
+
−
        $this->isLocked = false;
+
−
        echo 'You unlocked the Lock';
+
−
    }
+
−
    public function lock()
+
−
    {
+
−
        $this->isLocked = true;
+
−
        echo 'You locked the Lock';
+
−
    }
+
−
    public function isLocked()
+
−
    {
+
−
        return $this->isLocked;
+
−
    }
+
−
}
+
−
+
−
$aLock = new Lock; // Create object from the class blueprint
+
−
$aLock->unlock();  // You unlocked the Lock
+
−
$aLock->lock();    // You locked the Lock
+
−
</source>
+
−
 
+
−
Estáticas
+
−
No estaticas
+
−
Privadas
+
−
Púbicas
+
−
Protegidas
+
−
 
+
−
===métodos contructor y destructor===
+
−
===métodos mágicos===
+
−
===métodos abstractos===
+
−
===métodos estáticos===
+
−
 
+
−
 
+
−
 
+
−
====Enlace estático en tiempo de ejecución====
+
−
*Para poder hacer referencia en tiempo de ejecución a un elemento estático de la clase se usa este operador
+
−
*Elementos estáticos en php
+
−
#Constantes
+
−
#Variables estáticas
+
−
#Métodos estáticos
+
−
*Este operador lo podemos usar tanto dentro de la clase, como fuera de la misma
+
−
Operador de resolucion de ámbito ::
+
−
http://php.net/manual/es/language.oop5.paamayim-nekudotayim.php
+
−
==static==
+
−
==$this==
+
−
 
+
−
===métodos===
+
−
===pseudovariables '''''this'''''===
+
−
===operador '''''self''''' y '''''parent'''''===
+
−
 
+
−
 
+
 
===Instancias: Operador '''''new'''''===
 
===Instancias: Operador '''''new'''''===
 
*Una clase describe lo común de unos determinados objetos
 
*Una clase describe lo común de unos determinados objetos
Línea 203: Línea 350:
 
{{Actividad|
 
{{Actividad|
 
*Crea una clase llamada producto con los atributos código, nombre y precio}}
 
*Crea una clase llamada producto con los atributos código, nombre y precio}}
 +
</div>
 +
<div class="slide">
 
;Accediendo a los atributos de un objeto: seudovariable $this
 
;Accediendo a los atributos de un objeto: seudovariable $this
 
*$this  es una seudovariable que referenica al objeto del ámbito en el cual está usado
 
*$this  es una seudovariable que referenica al objeto del ámbito en el cual está usado
 
*Se utiliza dentro de la definición de la propia clase y hará referencia a un objeto concreto en un momento dado de la clase en la que está siendo utilizado
 
*Se utiliza dentro de la definición de la propia clase y hará referencia a un objeto concreto en un momento dado de la clase en la que está siendo utilizado
−
*Ejemplo  
+
</div>
 +
 
 +
<div class="slide">
 +
;Ejemplo  
 
<source lang=php>
 
<source lang=php>
 
<?php
 
<?php
Línea 220: Línea 372:
 
     }
 
     }
 
}
 
}
−
</source>
 
−
*Para usar el código anterior
 
−
<source lang=php>
 
  
−
$a = new MyClase();
 
−
$a->ser_estar();
 
  
−
// Accedo directamente al método de la clase
+
</div>
−
MyClase::ser_estar();
+
<div class="slide">
−
</source>
+
{{Actividad|
−
*Si desde la propia clase quiero acceder a métodos o atributos estáticos, se usa el operador '''''self'''''
+
=Empleado=
 +
Confeccionar una clase Empleado, definir como atributos su nombre y sueldo.
 +
Definir un método inicializar que lleguen como dato el nombre y sueldo. Plantear un segundo método que imprima el nombre y un mensaje si debe o no pagar impuestos (si el sueldo supera a 3000 paga impuestos)
 +
 
 
<source lang=php>
 
<source lang=php>
−
class Producto {
+
<html>
−
    private static $num_productos = 0;  
+
<head>
−
     private $codigo;
+
<title>Pruebas</title>
−
//.....
+
</head>
−
    public funtion ventaProducto($cantidad){
+
<body>
−
    //Este método podría realizar hacer varias cosas , y luego quiero decrementar elemento
+
<?php
−
    $this->decrementa($cantidad);
+
class Empleado {
 +
  private $nombre;
 +
  private $sueldo;
 +
 
 +
  public function asigna($nom,$sue)
 +
  {
 +
    $this->nombre=$nom;
 +
     $this->sueldo=$sue;
 +
  }
 +
  public function pagaImpuestos()
 +
  {
 +
    echo $this->nombre;
 +
    echo '-';
 +
    if ($this->sueldo>3000)
 +
      echo 'Debe pagar impuestos';
 +
    else
 +
      echo 'No paga impuestos';
 +
    echo '<br>';
 +
  }
 +
}
 +
 
 +
$empleado1=new Empleado();
 +
$empleado1->inicializar('Luis',2500);
 +
$empleado1->pagaImpuestos();
 +
$empleado1=new Empleado();
 +
$empleado1->inicializar('Carla',4300);
 +
$empleado1->pagaImpuestos();
 +
?>
 +
</body>
 +
</html>
 +
</source>
 +
 
 +
===Actividades===
 +
<br/>
 +
{{Actividad|
 +
Confeccionar una clase Menu. Permitir añadir la cantidad de opciones que necesitemos. Mostrar el menú en forma horizontal o vertical (según que método llamemos)
 +
}}
 +
<source lang = php>
 +
<html>
 +
<head>
 +
<title>Pruebas</title>
 +
</head>
 +
<body>
 +
<?php
 +
class Menu {
 +
  private $enlaces=array();
 +
  private $titulos=array();
 +
  public function cargarOpcion($en,$tit)
 +
  {
 +
    $this->enlaces[]=$en;
 +
    $this->titulos[]=$tit;
 +
  }
 +
  public function mostrarHorizontal()
 +
  {
 +
    for($f=0;$f<count($this->enlaces);$f++)
 +
    {
 +
      echo '<a href="'.$this->enlaces[$f].'">'.$this->titulos[$f].'</a>';
 +
      echo "-";
 
     }
 
     }
−
    public function incrementa ($cantidad) {
+
  }
−
        self::$num_productos-=$cantidad;
+
  public function mostrarVertical()
 +
  {
 +
    for($f=0;$f<count($this->enlaces);$f++)
 +
    {
 +
      echo '<a href="'.$this->enlaces[$f].'">'.$this->titulos[$f].'</a>';
 +
      echo "<br>";
 
     }
 
     }
−
//....
+
  }
 +
}
 +
 
 +
$menu1=new Menu();
 +
$menu1->cargarOpcion('http://www.google.com','Google');
 +
$menu1->cargarOpcion('http://www.yahoo.com','Yhahoo');
 +
$menu1->cargarOpcion('http://www.msn.com','MSN');
 +
$menu1->mostrarVertical();
 +
?>
 +
</body>
 +
</html>
 
</source>
 
</source>
  
−
*Observar la función get_class(), me retorna el nombre del objeto actual si no se le pasa parámetro
+
{{Actividad|
−
http://php.net/manual/es/function.get-class.php
+
Construir una clase llamado racional que podamos inicializar con un string del tipo por ejemplo "8/5"
−
*Observar que para acceder a los diferentes elementos de un objeto se utilizar el operador de indirección '''''->'''''. Esto es por que en realidad el nombre del objeto es una dirección de memoria.
+
}}
−
===Funciones para usar con objetos===
+
−
*Al igual que get_class(), existen una serie de funciones interesantes que conviene conocer.
+
−
*Ver la siguiente referenica
+
−
http://php.net/manual/es/ref.classobj.php
+
−
 
+
−
 
+
−
===Estableciendo nivel de acceso:Encapsulación===
+
−
*tanto los atributos como los métodos  pueden tener diferentes niveles de acceso
+
−
;private Solo accesible desde la propia clase
+
−
;public (Si se utiliza la sintexis var de php 4, implica acceso pulbic). Acceso total
+
−
;protected Solo accesible desde las clases que presentas herencia
+
−
===Constructor===
+
−
*En php existe un método llamado __construct(..) el cual es invocado siempres que se instancia un objeto
+
−
*Es el constructor, y su invocación es implícita al operador new.
+
−
*En PHP5 puedes definir en las clases métodos constructores, que se ejecutan cuando se crea el objeto. El constructor de una clase debe llamarse __construct. Se pueden utilizar, por ejemplo, para asignar valores a atributos.
+
 
<source lang=php>
 
<source lang=php>
−
class Producto {
+
<?php
−
     private static $num_productos = 0;  
+
class racional {
−
     private $codigo;
+
    //put your code here
−
+
     private $numRacional;
−
  public function __construct() {
+
     public function __construct($cadena) {
−
         self::$num_productos++;
+
        $this->numRacional = $cadena;
 +
    }
 +
    public function visualiza(){
 +
         return $this->numRacional;
 
     }
 
     }
−
    …
 
 
}
 
}
  
−
*El constructor de una clase puede llamar a otros métodos o tener parámetros, en cuyo caso deberán pasarse cuando se crea el objeto. Sin embargo, sólo puede haber un método constructor en cada clase.
+
$a=new racional("8/5");
−
<source lang=php>
+
$b=new racional("6/4");
−
class Producto {
+
echo '<br>valor de $a: '. $a->visualiza();
−
    private static $num_productos = 0;  
+
echo '<br>valor de $b: '. $b->visualiza();
−
    private $codigo;
+
?>
 +
</source>
  
−
    public function __construct($codigo) {
+
 
−
      $this->$codigo = $codigo;
+
;Sobrecarga
−
      self::$num_productos++;
+
Un concepto muy importante es la sobre carga.
−
    }
+
*Este concepto es básico en la programación Orientada a objetos;
 +
*Sin embargo este aspecto en php no es del todo intuitivo. No existe la sobrecarga como la entendemos en otros lenguajes
 +
*No obstante tenemos técnicas para poder simular la sobrecarga.
 +
*Muchas veces es fundamental  o al menos cómodo sobrecargar el constructor de la clase.
 +
*Vamos a ver como podemos implementar la sobrecarga en php
 +
*Supongamos que en el ejemplo anterior quisiérmos poder instanciar de la siguiente manera los racionales
 +
<source lang=php>
 +
$a = new racional ("8/5");/*  8/5  */
 +
$b = new racional (5,4);  /*  5/6  */
 +
$c = new racional (5);    /*  5/1  */
 +
$d = new racional ();     /*  1/1  */
 +
</source>
 +
*Para esta situación tenemos diferentes estrategias. En este tema vamos a analizar 2:
 +
#sobrecargar en el constructor
 +
#sobrecargar con '''''métodos mágicos'''''
 +
;Sobrecargar en el constructor
 +
*Una sencila es ir viendo de qué tipo son los parámetros
 +
*Vemos que podemos tener 0, 1 o 2 paŕametros
 +
*Por lo tanto la función constructora tendrá que tener 3 parámetros inicializados por si no le pasamos valores
 +
<source lang=php>
 +
public function __construct($cadenaOrNum=null, $den = null) {
 +
....
 
}
 
}
−
$p = new Producto('GALAXYS');
 
 
</source>
 
</source>
−
*Por ejemplo, si como en este ejemplo, definimos un constructor en el que haya que pasar el código, siempre que instancies un nuevo objeto de esa clase tendrás que indicar su código.
+
{{Actividad|Vamos a simular la sobre carga de la clase racional
−
{{Pregunta|Ahora habría que pensar como implementar la sobre carga de un constructor }}
+
−
{{Actividad|
+
−
*Realiza una clase para acceso a la base de datos
+
−
*Será una forma de reescribir mysqli mas amigable para nosotrs
+
−
*Podremos conectar.
+
−
*Si no pasamos valor por defecto se conectará con los parámetros de siempre (localhost, dwes, root, root
+
−
*Verificará usuario en la tabla de usuarios
+
−
*Insertará un usuario
+
−
*Obtendrá los datos de un producto o de todos
+
−
*Realiza luego un programa que utilice esta clase y observa su comodidad.
+
 
<source lang=php>
 
<source lang=php>
 +
 
<?php
 
<?php
−
require_once('Producto.php');
+
/**
 +
* Description of racional
 +
*
 +
* @author manolo
 +
*/
 +
class racional {
 +
    //put your code here
 +
    private $numRacional;
 +
    private $num;
 +
    private $den;
 +
    public function __construct($cadenaOrNum=null, $den = null) {
 +
        if (is_int($cadenaOrNum)){
 +
            if (isset($den))
 +
                $this->racionalNumDen($cadenaOrNum, $den );
 +
            else
 +
                $this->racionalNum($cadenaOrNum );
 +
        }
 +
        else{
 +
            if (isset($cadenaOrNum))
 +
                $this->racionalCadena($cadenaOrNum);
 +
            else
 +
                $this->racionalVacio();
 +
        }
 +
    }
 +
   
 +
    private function racionalNumDen($num, $den){
 +
        $this->numRacional=$num."/".$den;
 +
        $this->num=$num;
 +
        $this->den=$den;
 +
        $this->convierteNum();
 +
    }
 +
    private function racionalNum($num){
 +
        $this->numRacional=$num."/1";
 +
        $this->num=$num;
 +
        $this->den=1;
 +
        $this->convierteNum();
 +
    }
 +
    private function racionalCadena($cadenaOrNum){
 +
        $this->numRacional=$cadenaOrNum;
 +
        $pos = strpos($cadenaOrNum,"/");
 +
       
 +
        $num=substr($cadenaOrNum,0,$pos);
 +
        $den=substr($cadenaOrNum,$pos+1);
 +
        $this->num=$num;
 +
        $this->den=$den;
 +
    }
 +
    private function racionalVacio(){
 +
        $this->numRacional="1/1";
 +
        $this->num=1;
 +
        $this->den=1;
 +
    }
 +
    private function convierteNum(){
 +
        settype($this->num, int);
 +
        settype($this->den, int);
 +
    }
 +
   
 +
       
  
−
class DB { 
+
     public function visualiza(){
−
     public public  __contruct(.....){
+
        return $this->numRacional;
−
    //Este método conecta por defecto con localhost, root root y dwes
+
 
     }
 
     }
−
     public function ejecutaConsulta($sql) {
+
     public function valorRacional(){
−
     //realiza una consulta
+
        return $this->num/$this->den;
−
 
+
    }
 +
    private function simplifica(){
 +
       
 +
     }
 +
    private function suma(racional $num){
 +
       
 
     }
 
     }
  
 +
}
  
−
    //Obitene todos los productos de la tabla productos y los reotorna en una array
+
$a=new racional("8/5");
−
    public function obtieneProductos() {
+
$b=new racional("6/4");
−
   
+
echo '<br>racional de $a: '. $a->visualiza();
−
    }
+
echo '<br>valor de $a: '. $a->valorRacional();
 +
echo '<br>racional de $b: '. $b->visualiza();
 +
echo '<br>valor de $b: '. $b->valorRacional();
 +
echo"<hr/>";
 +
$a=new racional();
 +
$b=new racional();
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
echo '<br>racional de $b: '. $b->visualiza();
 +
echo '<br>valor de $b: '. $b->valorRacional();
 +
echo"<hr/>";
 +
$a=new racional(8);
 +
$b=new racional(4);
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
echo '<br>racional de $b: '. $b->visualiza();
 +
echo '<br>valor de $b: '. $b->valorRacional();
 +
echo"<hr/>";
 +
$a=new racional(124,6);
 +
$b=new racional(7,123);
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
echo '<br>racional de $b: '. $b->visualiza();
 +
echo '<br>valor de $b: '. $b->valorRacional();
  
−
   
+
?>
−
    //Obtiene un producto determinado
+
−
    public function obtieneProducto($codigo) {
+
  
 +
</source>
 +
 +
}}
 +
 +
*Código implementado en clase
 +
<!--
 +
<source lang=php>
 +
<?php
 +
 +
/**
 +
* Description of racional
 +
*
 +
* @author alumno
 +
*/
 +
class racional {
 +
    //put your code here
 +
    private $num;
 +
    private $den;
 +
    private $numRacional;
 +
    public function __construct($cadenaOrNum=null, $den = null) {
 +
        if (is_null($cadenaOrNum))
 +
          $this->racionalVacio();   
 +
        else
 +
          if (!(is_null($den)))
 +
              $this->racionalNumDen($cadenaOrNum, $den );
 +
          else
 +
              if (is_int($cadenaOrNum))
 +
                  $this->racionalNum($cadenaOrNum);
 +
              else
 +
                  $this->racionalCadena($cadenaOrNum);
 
     }
 
     }
 
      
 
      
−
     //Verifica un cliente  para la clase en general
+
     //Sobrecargamos el m étodo asigna de modo que se pueda implementar de las siguientes maneras
−
     public static function verificaUsuario($nombre, $contrasena) {
+
     /*asigna("6/4");
 +
      asigna();
 +
      asigna(8);
 +
      asigna(124, 6);
 +
    * */
  
 +
    public function __call($metodo, $argumentos) {
 +
        if ($metodo = "asigna"){
 +
            switch (count($argumentos)){
 +
                case 0:
 +
                    $this->racionalVacio();
 +
                    break;
 +
                case 2:
 +
                    $this->racionalNumDen($argumentos[0], $argumentos[1]);
 +
                    break;
 +
                case 1:
 +
                    if (is_int($argumentos[0]))
 +
                        $this->racionalNum($argumentos[0]);
 +
                    else
 +
                        $this->racionalCadena($argumentos[0]);
 +
                    break;
 +
            }
 +
           
 +
           
 +
           
 +
           
 +
        }
 +
       
 +
    }
 +
    // caso $a = racional(8,7);
 +
    private function racionalNumDen($num, $den ){
 +
        $this->num=$num;
 +
        $this->den=$den;
 +
        $this->numRacional="$num/$den";
 +
       
 +
    }
 +
// caso $a = racional(8);
 +
    private function racionalNum($num ){
 +
        $this->num=$num;
 +
        $this->den=1;
 +
        $this->numRacional="$num/1";
 +
       
 +
    }
 +
// caso $a = racional("8/7");
 +
    private function racionalCadena($cadena){
 +
        $pos = strpos($cadena, "/");
 +
        $num = substr($cadena,0, $pos);
 +
        $den = substr($cadena ,$pos+1 );
 +
       
 +
        settype($num, "int");
 +
        settype($den, "int");
 +
       
 +
        $this->num= $num;
 +
        $this->den= $den;
 +
        $this->numRacional=$cadena;
 +
    }
 +
// caso $a = racional(); y se inicia con 1/1
 +
    private function racionalVacio(){
 +
        $this->num=1;
 +
        $this->den=1;
 +
        $this->numRacional="1/1";
 +
       
 +
       
 
     }
 
     }
−
    //Verifica un cliente  para la clase en general
 
−
    public static function insertaUsuario($nombre, $contrasena) {
 
−
 
 
      
 
      
 +
    public function visualiza(){
 +
        echo "<br/>valor del numerador ".$this->num;
 +
        echo "<br/>valor del denominador ".$this->den;
 +
        echo "<br/>valor del racional ".$this->numRacional;
 +
        echo "<br/>valor numerico ".($this->num/$this->den);
 +
    }
 
}
 
}
  
 +
 +
 +
//-------------------------
 +
 +
 +
$a= new racional();
 +
$b= new racional(5);
 +
$c= new racional(5,6);
 +
$d= new racional("6/6");
 +
 +
$a->visualiza();
 +
$b->visualiza();
 +
$c->visualiza();
 +
$d->visualiza();
 +
 +
$a->asigna(6000,545);
 +
$a->visualiza();
 +
$a->asigna("8458/55154");
 +
$a->visualiza();
 +
$a->asigna(85547);
 +
$a->visualiza();
 +
$a->asigna();
 +
$a->visualiza();
 
?>
 
?>
 +
 +
 +
 
</source>
 
</source>
  
 +
===Métodos mágicos===
 +
*Corresponde a un conjunto de métodos que tiene ya una utilidad concreta
 +
*Son nombres reservados y no se pueden utilizar para identificar otros elementos
 +
*Tienen una utilidad prefijada y es para lo que se deben utilizar
 +
*Todos ellos empiezan por dos caracteres de subrayado
 +
*Podemos ver y analizar su significado en la web de php
 +
http://php.net/manual/es/language.oop5.magic.php
 +
 +
*Hemos visto __construct y __destruct
 +
*Vamos a analizar un método mágico para implementar la sobrecarga y exponer su funcionamiento
 +
*Ël método '''''__call($nombreFuncion, $argumentos)'''' es un método mágico que se invoca cuando intentamos acceder a un método de la clase y este método no existe
 +
*Volvamos a nuestro racional
 +
*Supongamos que los métodos de sobrecarga que queremos son los usados en el constructor __construct
 +
<source lang=php>
 +
// caso $a = racional(8,7);
 +
racionalNumDen($cadenaOrNum, $den );
 +
// caso $a = racional(8);
 +
racionalNum($cadenaOrNum );
 +
// caso $a = racional("8/7");
 +
racionalCadena($cadenaOrNum);
 +
// caso $a = racional(); y se inicia con 1/1
 +
racionalVacio();
 +
</source>
 +
*Pero imagenimos que nos gustaría que todos tuvieran el mismo nombre, por ejemplo crea().
 +
*Vamos a usar el método __call para ello
 +
*Este método recibe dos argumentos
 +
# $nombreFuncion es el nombre del método que se invoca
 +
# $argumentos es un array con los argumentos de la función
 +
{{Actividad| vamos a sobrecargar el método asigna() de la clase racional de modo que accepte sobrecarga
 +
<source lang=php>
 +
 +
$a=new racional();
 +
 +
$a->asigna("6/4");
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
 +
echo"<hr/>";
 +
$a->asigna();
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
 +
echo"<hr/>";
 +
$a->asigna(8);
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
 +
echo"<hr/>";
 +
$a->asigna(124, 6);
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
</source>
 
<!--
 
<!--
 
<source lang=php>
 
<source lang=php>
 
<?php
 
<?php
−
require_once('Producto.php');
 
  
−
class DB {  
+
/*
−
    protected static function ejecutaConsulta($sql) {
+
  * To change this license header, choose License Headers in Project Properties.
−
        $opc = array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8");
+
* To change this template file, choose Tools | Templates
−
        $dsn = "mysql:host=localhost;dbname=dwes";
+
* and open the template in the editor.
−
        $usuario = 'dwes';
+
*/
−
        $contrasena = 'abc123.';
+
−
       
+
−
        $dwes = new PDO($dsn, $usuario, $contrasena, $opc);
+
−
        $resultado = null;
+
−
        if (isset($dwes)) $resultado = $dwes->query($sql);
+
−
        return $resultado;
+
−
    }
+
  
−
     public static function obtieneProductos() {
+
/**
−
         $sql = "SELECT cod, nombre_corto, nombre, PVP FROM producto;";
+
* Description of racional
−
        $resultado = self::ejecutaConsulta ($sql);
+
*
−
         $productos = array();
+
* @author manolo
−
 
+
*/
−
if($resultado) {
+
class racional {
−
            // Añadimos un elemento por cada producto obtenido
+
    //put your code here
−
            $row = $resultado->fetch();
+
    private $numRacional;
−
            while ($row != null) {
+
    private $num;
−
                $productos[] = new Producto($row);
+
    private $den;
−
                 $row = $resultado->fetch();
+
     public function __construct($argumento) {
 +
          
 +
    }
 +
    public function __call($name, $argumentos) {
 +
         if ($name=="asigna"){
 +
            switch (count($argumentos)){
 +
                case 0:
 +
                    $this->racionalVacio();
 +
                    break;
 +
                case 1: //Aquí tenemos dos casos hay que ver el tipo
 +
                    if (is_int($argumentos[0]))
 +
                        $this->racionalNum($argumentos[0]);
 +
                    else
 +
                        $this->racionalCadena($argumentos[0]);
 +
                   
 +
                    break;
 +
                 case 2:
 +
                    $this->racionalNumDen($argumentos[0],$argumentos[1]);
 +
                    break;
 
             }
 
             }
−
}
+
           
 +
        }
 +
   
 +
    }
 +
   
 +
    private function racionalNumDen($num, $den){
 +
        $this->numRacional=$num."/".$den;
 +
        $this->num=$num;
 +
        $this->den=$den;
 +
        $this->convierteNum();
 +
    }
 +
    private function racionalNum($num){
 +
        $this->numRacional=$num."/1";
 +
        $this->num=$num;
 +
        $this->den=1;
 +
        $this->convierteNum();
 +
    }
 +
    private function racionalCadena($cadenaOrNum){
 +
        $this->numRacional=$cadenaOrNum;
 +
        $pos = strpos($cadenaOrNum,"/");
 +
       
 +
        $num=substr($cadenaOrNum,0,$pos);
 +
        $den=substr($cadenaOrNum,$pos+1);
 +
        $this->num=$num;
 +
        $this->den=$den;
 +
    }
 +
    private function racionalVacio(){
 +
        $this->numRacional="1/1";
 +
        $this->num=1;
 +
        $this->den=1;
 +
    }
 +
    private function convierteNum(){
 +
        settype($this->num, int);
 +
        settype($this->den, int);
 +
    }
 +
   
 
          
 
          
−
        return $productos;
 
−
    }
 
−
 
−
   
 
−
    public static function obtieneProducto($codigo) {
 
−
        $sql = "SELECT cod, nombre_corto, nombre, PVP FROM producto";
 
−
        $sql .= " WHERE cod='" . $codigo . "'";
 
−
        $resultado = self::ejecutaConsulta ($sql);
 
−
        $producto = null;
 
  
−
if(isset($resultado)) {
+
    public function visualiza(){
−
            $row = $resultado->fetch();
+
        return $this->numRacional;
−
            $producto = new Producto($row);
+
    }
−
}
+
    public function valorRacional(){
 +
        return $this->num/$this->den;
 +
    }
 +
    private function simplifica(){
 
          
 
          
−
        return $producto;   
 
 
     }
 
     }
−
      
+
     private function suma(racional $num){
−
    public static function verificaCliente($nombre, $contrasena) {
+
          
−
         $sql = "SELECT usuario FROM usuarios ";
+
−
        $sql .= "WHERE usuario='$nombre' ";
+
−
        $sql .= "AND contrasena='" . md5($contrasena) . "';";
+
−
        $resultado = self::ejecutaConsulta ($sql);
+
−
        $verificado = false;
+
−
 
+
−
        if(isset($resultado)) {
+
−
            $fila = $resultado->fetch();
+
−
            if($fila !== false) $verificado=true;
+
−
        }
+
−
        return $verificado;
+
 
     }
 
     }
−
   
+
 
 
}
 
}
 +
 +
$a=new racional();
 +
$b=new racional();
 +
$a->asigna("8/5");
 +
$b->asigna("6/4");
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
echo '<br>racional de $b: '. $b->visualiza();
 +
echo '<br>valor de $b: '. $b->valorRacional();
 +
echo"<hr/>";
 +
$a->asigna();
 +
$a->asigna();
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
echo '<br>racional de $b: '. $b->visualiza();
 +
echo '<br>valor de $b: '. $b->valorRacional();
 +
echo"<hr/>";
 +
$a->asigna(8);
 +
$b->asigna(4);
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
echo '<br>racional de $b: '. $b->visualiza();
 +
echo '<br>valor de $b: '. $b->valorRacional();
 +
echo"<hr/>";
 +
$a->asigna(124, 6);
 +
$b->asigna(124, 6);
 +
echo '<br>racional de $a: '. $a->visualiza();
 +
echo '<br>valor de $a: '. $a->valorRacional();
 +
echo '<br>racional de $b: '. $b->visualiza();
 +
echo '<br>valor de $b: '. $b->valorRacional();
  
 
?>
 
?>
 +
 
</source>
 
</source>
−
-->
 
 
}}
 
}}
  
−
<!--
+
==::==
−
===Carácterísticas de la programación orientada a objetos===
+
*Operador de resolución de ámbito
−
*La programación orientada a objetos está basada en cuatro pilares fundamentales
+
*http://php.net/manual/es/language.oop5.paamayim-nekudotayim.php
−
*Estos pilares dan pontecia a este paradigma de la programación
+
*Se utiliza para poder acceder a los elementos estáticos de la clase
−
*Ŝu objetivo final es reutilizar componentes. Pensamos en el desarrollo software como una contrucción donde diferentes componentes se integran para interactuar y resolver un problema previamente planteado.
+
*En la parte de la izquierda hay que especificar el dominio o elemento al que pertenece la propiedad o método estático.
−
;Polimorfismo:
+
*Podremos usar;
−
:Hace referencia a utilizar un mimo método de diferentes maneras. según se invoque con unos u otros parámetros realizará unas acciones u otras
+
#nombre de clase,
−
;Herencia:
+
#nombre del objeto
−
Característica por la cual una clase puede heredar todas las características de otra clase y así especializar su funcionalidad a partir de una clase mas general previamente construida
+
# '''''self''''' : si es dentro de la misma clase
−
;Encapsulacion y Abstracción.
+
# '''''parent''''' : si el elemento pertenece a la clase de la que heredo
−
Estas carácterísticas son fundamentales. La idea es construir una clase y tener encerrada dentra de ella su programación. Cara al esterior un programador que utilice dicho objeto sabe lo qué hace y para que puede utilizar dicho objeto, también debe saber como usarlo. Pero como lo hace no es información relevante para él.
+
#'''''static''''' Al igual que self se puede usar la palabra reservada estatic, para acceder a un elemento estático de la clase.
−
==elementos estáticos==
+
−
Dentro de una clase es posible definir elementos estáticos
+
−
tanto atributos como operaciones
+
−
Estos elementos tiene un comportameinto especial
+
−
su valor o funcionalidad es compartida por todos los objetos de la clase
+
−
solo hay una referencia a ello en memoria
+
−
no se crean en memoria por cada objeto
+
−
Permanecen en memoria mientras exista un objeto de la clase
+
−
Una operación estática solo puede  acceder a miembros estáticos
+
−
o invocar a otros métodos estáticos
+
  
−
==Modificadores de acceso==
 
−
*Exiten tres modificadores explícitos de acceso
 
−
*Es una forma de ocultar información al exterior
 
−
*permite implementar el principio de encapsulación
 
−
;''publico(+)'' ''''public'''' Todos pueden acceder sin ningún tipo de restricción para acceder a ese miembro
 
−
;''privado(+)'' ''''private'''' Nadie sino la propia clase puede acceder a ese miembro
 
−
;''protegido(+)'' ''''protected'''' Sólo la propia clase y clases derivadas pueden acceder a ese miembro
 
−
[[Archivo:Modificadores.png]]
 
−
;Los miembros no etiquetados son accesibles por clases amigas
 
−
:En java las clases amigas son las que pertenecen a un mismo paquete
 
−
:para especificar un paquete se usa la palabra reservada '''package'''
 
−
{{Lectura|Las clases que no se decalren dentro de un paquete pertenecen a un paquete por defecto Todas ellas}}
 
  
−
+
<!-- Dejo esto aquí a ver si lo completo o no
−
 
+
===métodos abstractos===
−
==Constructor==
+
===métodos estáticos===
−
*Cuando se instancia un objeto de una clase normalmente hay que dar valor a sus atributos
+
−
*Esto se hace con un método especial llamado constructor
+
−
*El constructor es un método que no debe de retornar nada
+
−
*Se ha de llamar exactamente igual que la clase
+
−
*Siempre ha de haber un constructor, en caso de no haberlo el sistema crea uno por defecto (transparente)
+
−
*Inicializa los atributos con valores por defecto 0,cadena vacía, null,...
+
−
*Si una clase tiene superclase se invoca al constructor de su supertipo si no se hace explícitamente
+
−
*En caso de hacer explícitamente ha de ser la primera instrucción del constructor
+
−
*Se hace con la palabra reservada '''super(..)'''
+
−
==Destructor==
+
−
*El destructor es un método especial que se ejecuta cuando el objeto se destruye (se libera la memoria donde estaba ubicado)
+
−
*En java existe lo que se llama el recolector de basura
+
−
*Esto implica que no tenemos que preocuparnos de eliminar un objeto
+
−
*Sin embargo existe un método que podemos invocar al destruirse un objeto
+
−
*el método se llama '''finalize''' y el código que en él pongamos se ejecutará cuando se destruya el objeto
+
 
=Herencia=
 
=Herencia=
 
*La herencia es un mecanismo por el cual puedo definir una clase con ciertas características (atributos, métodos)
 
*La herencia es un mecanismo por el cual puedo definir una clase con ciertas características (atributos, métodos)
Línea 474: Línea 969:
 
  toString()  compareTo() ...
 
  toString()  compareTo() ...
  
−
|}
+
 
 +
 
 +
 
 +
====Enlace estático en tiempo de ejecución====
 +
*Para poder hacer referencia en tiempo de ejecución a un elemento estático de la clase se usa este operador
 +
*Elementos estáticos en php
 +
#Constantes y Propiedades y métodos estáticas
 +
*Usaremos el operador '''''::''''' de resolución de ámbito
 +
*Especificaremos el nombre de la clase del cual queremos acceder a su constante
 +
 
 +
 
 +
#
 +
*Usaremos igualmente el operador de resolución de ámbito '''''::'''''
 +
 
 +
#propiedades  y métodos no estáticos
 +
*Para ellos usaremos el operador '''''->''''', precedido de la seudovariable '''''$this'''''
 +
==static==
 +
==$this==
 +
 
 +
===métodos===
 +
===pseudovariables '''''this'''''===
 +
===operador '''''self''''' y '''''parent'''''===
 +
 
 +
 
 
-->
 
-->
−
==self==
 
−
A ver si chuta esto
 
−
==::==
 
−
*Operador de resolución de ámbito
 
−
*http://php.net/manual/es/language.oop5.paamayim-nekudotayim.php
 
  
−
==visibilidad==
+
 
−
Visibilidad  o alcance de las propiedades no constantes y los métodos de las clases
+
|}

Última revisión de 02:33 1 jul 2016

Road Works.svg Trabajo en proceso, espera cambios frecuentes. Tu ayuda y retroalimentación son bienvenidos.
Ver página de charlas. 		Road Works.svg




DWES TituloTema6.png

Programación orientada a objetos

  • En programación el paradigma imperativo está basado en funciones y datos,
  • El paradigma orientado a objetos está basado en Objetos.
  • 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.



Icon define.gif

Definición

Objeto Cada elemento activo que identificamos dentro de un determinado univeso de discurso



Icon casestudy.gif

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... metodos



  • Puede parecer una forma más complicada de programar, pero es una manera de dividir la naturaleza del problema que estamos estudiando en unidades independinetes que pueden interactúan 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

Elementos en la programación orientada a objetos

  • De lo dicho anteriormente deducimos que tenemos dos elementos:
  1. Los atributos o características de la clase.
  2. Los métodos o comportamiento de la clase .
  • Una clase es la estructura de un tipo concreto de objetos.
  • Los objetos son elementos concretos en mi sistema.
Elementos de la POO
  • La estructura común (datos y comportamiento) de los objetos sirven especificar su composición
  • Esta composición queda descrita y especificada en la clase.
  • Una clase tiene dos elementos 
Atributos ==> Son las características o datos de un objeto
                        Su valor nos da el estado de un objeto en un momento dado
Elementos de la POO 
Comportamiento==> permiten modificar el estado de un objetos
                        Permiten saber como es el estado de un objeto
                        Permiten que un objeto haga cosas en el sistema (comunicación entre objetos) 
                        Son las cosas que el objeto sabe hacer Servicios que ofrece
                        También lo son acciones internas para  facilitar las cosas al objeto

Clase.png

OPP En php

  • PHP no se diseñó como lenguaje orientado a objetos, por lo que muchas de las carácterísticas de este paradigma se ha ido incorporando en las últimas versiones, especialemnte 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. Veremos este concepto más adelante.
Los elementos de una clase en php se identifican como
  1. propiedades: son los atributos o carácterísticas de la clase.
  2. 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
  • propiedades son las variables o constantes definidas dentro de la clase.
  • métodos son las funciones que definirán el comportamiento de la clase.


Icon casestudy.gif

Ejemplo

Vamos a crear una clase llamada fecha

  • Atributos de la clase (dia, mes, year)
  • Metodos (obtener la fecha como una cadena de caracteres



Pilares básicos de la POO

Icon key points.gif

Puntos clave

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 y me 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 
tipo de visibilidad asignada por defecto en caso de no especificar.
private
protected
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 ->
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);
//...
?>
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 
<?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();
 
?>

Propiedades

  • Al igual que en el código estructurado los valores que almaceno en memoria, las propiedades de los objetos pueden ser.
  1. Variables
  2. 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.
Accediendo al valor de una constante
  1. Dentro de la clase: usaremos el operador self junto con el operador de resolución de ámbito  ::
  2. En el programa: identificando la clase, mediante el nombre de la clase, o bien la variable objeto de esa clase 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;
?>



Icon casestudy.gif

Ejemplo

Creamos la clase factura

  • Constantes IVA
  • Atributos Importe Base, fecha, impuestos, Importe bruto, estado (pagada o pendiente)
  • Métodos: imprime


Variables
  • Estas propiedades
  • Las variables siguen la misma regla de construcción que vistas anteriormente.
  • Las propiedades de la clase al igual que los métodos pueden especificárseles una determinada #visibilidad o alcance, siendo el valor por defecto public.
  • También puedes ser #static o estáticas, también conocidas como variables de la clase, si se especifica con la palabra reservada #static.
  • Dado que php es de tipado dinámico, si dentro de un método de la clase quiero acceder a una propiedad de la misma he de indicarlo usando la seudovariable #$this'
  • 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 conviene conocer y que posteriormente estudiaremos
#métodos contructor y destructor
  • son el método __construct(..) y __destruct(..)
  • Su implementación es libre para cada clase,
  • Su invocación es transparente para el programador y se realiza siempre respectivamente al crear el objeto, y cuando este es destruido
  • El nombre es __construct y __destruct respectivamente, si bien, la lista de argumentos que pueden recibir, así como las acciones que pueden realizar es libre de implementar.
  • Estos métodos que se invocan automáticamente cuando ocurre algo, en php se conocen como métodos mágicos.
#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 __
  • Un ejemplo son el __construct(...) y __destruct(...) 
http://php.net/manual/es/language.oop5.magic.php

Instancias: Operador new

  • Una clase describe lo común de unos determinados objetos
  • Las clases en principio no se usan durante la ejecución, salvo si queremos acceder a métodos o ṕropiedades estáticas como veremos un poco más adelante
  • Lo que se usa son 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

Objetos4.png 

class MiCalse{
    //propiedades
    //métodos
}
$objeto = new Miclase();


Icon activity.jpg

Actividad

  • Crea una clase llamada producto con los atributos código, nombre y precio



Accediendo a los atributos de un objeto
seudovariable $this
  • $this es una seudovariable que referenica al objeto del ámbito en el cual está usado
  • Se utiliza dentro de la definición de la propia clase y hará referencia a un objeto concreto en un momento dado de la clase en la que está siendo utilizado
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";
        }
    }
}
 
 
</div>
<div class="slide">
{{Actividad|
=Empleado=
Confeccionar una clase Empleado, definir como atributos su nombre y sueldo.
Definir un método inicializar que lleguen como dato el nombre y sueldo. Plantear un segundo método que imprima el nombre y un mensaje si debe o no pagar impuestos (si el sueldo supera a 3000 paga impuestos)
 
<source lang=php>
<html>
<head>
<title>Pruebas</title>
</head>
<body>
<?php
class Empleado {
  private $nombre;
  private $sueldo;
 
  public function asigna($nom,$sue)
  {
    $this->nombre=$nom;
    $this->sueldo=$sue;
  }
  public function pagaImpuestos()
  {
    echo $this->nombre;
    echo '-';
    if ($this->sueldo>3000)
      echo 'Debe pagar impuestos';
    else
      echo 'No paga impuestos';
    echo '<br>';
  }
}
 
$empleado1=new Empleado();
$empleado1->inicializar('Luis',2500);
$empleado1->pagaImpuestos();
$empleado1=new Empleado();
$empleado1->inicializar('Carla',4300);
$empleado1->pagaImpuestos();
?>
</body>
</html>

Actividades



Icon activity.jpg

Actividad

Confeccionar una clase Menu. Permitir añadir la cantidad de opciones que necesitemos. Mostrar el menú en forma horizontal o vertical (según que método llamemos) 




<html>
<head>
<title>Pruebas</title>
</head>
<body>
<?php
class Menu {
  private $enlaces=array();
  private $titulos=array();
  public function cargarOpcion($en,$tit)
  {
    $this->enlaces[]=$en;
    $this->titulos[]=$tit;
  }
  public function mostrarHorizontal()
  {
    for($f=0;$f<count($this->enlaces);$f++)
    {
      echo '<a href="'.$this->enlaces[$f].'">'.$this->titulos[$f].'</a>';
      echo "-";
    }
  }
  public function mostrarVertical()
  {
    for($f=0;$f<count($this->enlaces);$f++)
    {
      echo '<a href="'.$this->enlaces[$f].'">'.$this->titulos[$f].'</a>';
      echo "<br>";
    }
  }
}
 
$menu1=new Menu();
$menu1->cargarOpcion('http://www.google.com','Google');
$menu1->cargarOpcion('http://www.yahoo.com','Yhahoo');
$menu1->cargarOpcion('http://www.msn.com','MSN');
$menu1->mostrarVertical();
?>
</body>
</html>



Icon activity.jpg

Actividad

Construir una clase llamado racional que podamos inicializar con un string del tipo por ejemplo "8/5" 




<?php
class racional {
    //put your code here
    private $numRacional;
    public function __construct($cadena) {
        $this->numRacional = $cadena;
    }
    public function visualiza(){
        return $this->numRacional;
    }
}
 
$a=new racional("8/5");
$b=new racional("6/4");
echo '<br>valor de $a: '. $a->visualiza();
echo '<br>valor de $b: '. $b->visualiza();
?>


Sobrecarga

Un concepto muy importante es la sobre carga.

  • Este concepto es básico en la programación Orientada a objetos;
  • Sin embargo este aspecto en php no es del todo intuitivo. No existe la sobrecarga como la entendemos en otros lenguajes
  • No obstante tenemos técnicas para poder simular la sobrecarga.
  • Muchas veces es fundamental o al menos cómodo sobrecargar el constructor de la clase.
  • Vamos a ver como podemos implementar la sobrecarga en php
  • Supongamos que en el ejemplo anterior quisiérmos poder instanciar de la siguiente manera los racionales 
$a = new racional ("8/5");/*   8/5  */
$b = new racional (5,4);  /*   5/6  */
$c = new racional (5);    /*   5/1  */
$d = new racional ();     /*   1/1   */
  • Para esta situación tenemos diferentes estrategias. En este tema vamos a analizar 2:
  1. sobrecargar en el constructor
  2. sobrecargar con métodos mágicos
Sobrecargar en el constructor
  • Una sencila es ir viendo de qué tipo son los parámetros
  • Vemos que podemos tener 0, 1 o 2 paŕametros
  • Por lo tanto la función constructora tendrá que tener 3 parámetros inicializados por si no le pasamos valores 
 public function __construct($cadenaOrNum=null, $den = null) {
 ....
}


Icon activity.jpg

Actividad

Vamos a simular la sobre carga de la clase racional 
<?php
/**
 * Description of racional
 *
 * @author manolo
 */
class racional {
    //put your code here
    private $numRacional;
    private $num;
    private $den;
    public function __construct($cadenaOrNum=null, $den = null) {
        if (is_int($cadenaOrNum)){
            if (isset($den))
                $this->racionalNumDen($cadenaOrNum, $den );
            else
                $this->racionalNum($cadenaOrNum );
        }
        else{
            if (isset($cadenaOrNum))
                $this->racionalCadena($cadenaOrNum);
            else
                $this->racionalVacio();
        }
     }
 
     private function racionalNumDen($num, $den){
         $this->numRacional=$num."/".$den;
         $this->num=$num;
         $this->den=$den;
         $this->convierteNum();
     }
     private function racionalNum($num){
         $this->numRacional=$num."/1";
         $this->num=$num;
         $this->den=1;
         $this->convierteNum();
     }
     private function racionalCadena($cadenaOrNum){
         $this->numRacional=$cadenaOrNum;
         $pos = strpos($cadenaOrNum,"/");
 
         $num=substr($cadenaOrNum,0,$pos);
         $den=substr($cadenaOrNum,$pos+1);
         $this->num=$num;
         $this->den=$den;
     }
     private function racionalVacio(){
         $this->numRacional="1/1";
         $this->num=1;
         $this->den=1;
     }
     private function convierteNum(){
         settype($this->num, int);
         settype($this->den, int);
     }
 
 
 
    public function visualiza(){
        return $this->numRacional;
    }
    public function valorRacional(){
        return $this->num/$this->den;
    }
    private function simplifica(){
 
    }
    private function suma(racional $num){
 
    }
 
}
 
$a=new racional("8/5");
$b=new racional("6/4");
echo '<br>racional de $a: '. $a->visualiza();
echo '<br>valor de $a: '. $a->valorRacional();
echo '<br>racional de $b: '. $b->visualiza();
echo '<br>valor de $b: '. $b->valorRacional();
echo"<hr/>";
$a=new racional();
$b=new racional();
echo '<br>racional de $a: '. $a->visualiza();
echo '<br>valor de $a: '. $a->valorRacional();
echo '<br>racional de $b: '. $b->visualiza();
echo '<br>valor de $b: '. $b->valorRacional();
echo"<hr/>";
$a=new racional(8);
$b=new racional(4);
echo '<br>racional de $a: '. $a->visualiza();
echo '<br>valor de $a: '. $a->valorRacional();
echo '<br>racional de $b: '. $b->visualiza();
echo '<br>valor de $b: '. $b->valorRacional();
echo"<hr/>";
$a=new racional(124,6);
$b=new racional(7,123);
echo '<br>racional de $a: '. $a->visualiza();
echo '<br>valor de $a: '. $a->valorRacional();
echo '<br>racional de $b: '. $b->visualiza();
echo '<br>valor de $b: '. $b->valorRacional();
 
?>





  • Código implementado en clase