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

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

1. propiedades: son los atributos o características de la clase.
2. métodos: representan 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
• Los nombres de las clases no son sensibles a los casos (sensitive-case), pero es muy recomendado utilizarlo como si lo fuera.-
• Es muy recomendable guardar las clases en ficheros cuyo nombre sea el propio de la clase, esto permitirá la autocarga de estos ficheros y forma parte de las buenas prácticas de programación

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

	Ejemplo
	Vamos a crear una clase llamada fecha Atributos de la clase (dia, mes, year) Métodos verFecha (obtener la fecha como una cadena de caracteres) En el programa principal <?php require "Fecha.php"; $f1 = new Fecha(10,12,2016); echo "La fecha es ".$f1->verFecha(); // put your code here ?> Y la salida que se produce La fecha es 10/12/2016

• Iremos entendiendo cada parte de esta declaración y uso a lo largo del tema

Pilares básicos de la POO

• Son 4 las características o principios de la programación orientada a objetos

Puntos clave

Encapsulación Abstracción Polimorfismo Herencia

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

Puntos clave

La encapsulación es uno de los pilares de la programación orientada a objetos permite o restringe la visibilidad de sus componentes

Visibilidad

• Implementa el principio de encapsulación.
• Permite especificar desde qué ámbito se tiene acceso a un determinado elemento. Básicamente tenemos tres tipos de ámbitos desde lo que podemos querer acceder.

