Una clase es una colección de variables y de funciones que acceden a esas variables. Con esta definición estamos atendiendo a uno de los fundamentos principales de la programación orientada a objetos. Si bien el lenguaje PHP no puede englobarse dentro del grupo de lenguajes orientados a objetos, implementa en su concepción una serie de características que permitirán al programador construir dichos elementos.

Concepto de clase

Una Clase en su concepto puede definirse con la frase que inicia este capítulo o bien, para hacerlo más comprensible, podemos definirla igualmente como todo aquel conjunto de expresiones (funciones y variables) que se agrupan bajo un denominador común y actúan sobre algo. Por ejemplo, atendamos a esta definición de clase:

<?php
class Almacen {
    var $objetos;  // Objetos de un almacén
  
    // Añadir $num objetos de tipo $artnr al almacén
 
    function add_item ($artnr, $num) {
        $this->items[$artnr] += $num;
    }
  
    // Sacar $num objetos del tipo $artnr del almacén
 
    function remove_item ($artnr, $num) {
        if ($this->items[$artnr] > $num) {
            $this->items[$artnr] -= $num;
            return true;
        } else {
            return false;
        }  
    }
}
?>

Como podemos observar, la definición de la clase Almacen comprende todas las variables y funciones que serán utilizadas cuando queramos manipular algo del Almacén real en nuestro código. De esta forma estamos creando un un código muy reutilizable y mucho más legible que nos servirá para desarrollar nuestra aplicación de forma mucho más ordenada. Cuando una aplicación en cualquier lenguaje empieza a crecer, tenerlo todo ordenado es algo fundamental.

Utilización

Para utilizar una clase hay que crear primero una variable que nos permita el acceso a los objetos de la misma. Esto lo hacemos mediante el operador new de la siguiente forma:

$mov = new Almacen;
 $mov->add_item("102", 10);

Como podemos observar, se crea un objeto $mov perteneciente a la clase Almacen. Seguidamente se llama a la función add_item() de la clase para añadir 10 unidades del artículo 102 al Almacén. Mediante el operador -> se especifica la variable o método de una clase en su parte izquierda y derecha, respectivamente.

Uso extendido

Una caraterística muy útil de las definiciones de clases, es que éstas pueden utilizar otras clases para extendre su propia deficnición, adquiriendo de forma automática todas las funciones y variables de la clase "madre". Así, por ejemplo, podríamos crear una clase para referenciar al mozo de almacén que hace los movimientos:

class Mozo_Almacen extends Almacen {
    var $mozo;
 
    function set_mozo ($name) {
        $this->mozo = $name;
    }
}

La clase del ejemplo se crea heredando todas las funciones y variables de Almacen y además añade otra variable y otra función adicionales. De esta forma podemos crear nuevos almacenistas y acceder a ellos mediante la clase Mozo_Almacen, que también podrá usar las funciones habituales de la clase Almacen. Veamoslo en el ejemplo siguiente:

$nuevo_mozo = new Mozo_Almacen; // Creamos un nuevo mozo
$nuevo_mozo->set_mozo ("pepe"); // Nombramos al mozo
print $nuevo_mozo->owner;       // Imprimimos el nombre del mozo
$nuevo_mozo->add_item ("102", 10); // Usamos una función de Almacen

Observemos el uso de la variable especial $this en el ejemplo de definición de clase extendida anterior. La variable $this hace referencia al propio objeto cuando se trata de funciones de la misma clase. Igualmente, podemos crear una función con el nombre de la clase que se ejecute cada vez que se cree una nueva instancia de dicha clase. Estas funciones reciben el nombre de constructor.

class Auto_Add extends Almacen {
    function Auto_Add () {
        $this->add_item ("102", 1);
    }
}

En este ejemplo se define la clase Auto_Add como una extensión de Almacen. Cada vez que se crea una nueva instancia de Auto_Add, se ejecuta la función de su interior con el mismo nombre y se añade de forma automática una unidad del elemento 102. Como utilidad adicional, podemos hacer que los constructores reciban parámetros opcionales:

class Constructor_Almacen extends Almacen {
    function Constructor_Almacen ($item = "102", $num = 10) {
        $this->add_item ($item, $num);
    }
}

