Plantilla:PHP/SintasixPHPOOP

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

Contenido

1 OPP En php
2 Pilares básicos de la POO
3 Encapsulación: Acceso a los componentes
4 Visibilidad
5 Declarando objetos: Operador new
6 $this
7 self
8 Acceso al contenido del objete : -> y ::
9 Herencia
10 Métodos abstractos
11 Propiedades
12 Métodos
13 Sobrecarga
14 ::

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 Insertar aquí texto sin formatoque si queremos pasar un objeto a través de la red, debemos serializarlo, para que viaje también el valor del mismo y no solo la dirección de memoria que en destino carecería de sentido. Veremos este concepto más adelante.

En php las clases tienen métodos y propiedades

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

Definir una clase en php

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

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

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

El nombre de las clases se recomienda que empiece por mayúsculas
Es recomendable guardar las clases en ficheros cuyo nombre sea el propio de la clase

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)

Tip: A continuación un posible código iremos viendo más adelante muchos detalles sintácticos aquí expresados

<?php
 
class Fecha {
  private $dia;
  private $mes;
  private $year;
 
/**
 * 
 * @param int $dia
 * @param int $mes
 * @param int $year
 * Método con el nombre de la clase que se ejecuta  cuando se instancia un objeto
 * Recibe tres parámetros con los que inicializa los atributos
 */
  public function Fecha($dia, $mes, $year){
     $this->dia = $dia;
     $this->mes= $mes;
     $this->year= $year;
  }
 
/**
 * @return string la fecha con formato dd/mm/yyyy
 * Método público para visualizar la fecha
 */
  public function verFecha(){
          return "$this->dia / $this->mes= $mes /$this->year";
 
  }
?>

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
Herecia
Polimorfismo
Abstraccion

Encapsulación: Acceso a los componentes

A la hora de definir tanto las propiedades como los métodos, especificaremos el nivel de acceso que se tiene a ese elemento
Es una buena práctica de programación no dejar acceso directo a los atributos de una clase, sino acceder a ellos a través de los métodos

Puntos clave

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

Visibilidad

Visibilidad o alcance de las propiedades no constantes y los métodos de las clases
Implementa el principio de encapsulación.
Permite especificar el nivel de acceso que se tienen sobre los elementos

Visibilidad

Son tres los tipos de visibilidad que podemos especificar:

public
private
protected

Tip: public tipo de visibilidad asignada por defecto en caso de no especificar

public

Este tipo de visibilidad es asignada por defecto
Los elementos públicos pueden ser accesibles en cualquier momento del programa.
Recordemos que para acceder a un elemento debemos especificar el objeto o clase del que queremos el elemento
Si el elemento es estático o constante usaremos el operador :: llamado operador de especificación ámbito #::
Si el elemento es no estático accedemos a través del operador ->

Ejemplo

En el código anterior ver el método verFecha() que es públic
Sin embargo las propiedades dia, mes,year, son private
Esto implica que en el programa principal puedo hacer

....
$f = new Fecha(5,10,2017)
...
$f->verFecha();
...

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
En OOP es una tendencia hacer todos los atributos privados y acceder a ellos por los métodos setter and getter.

<?php
class Usuario {
    private $usuario;
    private $password;   
 
    public function __construct($usuario) {
        $this->password = 'passDefecto';
        $this->usuario = $usuario;
    }
 
    public function __destruct() {
        echo 'Me voy......';
    }
    public function getUsuario(){
        return $this->usuario;
    }
    public function getPass(){
        return $this->password;
 
    }
    public function setUsuario($user){
        this->usuario =$user;
    }
    public function setPass($pass){
        this->password =$pass;
    }
}
 
$usuario = new Usuario('manolo');
//....
$pass = $_POST['pass'];
//....
$usuario->setPass($pass);
//...
?>

Tip: A un elemento private de una clase, tampoco podrá acceder desde clases que deriven de ésta

protected

Este tipo de visibilidad implica que los elementos así especificados solo son accesible por la propia clase y por las clases derivadas
Para ello hay que ver la herencia que veremos más adelante dónde propondremos un ejemplo

<?php
class persona{
    protected $nombre;
    protected $fNac;
    //....
}
//.....
class medico extends persona{
    private $numColegiado;
 
