Clases y objetos

Aunque PHP no es en si mismo un leguaje de programación orientado a objetos si dispone de algunas características que permiten definir clases y construir objetos.

La implementación de clases no va a añadir ninguna funcionalidad nueva a las posibilidades de PHP. Su verdadera utilidad es la de hacer la programación de otra manera, con un código más legible y reutilizable.

Y ...como cada maestrillo tiene ... sus «manías» ;-) seguro que encontrarás acérrim@s defensores de ese modo de programar y también empecinad@s detractores que defenderán que ... para este viaje no hacen falta alforjas yo solo te diré, aquí lo tienes... si te gusta quédatelo y sino olvídalo.

Las clases

Una clase no parece ser otra cosa que una especie de plantilla en la que se pueden definir una serie de variables -a las que se pueden asignar valores predefinidos- y funciones que pueden ser invocadas -en todo o en parte- desde cualquier otra parte del documento.

La sintaxis es la siguiente:

class nombre {
....
... definición de variables....
....
.. constructores (opcional)...
....
.. definición de funciones...
....
}

Vayamos por partes...

Dentro de la clase podemos definir variables que serán usadas por las funciones internas de esa clase y a las que se puede (no es obligatorio hacerlo) asignar valores.

Para definir una variable es obligatorio anteponer var al nombre de la variable y en el caso de que pretendamos asignarles un valor bastará con poner detrás del nombre de la variable el signo = y a continuación el valor.

Ni que decir tiene que... el nombre de la variable utiliza la sintaxis habitual de PHP y que si los valores asignados son tipo cadena tienen que ir entre comillas.

var $pepe="Jose"

es una sintaxis válida, pero...

$pepe="Jose"

no lo es, le falta el var y si lo escribes así... te dará error

Más tarde te contaré la triste historia de los contructores pero... como son opcionales, antes vamos a mencionar a las funciones.

Las funciones definidas dentro de las clases tienen una sintaxis idéntica a las demás funciones PHP con una salvedad importante.

Siempre que desde una función se invoque una variable definida dentro de la clase debe hacerse con la siguiente sintaxis:

$this->variable

¡¡Ojo al Cristo que es de plata... ;-)

Fíjate bien... el $ va siempre delante de la palabra this y solo se escribe una vez y en esa posición.
El nombre de la variable (que va siempre después de -> no lleva pegado el $.

¡¡Mira los ejemplos...!!

Crear y utilizar objetos

Las clases son solo plantillas y sus funciones no se ejecutan hasta que se les ordene.

Para poder utilizarlas primero debemos crear un objeto y luego ejecutar sobre ese objeto la función o funciones que deseemos

Creación de objetos

Para crear un objeto utilizando una clase determinada debemos utilizar siempre esta sintaxis:

$nombre = new clase

donde nombre es una palabra cualquiera con la que identificaremos el objeto (como si se tratara de una variable) y clase es el nombre de una de las clases definidas.

¡¡Cuidadito...!!

Fíjate que detrás del nombre de la clase no he puesto los famosos () que suelen utilizarse para invocar a las funciones.

Te juro que no fué olvido..:-)
Y te juro también que me pasé un par de horas peleando por mi manía de ponerlos... y aunque se que estas cosas ...solo me pasan a mí ;-) te lo comento... por si las moscas ;-)

Utilizando objetos

Una vez definido un objeto ya se le pueden aplicar las funciones definidas en la clase. La sintaxis es esta:

$nombre->funcion()

Donde $nombre es la misma variable utilizada a la hora de crear el objeto el -> no es un adorno, lo juro..;-), funcion es el nombre de una de las funciones definidas en la clase invocada y donde los () si son obligatorios y además -como ocurre en las funciones- pueden contener valores, variables, etc. etc. separadas por comas.

Reiterando llamadas a objetos

Si hacemos varias llamadas a una función utilizando el mismo objeto los resultados de la última llamada se sobreescriben sobre los de la llamada anterior.
Si queremos conservar varios resultados obetenidos de la aplicación de la misma función parece ser que tenemos dos opciones:

• Crear varios objetos
• Utilizar arrays

