|
|
| Línea 1: |
Línea 1: |
| | {{TEP}} | | {{TEP}} |
| | {{:Usuario:ManuelRomero/php/opp/nav}} | | {{:Usuario:ManuelRomero/php/opp/nav}} |
| − |
| |
| − | <!--__NOEDITSECTION__-->
| |
| − | __NOTOC__
| |
| − | {|cellpadding="5" cellspacing="6" style="width:100%;background:#DFFFFF; border-style:solid; border-width:2px; border-color:#0066FF;"
| |
| − | | width="100%" valign="top" style="padding: 0; margin:0px;" |
| |
| − | {|cellpadding="5" cellspacing="6" style="width:100%;background:#DFFFFF; border-style:solid; border-width:1px; border-color:#0066FF;"
| |
| − | | width="100%" valign="top" style="padding: 0; margin:0px;" |
| |
| − | <span style="background:#FFFF99">
| |
| − | </span>
| |
| − | [[Imagen:DWES_TituloTema6.png|center]]
| |
| − | |}
| |
| − | ===Repaso básico de la 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 sitema 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.
| |
| − | {{Definicion| '''Objeto''' Cada '''elemento activo''' que identificamos dentro de un determinado univeso de discurso}}
| |
| − | {{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'''''
| |
| − | }}
| |
| − | Una clase es la estructura de un tipo concreto de objetos.
| |
| − | Los objetos son elementos concretos en mi sistema.
| |
| − | 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
| |
| − | '''''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
| |
| − |
| |
| − | [[Archivo: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
| |
| − | #propiedades: son los atributos o carácterísticas de la clase.
| |
| − | #métodos: representas el comportamiento de la misma.
| |
| − | ;Definir una clase en php
| |
| − | <source lang=php>
| |
| − | class NombreClase{
| |
| − | //propiedades
| |
| − | //métodos
| |
| − | }
| |
| − | </source>
| |
| − | *'''''NombreClase''''' es un identificador válido con la siguiente expresión regular
| |
| − | ^[a-zA-Z_][a-zA-Z0-9_]*$
| |
| − | *'''''propiedades''''' son las variables o constantes definidas dentro de la clase.
| |
| − | *'''''métodos''''' son las funciones que definirán el comportamiento de la clase.
| |
| − |
| |
| − | ===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.
| |
| − | *Para acceder al valor de una constante
| |
| − | #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.
| |
| − | <source lang=php>
| |
| − | <?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;
| |
| − | ?>
| |
| − | </source>
| |
| − | ;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 epecifica 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
| |
| − | <source lang=php>
| |
| − | <?php
| |
| − | class Propiedades{
| |
| − | public $propiedad = "rojo";
| |
| − | function getPropiedad(){
| |
| − | 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>";
| |
| − | 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/>";
| |
| − | }
| |
| − | }
| |
| − |
| |
| − | $a = new Propiedades();
| |
| − | $a->getPropiedad();
| |
| − | ?></source>
| |
| − |
| |
| − |
| |
| − |
| |
| − |
| |
| − | Estáticas
| |
| − | No estaticas
| |
| − | Privadas
| |
| − | Púbicas
| |
| − | Protegidas
| |
| − | ====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'''''===
| |
| − | *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
| |
| − | [[Archivo:Objetos4.png]]
| |
| − | <source lang=php>
| |
| − | class MiCalse{
| |
| − | //propiedades
| |
| − | //métodos
| |
| − | }
| |
| − | $objeto = new Miclase();
| |
| − | </source>
| |
| − | {{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
| |
| − | <source lang=php>
| |
| − | <?php
| |
| − | class MyClase
| |
| − | {
| |
| − | function ser_estar()
| |
| − | {
| |
| − | if (isset($this)) {
| |
| − | echo '$this Ahora soy por que estoy';
| |
| − | } else {
| |
| − | echo "\$this ni es ni está.\n";
| |
| − | }
| |
| − | }
| |
| − | }
| |
| − | </source>
| |
| − | *Para usar el código anterior
| |
| − | <source lang=php>
| |
| − |
| |
| − | $a = new MyClase();
| |
| − | $a->ser_estar();
| |
| − |
| |
| − | // Accedo directamente al método de la clase
| |
| − | MyClase::ser_estar();
| |
| − | </source>
| |
| − | *Si desde la propia clase quiero acceder a métodos o atributos estáticos, se usa el operador '''''self'''''
| |
| − | <source lang=php>
| |
| − | class Producto {
| |
| − | private static $num_productos = 0;
| |
| − | private $codigo;
| |
| − | //.....
| |
| − | public funtion ventaProducto($cantidad){
| |
| − | //Este método podría realizar hacer varias cosas , y luego quiero decrementar elemento
| |
| − | $this->decrementa($cantidad);
| |
| − | }
| |
| − | public function incrementa ($cantidad) {
| |
| − | self::$num_productos-=$cantidad;
| |
| − | }
| |
| − | //....
| |
| − | </source>
| |
| − |
| |
| − | *Observar la función get_class(), me retorna el nombre del objeto actual si no se le pasa parámetro
| |
| − | http://php.net/manual/es/function.get-class.php
| |
| − | *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>
| |
| − | class Producto {
| |
| − | private static $num_productos = 0;
| |
| − | private $codigo;
| |
| − |
| |
| − | public function __construct() {
| |
| − | self::$num_productos++;
| |
| − | }
| |
| − | …
| |
| − | }
| |
| − |
| |
| − | *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.
| |
| − | <source lang=php>
| |
| − | class Producto {
| |
| − | private static $num_productos = 0;
| |
| − | private $codigo;
| |
| − |
| |
| − | public function __construct($codigo) {
| |
| − | $this->$codigo = $codigo;
| |
| − | self::$num_productos++;
| |
| − | }
| |
| − | }
| |
| − | $p = new Producto('GALAXYS');
| |
| − | </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.
| |
| − | {{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>
| |
| − | <?php
| |
| − | require_once('Producto.php');
| |
| − |
| |
| − | class DB {
| |
| − | public public __contruct(.....){
| |
| − | //Este método conecta por defecto con localhost, root root y dwes
| |
| − | }
| |
| − | public function ejecutaConsulta($sql) {
| |
| − | //realiza una consulta
| |
| − |
| |
| − | }
| |
| − |
| |
| − |
| |
| − | //Obitene todos los productos de la tabla productos y los reotorna en una array
| |
| − | public function obtieneProductos() {
| |
| − |
| |
| − | }
| |
| − |
| |
| − |
| |
| − | //Obtiene un producto determinado
| |
| − | public function obtieneProducto($codigo) {
| |
| − |
| |
| − | }
| |
| − |
| |
| − | //Verifica un cliente para la clase en general
| |
| − | public static function verificaUsuario($nombre, $contrasena) {
| |
| − |
| |
| − | }
| |
| − | //Verifica un cliente para la clase en general
| |
| − | public static function insertaUsuario($nombre, $contrasena) {
| |
| − |
| |
| − |
| |
| − | }
| |
| − |
| |
| − | ?>
| |
| − | </source>
| |
| − |
| |
| − | <!--
| |
| − | <source lang=php>
| |
| − | <?php
| |
| − | require_once('Producto.php');
| |
| − |
| |
| − | class DB {
| |
| − | protected static function ejecutaConsulta($sql) {
| |
| − | $opc = array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8");
| |
| − | $dsn = "mysql:host=localhost;dbname=dwes";
| |
| − | $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;";
| |
| − | $resultado = self::ejecutaConsulta ($sql);
| |
| − | $productos = array();
| |
| − |
| |
| − | if($resultado) {
| |
| − | // Añadimos un elemento por cada producto obtenido
| |
| − | $row = $resultado->fetch();
| |
| − | while ($row != null) {
| |
| − | $productos[] = new Producto($row);
| |
| − | $row = $resultado->fetch();
| |
| − | }
| |
| − | }
| |
| − |
| |
| − | 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)) {
| |
| − | $row = $resultado->fetch();
| |
| − | $producto = new Producto($row);
| |
| − | }
| |
| − |
| |
| − | return $producto;
| |
| − | }
| |
| − |
| |
| − | 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;
| |
| − | }
| |
| − |
| |
| − | }
| |
| − |
| |
| − | ?>
| |
| − | </source>
| |
| − | -->
| |
| − | }}
| |
| − |
| |
| − | <!--
| |
| − | ===Carácterísticas de la programación orientada a objetos===
| |
| − | *La programación orientada a objetos está basada en cuatro pilares fundamentales
| |
| − | *Estos pilares dan pontecia a este paradigma de la programación
| |
| − | *Ŝ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.
| |
| − | ;Polimorfismo:
| |
| − | :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
| |
| − | ;Herencia:
| |
| − | 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
| |
| − | ;Encapsulacion y Abstracción.
| |
| − | 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.
| |
| − | ==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}}
| |
| − |
| |
| − |
| |
| − |
| |
| − | ==Constructor==
| |
| − | *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=
| |
| − | *La herencia es un mecanismo por el cual puedo definir una clase con ciertas características (atributos, métodos)
| |
| − | *Posteriormente puedo definir otra clase a partir de la ya existente incorporándo implícitamente las características de la primera
| |
| − | *Es una característica muy natural (p.e Personas (médicos y bailarines) vehículos (Terrestres (coche, moto) Acuáticos (barco, lancha))
| |
| − | [[Archivo:Herencia.png]]
| |
| − | *Es una forma de objtener características comunes por separado y luego especializar evitando redundancias
| |
| − | Medi
| |
| − | *Facilita la reusabilidad y adaptación
| |
| − | Puedo heredar un método y añadir cosas (MRM Falta ejemplo)
| |
| − | En java todas las clases heredan de la clase Object (java.lang.Object)
| |
| − | Esta clase tiene una serio de métodos que por lo tanto podrán utilizar cualquier clase que cree o que exista en java
| |
| − | toString() compareTo() ...
| |
| − |
| |
| − | |}
| |
| − | -->
| |
| − | ==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
| |