    public function __construct($nombre, $fechaNacimiento, $colegiado) {
        $this->nombre=$nombre;
        $this->fNac=$fechaNacimiento;
        $this->numColegiado=$colegiado;
 
    }
    public function visualiza(){
        echo "Medico $this->nombre";
    }
}
$medicoPueblo1= new medico("pedro", "1/1/1969","123456");
$medicoPueblo1->visualiza();
 
?>

Declarando objetos: Operador new

Permite crear instancias de un objeto en memoria.
Una clase describe lo común de unos determinados objetos, la estructura o composición.
Las clases en principio no se usan durante la ejecución, salvo si queremos acceder a métodos o propiedades estáticas como veremos un poco más adelante
Lo que se usa en los programas son los objetos.
Para ello debemos instanciar objetos de las clases
Esto se hace con el operador new
Una vez instanciado ya tenemos la referencia del objeto y lo podemos utilizar
hay que pensar que en memoria tenemos toda la estructura del la clase por cada objeto

$this

Accediendo a los atributos de un objeto: seudovariable $this
$this es una seudovariable que referencia al objeto del ámbito en el cual está usado
Se utiliza dentro de la definición de la propia clase y hará referencia a un objeto concreto en un momento dado; esto dentro de la clase en la que está siendo utilizado

Ejemplo

<?php
class MyClase
{
    function ser_estar()
    {
        if (isset($this)) {
            echo '$this Ahora soy por que estoy';
        } else {
            echo "\$this ni es ni está.\n";
        }
    }
}

Podemos probar este código de la siguiente manera en un programa principal

....
        require "MyClass.php";
        $a = new MyClass();
        $a->ser_estar(); //Invocamos al método de un objeto
 
        MyClass::ser_estar(); //Invocamos al método de manera forzada, sin que exista un objeto concreto

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 objete : -> y ::

Ya hemos visto que para acceder a un elemento de un objeto usamos operadores -> o bien ::

Operador de indirección ->

Este operador es un operador de indirección
Los objetos son direcciones de memoria, cuando se quiere acceder al contenido de una dirección de memoria se usa un operador de indirección, que en el caso de php como en otros muchos lenguajes es -> .
Observar que se suele acompañar de una variable objeto o de la seudovariable $this , por ese motivo si se quiere acceder a una propiedad del objeto, ya no hay que especificar el $ en el nombre de la propiedad

class Clase1{
 public $propiedad1;
 ....
 public function __construct($valor){
       $this->propiedad1 = $valor; //la variable o propiedad de la clase no lleva $ al acceder a ella.
 
 }
....
 $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 {
    //put your code here
    const  IVA = 21;
    public static $numObj ;
    public function __construct() {
        self::$numObj++;
        echo "En total hay ".Clase1::$numObj." objetos de esta clase e IVA = ".static::IVA."<br />" ;
    }
 
}
 
$obj1 = new Clase1();
$obj2 = new Clase1();
$obj3 = new Clase1();
echo "<hr />";
echo "El valor del atributo estático numObj lo puedo ver desde cualquier objeto de la clase <br />";
echo "NumObj desde obj1 ".$obj1::$numObj. "<br />";
echo "NumObj desde obj2 ".$obj2::$numObj. "<br />";
echo "NumObj desde obj3 ".$obj3::$numObj. "<br />";
echo "NumObj desde en nombre de la clase ".Clase1::$numObj. "<br />";
?>

La salida que produciría el código sería

En total hay 1 objetos de esta clase e IVA = 21
En total hay 2 objetos de esta clase e IVA = 21
En total hay 3 objetos de esta clase e IVA = 21
El valor del atributo estático numObj lo puedo ver desde cualquier  objeto de la clase 
NumObj desde obj1 3
NumObj desde obj2 3
NumObj desde obj3 3
NumObj desde en nombre de la clase 3

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))

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

{{}}

Métodos abstractos

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.

Accediendo al valor de una constante

Dentro de la clase: usaremos el operador 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.

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
Las variables 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, también conocidas como variables de la clase, si se especifica con la palabra reservada #static.
Dado que php es de tipado dinámico, si dentro de un método de la clase quiero acceder a una propiedad de la misma he de indicarlo usando la seudovariable #$this'
En este caso no podremos el $ delante del nombre de la propiedad.

<?php
class Propiedades{
     public $propiedad = "rojo";
     public function getPropiedad(){
        echo "\$propiedad ahora es una variable local a método y no tiene valor: --$propiedad--<br/>";
        $propiedad="azul";
        echo "Ahora visualizo el valor de \$propiedad del método:  --$propiedad--<br/>";
        echo "Ahora visualizo el valor de \$propiedad de la clase:  --$this->propiedad--<br/>";
     } 
}
 
$a = new Propiedades();
$a->getPropiedad();
?>

Métodos

Es la forma de especificar el comportamiento de la clase
Es lo que el objeto va a saber hacer dentro del programa
Los métodos de detallan usando la palabra reservada function
En php dentro de la programación orientada a objetos tenemos una serie o tipo de métodos que conviene conocer y que posteriormente estudiaremos

#métodos contructor y destructor