Para que no me llames pelmazo en el ejemplo ejemploC2 puedes ver el primer supuesto y en ejemploC3 un caso de la segunda opción.

Constructores

Las clases tienen una peculiaridad interesante.
Cuando se define una función con un nombre idéntico al nombre de la clase, a esa función se le llama un constructor.

Esa función -el constructor- tiene la peculiaridad de que se ejecuta de forma automática en el momento en que el se define un nuevo objeto (new)

Y dependiendo como esté definido el constructor puede ejecutarse de distintas formas:

• Utilizando los valores predefinidos en las variables de la clase.

  Puedes verlo en el ejemplo ejemploC4.

• Asignado unos valores preestablecidos a los parámetros de la función constructor

  En el ejemplo ejemploC5 puedes ver la sintaxis de esta forma en la que se le asignan los valores 3 y 7 a las variables $a y $b.
En el mismo ejemplo, puedes ver la utilidad añadida del constructor.

Cuando se le pasan valores la función se ejecuta olvidándose de los valores asignados por defecto en la función y cuando se le pasan solo parte de los valores utiliza los valores recibidos y para los asignados en la llamada utiliza -por defecto- los valores del constructor.

Clases extendidas

Bueno... el caso es que... por si construimos la casa y y olvidamos ponerle ventanas.. ;-) PHP tiene la posibilidad de crear clases extendidas que tienen la virtud de poder disponer tanto de las variables y funciones propias como de todas las variables y funciones de la clase base.

Sintaxis de las clases extendidas

Para crear una clase extendida debemos utilizar la siguiente sintaxis:

class nuev extends base {
....
... definición de variables....
....
.. constructores (opcional)...
....
.. definición de funciones...
....
}

Como habrás deducido -se te ve en los ojos que si :-) - nuev es el nombre de la nueva clase (la extendida), base es el nombre de la clase padre y extens es eso... extends, es decir la palabra clave que indica a PHP que se trata de una clase extendida.

¡¡Cuidado... con los vicios!!

No es posible crear una clase extendida de otra clase extendida. PHP no soporta herencias múltiples.

¡¡Que lo sepas... ;-)

Funciones con Clases y objetos

PHP dispone de algunas funciones que pueden resultarte útiles a la hora de trabajar con clases y objetos. Son estas:

method_exists(obj, func)

Comprueba si la funcion func (función y método son sinónimos) está definida en el objeto obj.

Devuelve un valor booleano. Cierto (true) en el caso de que exista esa función y falso en el caso de que no exista.

get_class_vars(clase)

Devuelve un array asociativo cuyos índices son los nombres de las variables y cuyos valores son los valores preasignados a esa variable.

Solo recoge en ese array las variables que han sido inicializadas asignándoles un valor.

get_class_methods(clas)

Devuelve un array conteniendo los valores de todos los métodos (funciones) definidas en la clase clas.

get_object_var(obj)

Devuelve todas las variables (y sus valores) contenidas en el objeto obj.

La llamada ::

PHP permite llamar a una función definida en una clase sin necesidad de crear previamente un objeto.

La sintaxis es esta:

clase :: funcion()

donde clase es el nombre de una clase y funcion() es una función definida dentro de esa clase.

Su funcionalidad es la misma que si escribiéramos:

$nombre = new clase

$nombre -> funcion ()

<?
class Multiplica{

    var $factor1=7;
    var $factor2=8;

    function curratelo(){
        echo $this->factor1*$this->factor2;
       }
}

   $objeto= new Multiplica;
   $objeto->curratelo();
 ?>

<?
class Multiplica{

    var $resultado;


    function curratelo($a,$b){
      $this->resultado=$a*$b;
       }
       
    function imprimelo(){
        echo $this->resultado,"<br>";
       }
}

   $objeto= new Multiplica;
   $objeto->curratelo(7,3);
   $objeto->curratelo(11,4);

   $objeto1= new Multiplica;
   $objeto1->curratelo(-23,11);

   $objeto->imprimelo();
   $objeto1->imprimelo();

 ?>

<?
class Multiplica{

    var $resultado;
    var $indice=0;


