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

Última revisión de 07:32 3 ene 2020

Conceptos básicos de OOP

OOP Vs Programación estructurada

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.

Definición

Objeto Cada elemento activo que identificamos dentro de un determinado universo de discurso.

Serán nuestros componentes software para ensamblar nuestros programas

Ejemplo

En un banco hay cuentas bancarias (objeto): Las cuentas bancarias se identifican con un número y un titular (nombre, apellido y dni) atributos; Las cuentas se pueden dar de alta, de baja, hacer extracciones e ingresos y transferencias... métodos

Ejemplo

En la gestión de una empresa, a nivel de información tenemos

Empleados
Nóminas
Base de datos
Proveedores
Facturas
Pedidos

	Compartiva con la aplicación de master mind

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

Los atributos o características de la clase.
Los métodos o comportamiento de la clase .

Para crear objetos, previamente hay que definir su estructura.
La definición de la estructura (atributos y métodos ) de componentes software se llama clase

Clase

La descripción y especificación de componentes software para su posterior uso en los programas

Una clase es la estructura de un tipo concreto de objetos.
Los objetos son elementos concretos en mi sistema. Instancias de la clase en memoria para ser usadas por un programa

Elementos de la POO

Atributo

Son las características o datos de un objeto.
Sus valores nos da el estado de un objeto en un momento dado.
Normalmente al instanciar un objeto en memoria lo primero que hacemos es dar valores a sus atributos
Es recomendado que los atributos estén encapsulados solo al objeto (privados)

Elementos de la POO

Métodos

Especifican el comportamiento de los objetos.
Permiten modificar y conocer el estado de un objetos (métodos getter and setter).
Permiten que un objeto haga cosas en el sistema (comunicación entre objetos) .
Los métodos son las acciones que el objeto sabe hacer, servicios que ofrece
También son las acciones internas para facilitar las acciones al objeto

OPP En php

PHP no se diseñó como lenguaje orientado a objetos, por lo que muchas de las características de este paradigma se han ido incorporando en las últimas versiones, especialmente a partir de la versión 5.3.
PHP Almacena el valor de un objeto como una referencia (dirección de memoria), no guarda el valor.
Esto implica que si queremos pasar un objeto a través de la red, debemos serializarlo, para que viaje también el valor del mismo y no solo la dirección de memoria que en destino carecería de sentido. Veremos este concepto más adelante.

En php las clases tienen métodos y propiedades

propiedades: son los atributos o características de la clase.
métodos: representas el comportamiento de la misma.

Definir una clase en php

class NombreClase{
//propiedades
//métodos
}

NombreClase es un identificador válido con la siguiente expresión regular

^[a-zA-Z_][a-zA-Z0-9_]*$

El nombre de las clases se recomienda que empiece por mayúsculas
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.

Desde la propia clase
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.
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:

public
private
protected

Tip: public tipo de visibilidad asignada por defecto a los métodos, en caso de no especificarla.

En el caso de los atributos hay que declararlo de forma explícita.
Las funciones podemos no declararlo tomando el valor por defecto public
Por herencia podemos usar la palabra reservada var para declarar los atributos en cuyo caso son public, pero su uso está depreciado

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

Tip: A un elemento private de una clase, tampoco podrá acceder desde clases que deriven de ésta, pero en php, dentro de una clase, se puede acceder a los elementos privados de otro objeto de la misma clase.

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

nombre de clase,
nombre del objeto
self : si es dentro de la misma clase
parent : si el elemento pertenece a la clase de la que heredo
static Al igual que self se puede usar la palabra reservada static, para acceder a un elemento estático de la clase.

Resolución de ámbito

El siguiente código aclara de forma completa estas posibilidades:

class Clase1 {
  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.

Variables
Constantes

Constantes

Para definir constantes se usa la palabra reservada const. Como ya sabemos este valor no puede ser modificado durante la ejecución.
El identificador de las constantes no empieza por $.
A una constante hay que asignarle un valor no pudiendo asignar expresiones.
Todos los objetos de la misma clase comparte el valor de la constante. Por lo que se tomará como un valor estático.
Antes de la versión 7.1, incluyendo la 7.0, las constantes siempre eran públicas
A partir de la versión 7.1 se puede especificar la visibilidad (public, protected o private)

Accediendo al valor de una constante

1.- Dentro de la clase:

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.

Tip: Es importante recordar que para acceder dentro de la clase a los métodos o propiedades de ella, hay que usar la seudovariable #$this'

Esto es debido a que php es de tipado dinámico, si no lo hiciéramos estaríamos accediendo a una variable local al método

Tip: Recordar que en este caso no podremos el $ delante del nombre de la propiedad.

<?php
class Propiedades{
   public $propiedad = "rojo";
   public function getPropiedad(){
     echo "\$propiedad ahora es una variable local
     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 case 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 case

Usando constructores

class Clase1 {
    //put your code here
 
    public function Clase1($m){
        echo "Estoy en constructor de Clase1, método Clase1,
           y he recibido el paŕametro <strong>$m</strong>";
    }
 
 
}
$obj1 = new Clase1("Mensaje pasado al constructor ");

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

Declarar los atributos de la clase,
Definición de constructor
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

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 mimos nombre, pero diferente número de parámetros o con parámetros de diferente tipo
El 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 tenemos técnicas para poder simular la sobrecarga.
Muchas veces es fundamental. Especialmente importante a la hora de sobrecargar el constructor de la clase.
Para simular la sobrecarga en php, jugamos con el concepto de que una variable que no tenga valor se considera de tipo null.
Lo vemos 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);
}

</nowiki>

Ahora la invocamos de diferente manera y vemos 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 parámetros
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 esta caso invocamos con un solo parámetro de tipo entero

Podemos ver el resultado

Invocar con 2 parámetros reales

  ... 
echo "Invocando a <strong>verTipoParametros (5,7)</strong><hr />";
verTipoParametros (5,7);
  ...

En esta caso invocamos con dos parámetros de tipo entero
Al igual que en caso anterior los parámetros en la función serían 3, dos de ellos con valor de tipo entero, y el tercero con valor y tipo null
Podemos ver el resultado

Invocar con 3 parámetros reales

  ... 
echo "Invocando a <strong>
      verTipoParametros ('pedro',5,9)
      </strong><hr />";
 
verTipoParametros ('pedro',5,9);
  ...

Ahora pasamos tres parámetros, como vemos el primero de tipo string y los otros dos enteros
Podemos ver el resultado

Invocar con 3 parámetro 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
Podemos ver el resultado

Sobrecargando el constructor

Usando esta forma de trabajar vamos a sobre cargar el constructor de una clase
Tomamos una clase de tipo Racional. Un número Racional es un objeto que tendrá numerador y denominador

Ahora a la hora de construir el objeto planteamos la posibilidad de poder instanciar de la siguiente manera:

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

Aquí vemos claramente que necesitamos sobrecargar el constructor para que pueda responder a todas las situaciones
Aplicando los conceptos vistos antes, lo único que tenemos que hacer en el constructor es ir viendo de qué tipo' son los parámetros.

Tip: Recordar que null también es un tipo

Vemos que podemos tener 0, 1 o 2 parámetros
Por lo tanto la función constructora tendrá que tener 2 parámetros

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

Especificamos el código de cómo se podría hacer

class Racional {
 
    private $num;
    private $den;
 
    public function __construct($num=1, $den=1) {
        //opciones new Racional () =>1/1
        //opciones new Racional (5) =>5/1
        //opciones new Racional ("5/2") =>5/2
        ////opciones new Racional (5,2) =>5/2
        //Otra sitiación no se instancia
        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);
    }
 