En php, al igual que ocurre en Java, podemos tener un método con el mismo nombre que la clase.
Cuando instanciamos un objeto de una determinada clase, si existe este método se ejecuta y podríamos entenderlo como constructor de la clase.
Pero realmente el constructor corresponde a un #método mágico llamado __construct()'que es invocado y ejecutado siempre que se instancie un nuevo objeto de la clase. En este caso no se ejecutará el método con el nombre de la case si es que existiera.
El igual que tenemos un método que se ejecuta cuando instanciamos un objeto de la clase, existe otro #método mágico que se ejecuta siempre que se destrulla una instancia de una clase u objeto, y es el método __destruct()
Las impelementaciones de estos dos métodos, lógicamente son libre para cada clase,
Su invocación es transparente para el programador (esto es como 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

#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

Actividad

Empleado

Confeccionar una clase Empleado, definir como atributos su nombre y sueldo.
Definir un método inicializarlo para que lleguen como dato el nombre y sueldo.
Plantear un segundo método que imprima el nombre y un mensaje si debe o no pagar impuestos (si el sueldo supera a 3000 paga impuestos)

<html>
<head>
<title>Pruebas</title>
</head>
<body>
<?php
class Empleado {
  private $nombre;
  private $sueldo;
 
  public function asigna($nom,$sue)
  {
    $this->nombre=$nom;
    $this->sueldo=$sue;
  }
  public function pagaImpuestos()
  {
    echo $this->nombre;
    echo '-';
    if ($this->sueldo>3000)
      echo 'Debe pagar impuestos';
    else
      echo 'No paga impuestos';
    echo '<br>';
  }
}
 
$empleado1=new Empleado();
$empleado1->inicializar('Luis',2500);
$empleado1->pagaImpuestos();
$empleado1=new Empleado();
$empleado1->inicializar('Carla',4300);
$empleado1->pagaImpuestos();
?>
</body>
</html>

Actividad

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

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

Actividad

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

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

Ejemplo

Creamos la clase factura

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

Sobrecarga

Un concepto muy importante es la sobre carga.

Este concepto es básico en la programación Orientada a objetos;
Sin embargo este aspecto en php no es del todo intuitivo. No existe la sobrecarga como la entendemos en otros lenguajes
No obstante tenemos técnicas para poder simular la sobrecarga.
Muchas veces es fundamental o al menos cómodo sobrecargar el constructor de la clase.
Vamos a ver como podemos implementar la sobrecarga en php
Supongamos que en el ejemplo anterior quisiérmos poder instanciar de la siguiente manera los racionales

$a = new racional ("8/5");/*   8/5  */
$b = new racional (5,4);  /*   5/6  */
$c = new racional (5);    /*   5/1  */
$d = new racional ();     /*   1/1   */

Para esta situación tenemos diferentes estrategias. En este tema vamos a analizar 2:

sobrecargar en el constructor
sobrecargar con métodos mágicos

Sobrecargar en el constructor

Una sencila es ir viendo de qué tipo son los parámetros
Vemos que podemos tener 0, 1 o 2 paŕametros
Por lo tanto la función constructora tendrá que tener 3 parámetros inicializados por si no le pasamos valores

 public function __construct($cadenaOrNum=null, $den = null) {
 ....
}

Sobrecargar el constructor de un racional

Siguiendo el ejemplo establecido anteriormente realiza un constructor que permita instanciar un objeto de la clase racional de la siguiente manera

$a = new racional ("8/5");/*   8/5  */
$b = new racional (5,4);  /*   5/6  */
$c = new racional (5);    /*   5/1  */
$d = new racional ();     /*   1/1   */

métodos mágicos y la sobrecarga

Hemos visto __construct y __destruct
Vamos a analizar un método mágico para implementar la sobrecarga y exponer su funcionamiento
Ël método __call($nombreFuncion, $argumentos)' es un método mágico que se invoca cuando intentamos acceder a un método de la clase y este método no existe
Volvamos a nuestro racional
Supongamos que los métodos de sobrecarga que queremos son los usados en el constructor __construct

// caso $a = racional(8,7);
racionalNumDen($cadenaOrNum, $den );
// caso $a = racional(8);
racionalNum($cadenaOrNum );
// caso $a = racional("8/7");
racionalCadena($cadenaOrNum);
// caso $a = racional(); y se inicia con 1/1
racionalVacio();

Pero imagenimos que nos gustaría que todos tuvieran el mismo nombre, por ejemplo crea().
Vamos a usar el método __call para ello
Este método recibe dos argumentos

$nombreFuncion es el nombre del método que se invoca
$argumentos es un array con los argumentos de la función

Actividad

vamos a sobrecargar el método asigna() de la clase racional de modo que accepte sobrecarga

::

Plantilla:PHP/SintasixPHPOOP

Contenido

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 objete : -> y ::

Herencia

Métodos abstractos

Propiedades

Métodos

Sobrecarga

::

Menú de navegación

Herramientas personales

Espacios de nombres

Variantes

Vistas

Acciones

Buscar

Navegación

Herramientas