   function curratelo($a,$b){
      $this->resultado[$this->indice]=$a*$b;
      $this->indice++;
       }

   function imprimelo(){
       foreach($this->resultado as $valor){
            echo $valor,"<br>";
        }
   }

}

   $objeto= new Multiplica;
   
   $objeto->curratelo(7,3);
   $objeto->curratelo(11,4);
   $objeto->curratelo(-23,11);

   $objeto->imprimelo();

 ?>

<?
class Multiplica{

    var $factor1=7;
    var $factor2=8;

    function Multiplica(){
        echo $this->factor1*$this->factor2,"$lt;br>";
    }
}

   $objeto= new Multiplica;

 ?>

<?
class Multiplica{

    var $producto;


    function Multiplica($a=3,$b=7){
        $this->producto=$a*$b;
        echo $this->producto,"<br>";
    }
}
   $objeto= new Multiplica;

   $objeto->Multiplica(90,47);

   $objeto->Multiplica(47);

   $objeto->Multiplica();


 ?>

<?
Class Operaciones {
    var $inicializada=32;
    var $num1;
    var $num2;
    var $suma;
    var $diferencia;
    var $producto;
    var $cociente;
    var $contador=0;
      function Operaciones ($val1=45,$val2=55){
        $this->contador +=1;
        $c=$this->contador;
        $this->num1[$this->contador]=$val1;
        $this->num2[$c]=$val2;
        $this->suma[$c]=$val1+$val2;
        $this->diferencia[$c]=$val1-$val2;
        $this->producto[$c]=$val1*$val2;
        $this->cociente[$c]=$this->inicializada*$val1/$val2;
              }


     function imprime(){
         echo "<table align=center border=1>";
         echo "<td>Num 1</td><td>num2</td><td>Suma</td>";
         echo "<td>Diferencia</td><td>Producto</td><td>Cociente</td><tr>";
         foreach($this->num1 as $clave=>$valor){
             $n2=$this->num2[$clave];
             $s=$this->suma[$clave];
             $d=$this->diferencia[$clave];
             $p=$this->producto[$clave];
             $c=$this->cociente[$clave];
             echo "<td align=center>$valor</td>";
             echo "<td align=center>$n2</td>";
             echo "<td align=center>$s</td>";
             echo "<td align=center>$d</td>";
             echo "<td align=center>$p</td>";
             echo "<td align=center>$c</td><tr>";
     }
      echo "</table>";

     }
}
$objeto= new Operaciones;

for ($i=1;$i<11;$i++){
    for ($j=1;$j<11;$j++){
        $objeto -> Operaciones($i,$j);
           }
}

$objeto-> imprime();

?>

<?
class Multiplica{

    var $factor1=7;
    var $factor2=8;

    function Multiplica(){
        echo $this->factor1*$this->factor2,"<br>";
        echo "Esto está en el constructor de la clase padre<br>";
    }
}

class MeSeOlvido extends Multiplica{

   var $divisor=5;
   function MeSeOlvido(){
        echo $this->factor1*$this->factor2/$this->divisor,"<br>";
   }
}

$objeto= new MeSeOlvido;

$objeto->Multiplica();
 ?>

<?
include("ejemploC6.php");

$busca="imprima";

if(method_exists ( $objeto, $busca)){
    echo "Existe la función  $busca <br>";
}else{
    echo "No existe la función $busca <br>";
}

$r=get_class_vars ("Operaciones");
foreach ($r as $pepe=>$pepito){
    echo "$pepe -->$pepito<br>";
}

$s=get_class_methods("Operaciones");
foreach($s as $clave){
    echo $clave,"<br>";
}
print_r(get_object_vars($objeto));
?>

<?
class A {
    function ejemplo() {
        echo "Este es el resultado de la función ejemplo<br>";
        }
}

# llamo a la funcion sin crear un nuevo objeto
# usando ::
A::ejemplo();

#ahora creo el objeto $b y llamo a la función

$b = new A;
$b->ejemplo();
?>

---

Sugerir a un/a amig@	Envíame tus comentarios

Anterior

Indice

Siguiente