    //A continuación los métodos privados para asignar valores
    private function racionalNum($num) {
        $this->num = $num;
        $this->den = 1;
    }
    /**
     * 
     * @param string $num numero racional del tipo "a/b"
     * hay muchas forma de poder descomponer ese array en dos números
     */
    public function racionalCadena($num) {
        $this->num = (int) $num;
        $this->den = substr($num, strpos($num, "/") + 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 un posibilidad, pero debemos de intentar crear un código más compacto y realizar una estratelgia más compacta. El ejemplo anterior lo podríamos compactar de la siguiente manera.

En ella vamos a inicializar los parámetros con un valor que quiero que tengan si no se aporta valor 1 Posteriormente en el código establezco la situación en el caso de que el primer parámetro sea string y asigno los valores a numerador y denominador. Hecho esto, ya hemos considerado todas las opciones, ahora ya solo queda inicializar los atributos con estos valores.

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 poder hacer lo mismo es usando el método mágico __call($funcion, $parametros).

Tip: El método mágico __call(..) es ejecutado cuando invocamos a un método que no existe en la clase

Ahora queremos usar un método llamado asigna que nos permita cambiar el valor de un racional. La forma de aportar el nuevo valor, queremos que sea la misma que la forma 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.
Cuando un elementos (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 haya un objeto de esa clase.
Como no es un elemento de cada objeto, sino de todos los objetos de una clase, también se le suelen llamar atributos o métodos de la clase.
Como no es de la clase para acceder a él necesitamos nombrar la clase. En php se puede hacer suando el operador self o incluso el propio nombre de la clase

Usar constantes y elementos estáticos

Como ejemplo vamos a implementar una Factura y utilizarlas con los siguientes requisitos

La factura tendrá una constante llamada IVA
Tendremos un atributo estáticos que especificará el número de facturas que tengo
Los atributos de factura serán importe_bruto y fecha
Tendrá un método generar factura que nos visualizará una factura con los siguientes datos:

Factura de XXXX (El nombre lo recibirá como argumento)
Fecha (La fecha de la factura que es un atributo)
Importe (El importe base que es un atrubuto)
IVA aplicado (El valor de la constante iva)
Total bruto (El importe base más el iva)

En el index crearemos 5 facturas, visualizaremos el número de facturas, elimniaremos dos de ellas y visualizaremos el número de facturas e imprimieremos las 2 facturas que nos queden

Posible solucion

<?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 la factura
    private $importe_bruto;
    private $fecha;
 
    // Constructor
    public function __construct($importe_bruto, $fecha)
    {
        $this->importe_bruto = $importe_bruto;
        $this->fecha = $fecha;
        self::$numeroFacturas++; // Incrementa el número de facturas al crear una nueva instancia
    }
 
    // Destructor
    public function __destruct()
    {
        self::$numeroFacturas--; // Decrementa el número de facturas al eliminar una instancia
    }
 
    // 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\n";
        echo "Fecha: {$this->fecha}\n";
        echo "Importe base: {$this->importe_bruto} €\n";
        echo "IVA aplicado (" . (self::IVA * 100) . "%): {$ivaAplicado} €\n";
        echo "Total bruto: {$totalBruto} €\n";
        echo "-----------------------------\n";
    }
 
    // Método estático para obtener el número de facturas actuales
    public static function obtenerNumeroFacturas()
    {
        return self::$numeroFacturas;
    }
}
 
 
//index.php
// Código en el índice
 
// 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() . "\n\n";
 
// 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() . "\n\n";
 
// Imprimir las facturas restantes
$factura1->generarFactura("Cliente 1");
$factura2->generarFactura("Cliente 2");

Es un ejemplo típico tener un atributo static que cuente cuantos objetos hay de una clase.

Miramos la siguiente imagen que trata de ilustrar como al crear objetos se instancian en memoria

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

Vemos el código y como se accede al elemento

<?php
class Racional {
 
    static public $cuenta_racionales=0;
 
    //atributos
    private $num; //el numerador
    private $den; //el denominador
    //......
    public function __construct($num, $den) {
        self::$cuenta_racionales++;
    .......

El uso

<?php
 
/* 
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
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 racionales</h1>";
    $r4 = new Racional(5,4);
    $r5 = new Racional(5,4);
    echo "<h1>Ahora tenemos" .Racional::$cuenta_racionales."</h1>";
    $r6 = new Racional(5,4);
    $r7 = new Racional(5,4);
 
    //Observa (y esto es de php ) que puedo acceder a un elemento estático
    //A traves del nombre del objeto
    echo "<h1>Ahora tenemos" .Racional::$cuenta_racionales."</h1>";
    echo "<h1>Podemos acceder con los objtetos </h2>";
    echo "<h1>Según r1 tenemos " .$r1::$cuenta_racionales."</h1>";
    echo "<h1>Según r2 tenemos " .$r2::$cuenta_racionales."</h1>";
    echo "<h1>Según r3 tenemos " .$r3::$cuenta_racionales."</h1>";
    echo "<h1>Según r4 tenemos " .$r4::$cuenta_racionales."</h1>";
    echo "<h1>Según La clase tenemos " .Racional::$cuenta_racionales."</h1>";
 
 
 
 
?>

La salida

Vamos a implementar las operaciones en un Racional.

Primero como siempre conviene recordar cómo se hacen

Sumar

Restar

Multiplicar

Dividir

Si la operación la implemento como un método no estático lo que estaría haciendo es sumar al objeto acutual, otro objeto Racional que pasamos como argumento. Puedo modificar el objeto acutal como resultado de la suma, o devolver otro objeto Racional que sería lo mas correcto

 /**
     *
     * @param Racional $n1
     * @return \Racional
     * @description suma al racional actual, el racional que recibe como parámetro
     */
    public function sumar(Racional $n1) {
        $den = ($this->den * $n1->getDen());
        $num = ($this->den * $n1->getNum() + $this->num * $n1->getDen());
 
        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 realizo como un método estático lo que estaría haciendo es sumar dos objetos Racionales , devolviendo un nuevo objeto de tipo Racional Vamos

    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 me permite crear una jerarquía en los componentes software, que se pueden ir especializando
Es principio de abstracción por el cual podemos crear una jerarquía de clases, donde tenemos la raíz con los elementos comunes y en los nodos vamos especializando clases.
La idea es definir una clase con ciertas características comunes (atributos, métodos)

Posteriormente crearemos otras clases a partir de la ya existente, quedando implícitamente los atributos y métodos como también parte de su estructura o composición.

Es una característica muy natural (p.e Personas (médicos y bailarines) vehículos (Terrestres (coche, moto) Acuáticos (barco, lancha))

Es una forma de obtener características comunes por separado y luego especializar evitando redundancias
Facilita la reusabilidad y adaptación

La herenica implica declarar jerarquía de clases

En la raíz de la misma, establecemos la parte o estructura común a dichas clases , y posteriormente vamos especializando las diferencias de cada clase

Puntos clave

Todos los atributos y métodos de un supertipo o clase en nivel superior que sean públicos o protegidos, son heredados (son parte de ella) a todas las clases de nivel inferior.

Para establecer una jerarquía, usamos la palabra reservada extends en las clases que hereden.
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, string $e){
 
    }
 
    public  function establecer_frase ($frase){
 
    }
 
    public function hablar ($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 a los métodos del supertipo usando el operador parent seguido del operador de resolución de ámbito ::

Observa el código

<?php
 
class Sanitario extends Persona
{
    protected $centroSalud;
    protected $yearTitulacion;
 
    public function __construct(string $centro, string $year){
        parent::__construct();
        ....
 
    }

Vemos dos ejemplos para explicar de forma empírica este concepto

Herencia: gestión personal ambulatorio

Se pide gestionar un ambulatorio.
Para ello vamos a hacer sólo el diagrama de clases y su implementación.
Lo hacemos a nivel básico (sin entrar en detalles).
Tras realizar un 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 especifican
en los siguientes diagramas de clases

Clase Conserje
Clase Enfermera
Clase Medicas

Claramente vemos que todos ellos tienen varios elementos en común.
Esto nos permite crear una clases genérica que por ejemplo podemos llamar personalAmbulatorio
Posteriormente creamos una especialización de personalAmbulatorio con los elementos particulares
El digrama podría quedar

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, "Cardiólogí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");
$enfermera = new Enfermera("Javier", "Moreno", "Casa de Javier", "general", 1990);
$enfermera2 = new Enfermera("Luis", "Perez", "Casa de Javier", "general", 1990);
 
 
$conserje->avisoEnfermera($enfermera, "Realizar cura en brazo Señor Martínez NSS 50/2155441/35");
 
$enfermera->avisoMedico($medico3, "Paciente con toss y fiebre");
 
$enfermera2->avisoMedico($medico2, "Paciente con toss y fiebre");
$enfermera2->avisoMedico($medico2, "Paciente con Vómitos");
$enfermera2->avisoMedico($medico3, "Paciente con pie torcido, impresión de rotura");
 
 
$conserje->avisoMedico($medico1, "Visitar en casa con mucha fiebre", "Visita");
$conserje->avisoMedico($medico1, "Problemas para desplazarse ", "Visita");
$conserje->avisoMedico($medico2, "Mareos y vétigos", "Visita");
$conserje->avisoMedico($medico2, "Persona mayor con poca mobilidad", "Visita");
$conserje->avisoMedico($medico3, "Niño pequeño con fiebre", "Visita");
$conserje->avisoMedico($medico1, "Caída en el parque", "Consulta");
?>
 
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <style type="text/css">
 
        </style>
        <link rel="stylesheet" href="./stilo.css" type="text/css"/>
    </head>
    <body>
        <?php
        echo "$medico3";
        echo "$medico1";
        echo "$medico2";
// put your code here
        ?>
    </body>
</html>

Clases Abstractas

Cuando realizamos jerarquías muchas veces encontramos métodos comunes a varias clases. Esto implicaría que ese método sería un método de una superclase o clase padre de la que luego se heredará
Pero puede ocurrir que aunque el concepto del método es común a todas las clases,la forma de implementarla es particular en cada una de ellas.

clase abstracta

En este caso, la forma correcta de proceder, es especificar el método el la clase superior, e implementar el código en cada una de las clases que derivo.
El método especificado en la clase superior sería un método sin código, conocido como un método abstracto, y la clase dónde se especifica pasa a ser abstracta

Clase Abstracta

Es aquella clase que tiene un método o más abstracto

Método Abstracto

Es un método que no tiene código asociado
El código se implementará en las clases derivadas

Puntos clave

Nunca podremos instanciar un objeto de una clase abstracta

Esto es normal, ya que ese objeto no tendría instrucciones para su/s método/s abstracto/s

Vamos a platear un ejemplo

App de Geometría

Gestionar figuras geométricas de tipo triángulo, cuadrado y Rectángulo.

De ellas queremos conocer:

el número de lados.
calcular el área.
dibujar el polígono (Esto insertaremos un pequeño código de javascript de uso básico del canvas
conocer el número de lados del polígono.

Realizamos los siguientes clases

Clase Polígono

Descripción de la Clase Polígono

Clase Rectángulo

Descripción de la Clase Rectángulo

Clase Cuadrado

Descripción de la Clase Cuadrado

Clase Triangulo

Descripción de la Clase Triángulo

Uso de esta aplicación

Un posible código index.php que lo único que hace es crear objetos y visulizar su área y dibujarlos

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
        <?php
        spl_autoload_register(function ($clase){
            require "$clase.php";
        });
 
        $triangulo = new Triangulo(200,300);
        $cuadrado = new Cuadrado(200);
        $rectangulo = new Rectangulo(200,100);
 
        echo "<h4>Triángulo,  ". Poligono::lados($triangulo)." y área ".
                $triangulo->area()." px<sup>2</sup></h4>";
 
        echo "<h4>Cuadrado, ". Poligono::lados($cuadrado)." y área ".
                $cuadrado->area()." px<sup>2</sup></h4>";
        echo "<h4>Rectángulo, ". Poligono::lados($rectangulo)." y área ".
                $rectangulo->area()." px<sup>2</sup></h4>";
 
        echo $triangulo->dibuja();
        echo $cuadrado->dibuja();
        echo $rectangulo->dibuja();
 
 
        ?>
    </body>
</html>

Resultado de su ejecución

V

@@ Línea 14: / Línea 14: @@
 |}
 __TOC__
-{{#widget:Slides}}
-<div class="slides layout-regular template-default">
-<div class="slide">
 <!--1 -->
 <div class=parrafo>
 {{PHP/ConceptosBasicos}}
+{{PHP/SintasixPHPOOP}}
 {{PHP/Sobrecarga}}
 {{PHP/Estatico}}
-{{PHP/Herencia}}
+{{PHP/Herencia}}
 </div>
 |}

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

Última revisión de 07:32 3 ene 2020

Contenido

Conceptos básicos de OOP

OOP Vs Programación estructurada

Elementos en la programación orientada a objetos

OPP En php

Pilares básicos de la POO

Encapsulación: Acceso a los componentes

Visibilidad

Declarando objetos: Operador new

$this

self

Acceso al contenido del objeto

Propiedades

Métodos

Métodos contructor y destructor

Métodos mágicos

Sobrecarga

Sobrecargando el constructor

Sobrecarga con __call(...)

Métodos static Vs no static

Herencia

Clases Abstractas

Menú de navegación

Herramientas personales

Espacios de nombres

Variantes

Vistas

Acciones

Buscar

Navegación

Herramientas

Imprimir/exportar