// Añadimos el producto por defecto
$default_item   = new Constructor_Almacen;
// Añadimos otro producto
$different_item = new Constructor_Almacen ("205", 175);

Ejemplo práctico

Para finalizar, vamos a ver un ejemplo de clase que servirá para realizar consultas a una base de datos MySQL:

<?php
//mysql_connect.inc.php

class DB_mysql {

 /* variables de conexión */
 var $BaseDatos;
 var $Servidor;
 var $Usuario;
 var $Clave;

 /* identificador de conexión y consulta */
 var $Conexion_ID = 0;
 var $Consulta_ID = 0;

 /* número de error y texto error */
 var $Errno = 0;
 var $Error = "";

 /* Método Constructor: Cada vez que creemos una variable
 de esta clase, se ejecutará esta función */
 function DB_mysql($bd = "", $host = "localhost", $user = "nobody", $pass = "") {
  $this->BaseDatos = $bd;
  $this->Servidor = $host;
  $this->Usuario = $user;
  $this->Clave = $pass;
 }

 /*Conexión a la base de datos*/
 function conectar($bd, $host, $user, $pass){
  if ($bd != "") $this->BaseDatos = $bd;
  if ($host != "") $this->Servidor = $host;
  if ($user != "") $this->Usuario = $user;
  if ($pass != "") $this->Clave = $pass;
  // Conectamos al servidor
  $this->Conexion_ID = mysql_connect($this->Servidor, $this->Usuario, $this->Clave);
  if (!$this->Conexion_ID) {
   $this->Error = "Ha fallado la conexión.";
   return 0;
  }
 //seleccionamos la base de datos
  if (!@mysql_select_db($this->BaseDatos, $this->Conexion_ID)) {
   $this->Error = "Imposible abrir ".$this->BaseDatos ;
   return 0;
  }
 /* Si hemos tenido éxito conectando devuelve
 el identificador de la conexión, sino devuelve 0 */
  return $this->Conexion_ID;
 }

 /* Ejecuta un consulta */
 function consulta($sql = ""){
  if ($sql == "") {
   $this->Error = "No ha especificado una consulta SQL";
   return 0;
  }
 //ejecutamos la consulta
  $this->Consulta_ID = @mysql_query($sql, $this->Conexion_ID);
  if (!$this->Consulta_ID) {
   $this->Errno = mysql_errno();
   $this->Error = mysql_error();
  }
 /* Si hemos tenido éxito en la consulta devuelve
 el identificador de la conexión, sino devuelve 0 */
  return $this->Consulta_ID;
 }

 /* Devuelve el número de campos de una consulta */
 function numcampos() {
  return mysql_num_fields($this->Consulta_ID);
 }

 /* Devuelve el número de registros de una consulta */
 function numregistros(){
  return mysql_num_rows($this->Consulta_ID);
 }

 /* Devuelve el nombre de un campo de una consulta */
 function nombrecampo($numcampo) {
  return mysql_field_name($this->Consulta_ID, $numcampo);
 }

 /* Muestra los datos de una consulta */
 function verconsulta() {
  echo "<table border=1>\n";
  // mostramos los nombres de los campos
  for ($i = 0; $i < $this->numcampos(); $i++){
   echo "<td><b>".$this->nombrecampo($i)."</b></td>\n";
  }
  echo "</tr>\n";
  // mostrarmos los registros
  while ($row = mysql_fetch_row($this->Consulta_ID)) {
   echo "<tr> \n";
   for ($i = 0; $i < $this->numcampos(); $i++){
    echo "<td>".$row[$i]."</td>\n";
   }
   echo "</tr>\n";
  }
 }

} //fin de la Clse DB_mysql

?>

Y el ejemplo de uso:

<body>
<html>
<?php
 require ("mysql_connect.inc.php");
 $miconexion = new DB_mysql ;
 $miconexion->conectar("mydb", "localhost", "admin", "");
 $miconexion->consulta("SELECT * FROM clientes");
 $miconexion->verconsulta();
?>
</body>
</html>

Sólo los usuarios registrados pueden escribir comentarios.
Por favor, valídate o regístrate.

Powered by AkoComment 2.0!