1. Desde la propia clase
2. Desde otra sección de código (otra clase sin ninguna relación de herencia o en el programa dónde se está usando un objeto de esa clase.
3. Desde otra clase que se ha extendido (dónde hay una relación de herencia

Visibilidad

• Son tres los tipos de visibilidad que podemos especificar:

1. public
2. private
3. protected

public

• Los elementos públicos pueden ser accesibles desde cualquier ámbito dónde se pueda acceder al objeto
• Recordemos que para acceder a un elemento debemos especificar el objeto o clase al que pertenece el elemento al que queremos acceder
• 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(); ... Pero no puedo hacer .... $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 (ni siquiera desde clases que sean una herencia, o clases heredadas).
• En OOP es una tendencia hacer todos los atributos privados y acceder a ellos por los métodos setter and getter.

ejemplo usando get and set method

Realiza un programa que implemente un usuario con usuario y password Se puede crear un objeto sin pasar password, en cuyo caso se asignará el mismo password que usuario El password ha de tener un mínimo de 8 caracteres y al menos un número Si no se crea la password se generará un mensaje de que no se ha podido crear el usuario con dichas credenciales posible solución <?php class Usuario {   <?php   class Usuario {   private $user; private $pass; private $error;   public function __construct(string $user, string $pass = null) { $this->error = null; $this->user = $user; $this->pass = $this->check_pass($pass); if (!is_null($this->error)) { $this->show_error(); } }   private function check_pass($pass) { $pass_valida = true; if (is_null($pass)) $pass = $this->user; if (strlen($pass) < 8) { $pass_valida=false; $this->error = "La password ha de tener al menos 8 caracteres"; } $pass2 = str_replace([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], "", $pass); if ($pass == $pass2) { $pass_valida = false; $this->error = "La password ha de contener algún número"; } return $pass_valida; }   public function show_error() { return $this->error; }   /** * @return string */ public function getUser(): string { return $this->user; }   /** * @param string $user */ public function setUser(string $user): void { $this->user = $user; }   /** * @return mixed */ public function getPass() { return $this->pass; }   /** * @param mixed $pass */ public function setPass($pass): void { if ($this->check_pass($pass)) $this->pass = $pass; }   /** * @return null */ public function getError() { return $this->error; }   /** * @param null $error */ public function setError($error): void { $this->error = $error; }     }

class A{
  private $foo
 
.........
 
   public function compara (A $b){
    //Voy a acceder directamente a un atributo privado del objeto $b
    //Como este objeto es de la clase A, sí que puedo hacerlo
    //Esto ocurre en php
         if $this->foo ==$b->foo
   }
 .....
 
}
 
}

protected

• Este tipo de visibilidad implica que los elementos así especificados solo son accesible por la propia clase y por las clases derivadas, con las que se establezca una relación de herencia.
• 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();
 
?>

Declarando objetos: Operador new

• Permite crear instancias de un objeto en memoria.
• Una clase describe la estructura común de determinados objetos, su composición o podríamos verlo como una plantilla .
• 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
• En un programa crearemos objetos (instancias de la clase).
• Para instanciar objetos de las clases usaremos el operador new
• Una vez instanciando ya tenemos la referencia del objeto y lo podemos utilizar.
• En php los objetos internamente se manejan como direcciones de memoria, por ese motivo, cuando queremos acceder a un elemento del objeto, tendremos que indireccionar su posición a partir de la dirección base del propio objeto, por lo que se utiliza el operador de indireccion ->, como ya venimos haciendo en este tema.
• Hay que ser consciente que en memoria tenemos toda la estructura del la clase por cada objeto (es decir si tengo un método concreto y 5 objetos, tendré en memoria los 5 métodos, uno por cada objeto, y cada método pertenece a su objeto).

$this

• Para poder acceder a los atributos, o métodos de un objeto en una clase usaremos la 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;
• Cuando en un método de una clase se quiere acceder a un atributo de la misma, hay que usar la $this, ya que en caso contrario estaría accediendo a una variable local al método

Observa el siguiente código

<?php   class Persona{ public $nombre; public $apellido;   public function __construct( string $n, string $a){ //No estoy asignando los valores a los atributos //Sino a unas variables locales a este método $nombre = $n; $apellido = $a; } } $p = new Persona ("María", "Ruíz"); //Los atributos no tienen valor echo "<h1>Nombre -$p->nombre-</h1>"; echo "<h1>Apelido -$p->apellido-</h1>"; La forma correcta de escribir el constructor public function __construct( string $n, string $a){ //Ahora sí que asigno los valores a los atributos de la clase $this->nombre = $n; $this->apellido = $a; }

Puntos clave

La lectura de la seudovariable $this sería : cuando exista una instancia de objeto de esta clase, quiero acceder a la propiedad o atributo atributo_x o ejecutar el método metodo_y de ese objeto.

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

• 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 ::

• http://php.net/manual/es/language.oop5.paamayim-nekudotayim.php
• Se utiliza para poder acceder a los elementos estáticos de la clase
• En la parte de la izquierda hay que especificar el dominio o elemento al que pertenece la propiedad o método estático.
• Podremos usar;

1. nombre de clase,
2. nombre del objeto
3. self : si es dentro de la misma clase
4. parent : si el elemento pertenece a la clase de la que heredo
5. 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 { 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 <nowiki>=</nowiki> 21 En total hay 2 objetos de esta clase e IVA <nowiki>=</nowiki> 21 En total hay 3 objetos de esta clase e IVA <nowiki>=</nowiki> 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.

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.
• 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:

• Operador self junto con el operador de resolución de ámbito  ::
• Nombre 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étodos de la clase, si se especifica con la palabra reservada #static.

• 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

<?php
class Propiedades{
   public $propiedad = "rojo";
   public function getPropiedad(){
     echo "\$propiedad ahora es una variable local
     al 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, a diferencia de Java, no podemos tener un método con el mismo nombre que la clase (Versiones anteriores a la 7.4 sí que se podía, pero actualmente genera un error).
• El constructor en php 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 clase si es que existiera.
• El igual que tenemos un método que se ejecuta cuando instanciamos un objeto de la clase, __construct()', 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 clase

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 parámetro <strong>$m</strong>"; }     } $obj1 = new Clase1("Mensaje pasado al constructor "); *La salida de este código Estoy en constructor de Clase1, métdo Clase1, y he recibido el parámetro 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étodo __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étodo __construct, y he recibido el paŕametro Mensaje pasado al constructor Tip: El constructor puede (en la mayoría de los casos debe)recibir parámetros pasados al crear la instancia del objeto con el operador 'new'

• El método constructor es un método que típicamente se suele sobrecargar, es decir, tener código diferente en función de los parámetros que aporte en su invicación. Ver el tema de #Sobrecarga dónde se explica este concepto con un ejemplo

Promoción de propiedades (property promotion)

• La versión 8 de php presenta esta gran utilidad, que permite una declaración muy compacta de constructor y atributos.
• El la delcaración del constructor se realizan las siguientes acciones:

1. Declarar los atributos de la clase,
2. Definición de constructor
3. Asignaciones valores a los atributos .

• Por ejemplo

class Poligono
{
 
    public function __construct(private  float $altura,private float  $base, private int $lados ){}
}
.....
 
$cuadrado = new Poligono(5,5,4);

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"; ?> *La salida de este código 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

{{MRM_Ejemplo|Title=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");
?>

   *La salida de este código

Sobrecarga

Es un concepto muy importante y básico en la programación orientada a objetos. La sobrecarga es una concreción del principio de polimorfismo.

Polimorfismo

Podemos tener varios métodos con el mismo nombre, pero con diferente número de parámetros o con parámetros de distinto tipo. En tiempo de ejecución se ejecutará uno u otro en función de los parámetros reales que pasemos en la invocación del método.

• Sin embargo, este aspecto en PHP no es del todo intuitivo: no existe la sobrecarga como la entendemos en otros lenguajes.
• No obstante, disponemos de técnicas para poder simular la sobrecarga.
• En muchos casos resulta fundamental, especialmente al sobrecargar el constructor de una clase.
• Para simular la sobrecarga en PHP, aprovechamos que una variable que no tenga valor se considera del tipo null.
• Lo veremos con una serie de ejemplos para dejar claro este concepto.

• Tomamos como ejemplo una función:

	Ejemplo
	function verTipoParametros($a = null, $b = null, $c = null){ echo "Primer parámetro: "; var_dump($a); echo "Segundo parámetro: "; var_dump($b); echo "Tercer parámetro: "; var_dump($c); }

• Ahora la invocamos de diferentes maneras y observamos el resultado:

	Invocar sin parámetros reales
	echo "Invocando a <strong>verTipoParametros()</strong><hr />"; verTipoParametros(); A pesar de que tiene tres parámetros, la invocamos sin argumentos. El resultado será que cada parámetro, al ejecutar la función, será de tipo null con valor null (es un tipo válido en PHP).

	Invocar con 1 parámetro real
	echo "Invocando a <strong>verTipoParametros(5)</strong><hr />"; verTipoParametros(5); En este caso invocamos con un solo parámetro de tipo entero.

	Invocar con 2 parámetros reales
	echo "Invocando a <strong>verTipoParametros(5,7)</strong><hr />"; verTipoParametros(5,7); En este caso invocamos con dos parámetros de tipo entero. Los parámetros dentro de la función serán tres: dos con valor entero y el tercero con valor y tipo null.

	Invocar con 3 parámetros reales
	echo "Invocando a <strong>verTipoParametros('pedro',5,9)</strong><hr />"; verTipoParametros('pedro',5,9); En este caso pasamos tres parámetros: el primero de tipo string y los otros dos de tipo entero.

	Invocar con 3 parámetros reales, uno de ellos un array
	echo "Invocando a <strong>verTipoParametros([1,4,'maría'], true, 'sonia')</strong><hr />"; verTipoParametros([1,4,'maría'], true, 'sonia'); Ahora igualmente pasamos tres parámetros, pero uno de ellos es un array.

Sobrecargando el constructor

• Usando esta forma de trabajar, vamos a sobrecargar el constructor de una clase.
• Tomemos como ejemplo una clase Racional. Un número racional es un objeto que tiene numerador y denominador.

• Queremos permitir crear el objeto de distintas formas:

$r1 = new Racional("8/5"); /* 8/5 */
$r2 = new Racional(5,4);   /* 5/4 */
$r3 = new Racional(5);     /* 5/1 */
$r4 = new Racional();      /* 1/1 */

• Necesitamos que el constructor pueda responder a todas las situaciones.
• Aplicando los conceptos vistos, solo tenemos que comprobar de qué tipo son los parámetros.

• Vemos que podemos tener 0, 1 o 2 parámetros.

Por lo tanto, el constructor tendrá dos parámetros opcionales.

public function __construct($num = 1, $den = 1) {
    ...
}

• Especificamos el código de cómo se podría implementar:

class Racional {
 
    private $num;
    private $den;
 
    public function __construct($num = 1, $den = 1) {
        // opciones:
        // new Racional()       => 1/1
        // new Racional(5)      => 5/1
        // new Racional("5/2")  => 5/2
        // new Racional(5,2)    => 5/2
        // Otra situación: no se instancia correctamente
 
        if (is_string($num)) {
            $numero = explode("/", $num);
            $num = $numero[0];
            $den = $numero[1];
        }
        $this->num = $num; 
        $this->den = $den;
    }
 
    /* Método para visualizar el objeto como cadena de caracteres */
    public function __toString() {
        return ($this->num . "/" . $this->den);
    }
 
    // Métodos privados para asignar valores según la forma de invocación
    private function racionalNum($num) {
        $this->num = $num;
        $this->den = 1;
    }
 
    /**
     * @param string $num número racional del tipo "a/b"
     * Hay muchas formas de poder descomponer esa cadena en dos números.
     */
    public function racionalCadena($num) {
        $partes = explode("/", $num);
        $this->num = (int) $partes[0];
        $this->den = (int) $partes[1];
    }
 
    public function racionalVacio() {
        $this->num = 1;
        $this->den = 1;
    }
 
    /* En este caso, si los valores son incorrectos, asigno el racional 1/1 */
    public function racionalNumDen($num, $den) {
        if (is_numeric($num) && is_numeric($den)) {
            $this->num = $num;
            $this->den = $den;
        } else {
            $this->num = 1;
            $this->den = 1;
        }
    }
}

Esta sería una posibilidad, pero podemos crear un código más compacto.

En la siguiente versión inicializamos los parámetros con un valor por defecto (1). Posteriormente, si el primer parámetro es una cadena, se divide en numerador y denominador. Hecho esto, solo queda asignar los valores a los atributos.

public function __construct($num = 1, $den = 1){
    if (is_string($num)){
        $numero = explode("/", $num);
        $num = $numero[0];
        $den = $numero[1];
    }
    $this->num = $num;
    $this->den = $den;
}

• Probamos este constructor con el siguiente código:

$a = new Racional();
$b = new Racional(5);
$c = new Racional(5,6);
$d = new Racional("6/6");
 
echo "Valor del racional \$a = $a <br />";
echo "Valor del racional \$b = $b <br />";
echo "Valor del racional \$c = $c <br />";
echo "Valor del racional \$d = $d <br />";

• Mostrando los siguientes resultados:

Valor del racional $a = 1/1  
Valor del racional $b = 5/1  
Valor del racional $c = 5/6  
Valor del racional $d = 6/6  

Sobrecarga con __call(...)

• Otra forma de lograr un comportamiento similar es usando el método mágico __call($funcion, $parametros).

• Queremos usar un método llamado asigna() que nos permita cambiar el valor de un racional.
• La forma de aportar el nuevo valor será la misma que la de construir el objeto.

$r1 = new Racional();      // construye el objeto 1/1
$r1->asigna("6/4");        // ahora el objeto vale 6/4
$r1->asigna();             // ahora el objeto vale 1/1
$r1->asigna(8);            // ahora el objeto vale 8/1
$r1->asigna(124, 6);       // ahora el objeto vale 124/6

• La forma de proceder será usando los métodos privados creados anteriormente.
• El siguiente código implementa la solución:

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;
        }
    }
}

Métodos static vs no static

• En PHP, la idea de static es igual que en cualquier lenguaje de programación orientado a objetos.
• Cuando un elemento (atributo o método) es estático, ese elemento es compartido por todos los objetos de la clase y persiste en memoria con su contenido mientras exista al menos un objeto de esa clase.
• Como no pertenece a cada objeto individual, sino a la clase en general, también se les llama atributos o métodos de clase.
• Para acceder a un elemento estático, necesitamos nombrar la clase (no el objeto). En PHP podemos hacerlo usando el operador self o el propio nombre de la clase junto con el operador de resolución de ámbito ::.

Usar constantes y elementos estáticos

Como ejemplo, vamos a implementar una clase Factura con los siguientes requisitos La factura tendrá una constante llamada IVA. Tendremos un atributo estático que especificará el número de facturas creadas. Los atributos de cada factura serán importe_bruto y fecha. Tendrá un método generarFactura() que mostrará: Factura de XXXX (el nombre se recibirá como argumento). Fecha (atributo). Importe base (atributo). IVA aplicado (constante de la clase). Total bruto (importe base más el IVA). En el archivo index.php crearemos 5 facturas, visualizaremos el número de facturas, eliminaremos dos de ellas y volveremos a visualizar el número de facturas. Finalmente imprimiremos las dos facturas restantes. Posible solución <?php // Factura.php class Factura { // Constante IVA const IVA = 0.21;   // Atributo estático para contar el número de facturas private static $numeroFacturas = 0;   // Atributos de instancia private $importe_bruto; private $fecha;   // Constructor public function __construct($importe_bruto, $fecha) { $this->importe_bruto = $importe_bruto; $this->fecha = $fecha; self::$numeroFacturas++; // Incrementa el contador al crear una nueva factura }   // Destructor public function __destruct() { self::$numeroFacturas--; // Decrementa el contador al eliminar una factura }   // Método para generar una factura public function generarFactura($nombreCliente) { $ivaAplicado = $this->importe_bruto * self::IVA; $totalBruto = $this->importe_bruto + $ivaAplicado;   echo "Factura de $nombreCliente<br/>"; echo "Fecha: {$this->fecha}<br/>"; echo "Importe base: {$this->importe_bruto} €<br/>"; echo "IVA aplicado (" . (self::IVA * 100) . "%): {$ivaAplicado} €<br/>"; echo "Total bruto: {$totalBruto} €<br/>"; echo "-----------------------------<br/>"; }   // Método estático para obtener el número de facturas actuales public static function obtenerNumeroFacturas() { return self::$numeroFacturas; } }   // index.php   // Crear 5 facturas $factura1 = new Factura(100, '2024-11-18'); $factura2 = new Factura(200, '2024-11-18'); $factura3 = new Factura(150, '2024-11-18'); $factura4 = new Factura(300, '2024-11-18'); $factura5 = new Factura(250, '2024-11-18');   // Visualizar el número de facturas echo "Número de facturas actuales: " . Factura::obtenerNumeroFacturas() . "<br/><br/>";   // Eliminar dos facturas unset($factura4); unset($factura5);   // Visualizar el número de facturas tras eliminar dos echo "Número de facturas tras eliminar: " . Factura::obtenerNumeroFacturas() . "<br/><br/>";   // Imprimir las facturas restantes $factura1->generarFactura("Cliente 1"); $factura2->generarFactura("Cliente 2"); ?>

• Es muy común tener un atributo static que cuente cuántos objetos existen de una clase.

• En la siguiente imagen se ilustra cómo al crear varios objetos, cada uno se instancia por separado en memoria:

• Cuando añadimos un elemento estático, solo habrá una copia en memoria, compartida por todos los objetos de la clase:

• Vemos el código y cómo se accede al elemento estático:

<?php
class Racional {
    static public $cuenta_racionales = 0;
 
    private $num; // Numerador
    private $den; // Denominador
 
    public function __construct($num, $den) {
        self::$cuenta_racionales++;
        $this->num = $num;
        $this->den = $den;
    }
}
?>

• El uso:

<?php
require_once "Racional.php";
 
$r1 = new Racional(5,4);
$r2 = new Racional(5,4);
$r3 = new Racional(5,4);
 
echo "<h1>Ahora tenemos " . Racional::$cuenta_racionales . " objetos Racional</h1>";
 
$r4 = new Racional(5,4);
$r5 = new Racional(5,4);
 
echo "<h1>Ahora tenemos " . Racional::$cuenta_racionales . " objetos Racional</h1>";
 
$r6 = new Racional(5,4);
$r7 = new Racional(5,4);
 
// Observa (y esto es propio de PHP) que puedo acceder a un elemento estático
// tanto a través del nombre de la clase como desde un objeto
echo "<h2>Podemos acceder con los objetos:</h2>";
echo "<h3>Según r1: " . $r1::$cuenta_racionales . "</h3>";
echo "<h3>Según r2: " . $r2::$cuenta_racionales . "</h3>";
echo "<h3>Según r3: " . $r3::$cuenta_racionales . "</h3>";
echo "<h3>Según la clase: " . Racional::$cuenta_racionales . "</h3>";
?>

• La salida:

---

• Vamos a implementar las operaciones con números racionales.

Antes, recordemos las operaciones básicas:

Sumar

Restar

Multiplicar

Dividir

• Si la operación la implementamos como un método no estático, lo que estaremos haciendo es sumar al objeto actual otro objeto Racional que pasamos como argumento.

Podemos modificar el objeto actual o devolver un nuevo objeto (lo más correcto).

/**
 * Suma al racional actual el racional recibido como parámetro.
 * @param Racional $n1
 * @return Racional
 */
public function sumar(Racional $n1) {
    $den = $this->den * $n1->getDen();
    $num = $this->num * $n1->getDen() + $this->den * $n1->getNum();
    return new Racional($num, $den);
}

• Para usarlo:

$r1 = new Racional(7,6);
$r2 = new Racional(9,4);
 
$r3 = $r1->sumar($r2);
echo "$r1 + $r2 = $r3";

• La salida:

---

• Si la operación la realizamos como un método estático, estaremos sumando dos objetos Racional y devolviendo un nuevo objeto como resultado:

static public function sum_static(Racional $r1, Racional $r2){
    $n = $r1->getNum() * $r2->getDen() + $r1->getDen() * $r2->getNum();
    $d = $r1->getDen() * $r2->getDen();
    return new Racional($n, $d);
}

• Para usarlo:

$r1 = new Racional(7,6);
$r2 = new Racional(9,4);
 
$r3 = Racional::sum_static($r1, $r2);
echo "$r1 + $r2 = $r3";

• La salida:

Herencia

• La herencia es un mecanismo de programación que permite crear una jerarquía en los componentes software, que se van especializando.
• Es un principio de abstracción mediante el cual podemos crear una jerarquía de clases, con una raíz que contiene los elementos comunes y nodos que representan clases especializadas.
• La idea es definir una clase con ciertas características comunes (atributos, métodos). Posteriormente, crearemos otras clases a partir de la ya existente, heredando implícitamente los atributos y métodos como parte de su estructura o composición.

• Es una característica muy natural. Por ejemplo:

 - Personas → (Médicos, Bailarines)  
 - Vehículos → (Terrestres → Coche, Moto) / (Acuáticos → Barco, Lancha)  

• La herencia es una forma de obtener características comunes por separado y luego especializarlas, evitando redundancias.
• Facilita la reutilización y la adaptación del código.

La herencia implica declarar jerarquías de clases

• En la raíz de la jerarquía establecemos la parte o estructura común a todas las clases, y posteriormente vamos especializando las diferencias de cada una.

Puntos clave

Todos los atributos y métodos de una clase superior (supertipo) que sean públicos o protegidos son heredados por todas las clases derivadas (subtipos).

• Para establecer una jerarquía, usamos la palabra reservada extends en las clases que heredan.
• Vamos a verlo con un ejemplo:

• Primero establecemos la clase Persona:

<?php
class Persona {
    protected $nombre;
    protected $direccion;
    protected $edad;
    protected $frase;
 
    public function __construct(string $n, string $d, int $e){
        $this->nombre = $n;
        $this->direccion = $d;
        $this->edad = $e;
    }
 
    public function establecer_frase(string $frase){
        $this->frase = $frase;
    }
 
    public function hablar(){
        echo $this->frase;
    }
}
?>

• Ahora establecemos la clase que hereda de Persona:

Principios del uso de la herencia

Todos los atributos y métodos públicos y protegidos del supertipo Persona son también de Sanitario. En un momento dado, podemos invocar métodos del supertipo usando el operador parent junto con el operador de resolución de ámbito ::.

<?php
class Sanitario extends Persona {
    protected $centroSalud;
    protected $yearTitulacion;
 
    public function __construct(string $n, string $d, int $e, string $centro, int $year) {
        parent::__construct($n, $d, $e);
        $this->centroSalud = $centro;
        $this->yearTitulacion = $year;
    }
 
    public function mostrarInfo(){
        echo "$this->nombre trabaja en $this->centroSalud y obtuvo su título en $this->yearTitulacion.";
    }
}
?>

---

• Vemos dos ejemplos para explicar de forma práctica este concepto.

Herencia: gestión de personal en un ambulatorio

Se pide gestionar un ambulatorio. Para ello haremos solo el diagrama de clases y su implementación a nivel básico (sin entrar en detalles). Tras realizar el análisis, se determina que se pretende gestionar los datos de los empleados y anotar las acciones básicas que realizan. Encontramos los siguientes elementos, que especificamos como clases Conserjes Enfermeras Médicas Las propiedades (atributos) y métodos de cada clase se representan en los siguientes diagramas: Clase Conserje Clase Enfermera Clase Médica Claramente vemos que todos ellos comparten varios elementos comunes. Esto nos permite crear una clase genérica, por ejemplo personalAmbulatorio. Posteriormente crearemos especializaciones de esta clase con los elementos particulares. El diagrama podría quedar así: Ver la aplicación ejecutándose: http://manuel.infenlaces.com/dwes/ejercicios/T6_Ambulatorio/ Posible index de uso <?php spl_autoload_register(function ($nombre_clase) { include $nombre_clase . '.php'; });   $medico1 = new Medica("María", "Martínez", "Casa de María", 29, "Cardiología"); $medico2 = new Medica("Luis", "Pérez", "Casa de Luis", 38, "Pediatría"); $medico3 = new Medica("Nieves", "Ruiz", "Casa de Nieves", 44, "Dermatología"); $conserje = new Conserje("Soledad", "Viruela", "Casa de Soledad", 58, "Mostrador Entrada"); $enfermera1 = new Enfermera("Javier", "Moreno", "Casa de Javier", "General", 1990); $enfermera2 = new Enfermera("Luis", "Pérez", "Casa de Javier", "General", 1990);   $conserje->avisoEnfermera($enfermera1, "Realizar cura en brazo del Sr. Martínez NSS 50/2155441/35"); $enfermera1->avisoMedico($medico3, "Paciente con tos y fiebre");   $enfermera2->avisoMedico($medico2, "Paciente con fiebre y vómitos"); $enfermera2->avisoMedico($medico3, "Paciente con pie torcido; posible fractura");   $conserje->avisoMedico($medico1, "Visitar en casa por fiebre alta", "Visita"); $conserje->avisoMedico($medico2, "Persona mayor con poca movilidad", "Visita"); $conserje->avisoMedico($medico3, "Niño pequeño con fiebre", "Consulta"); ?> <html> <head> <meta charset="UTF-8"> <title>Gestión Ambulatorio</title> <link rel="stylesheet" href="./stilo.css" type="text/css"/> </head> <body> <?php echo $medico3; echo $medico1; echo $medico2; ?> </body> </html>

Clases Abstractas

• Cuando realizamos jerarquías, muchas veces encontramos métodos comunes a varias clases.

Esto implicaría que ese método debería pertenecer a una superclase (o clase padre), de la que luego se heredará.

• Pero puede ocurrir que, aunque el concepto del método sea común a todas las clases, la forma de implementarlo sea diferente en cada una.

	Clase abstracta
	Ejemplo ilustrativo: Archivo:ClaseAbstracta.png

• En este caso, la forma correcta de proceder es especificar el método en la clase superior y dejar su implementación a las clases derivadas.
• El método especificado en la clase superior será un método sin código, conocido como método abstracto, y la clase donde se define pasa a ser una clase abstracta.

Clase abstracta

Es aquella clase que tiene uno o más métodos abstractos.

Método abstracto

Es un método que no tiene código asociado. Su implementación se realizará en las clases derivadas.

Puntos clave

Nunca podremos instanciar un objeto de una clase abstracta. Esto es lógico, ya que ese objeto no tendría instrucciones para ejecutar sus métodos abstractos.

• Vamos a plantear un ejemplo práctico:

	App de Geometría
	{{{1}}}