Conceptos de PHP Orientado a Objetos

Hasta ahora todos los problemas planteados hemos llamado a los métodos desde donde definimos un objeto de dicha clase, por ejemplo:

$cabecera=new CabeceraPagina('El blog del programador','center');
$cabecera->graficar();

Utilizamos la sintaxis:

[nombre del objeto]->[nombre del método]

Es decir antecedemos al nombre del método el nombre del objeto y el operador ->

Ahora bien que pasa si queremos llamar dentro de la clase a otro método que pertenece a la misma clase, la sintaxis es la siguiente:

$this->[nombre del método]

Es importante tener en cuenta que esto solo se puede hacer cuando estamos dentro de la misma clase.

Confeccionaremos un problema que haga llamadas entre métodos de la misma clase.

Problema:Confeccionar una clase Tabla que permita indicarle en el constructor la cantidad de filas y columnas. Definir otra responsabilidad que podamos cargar un dato en una determinada fila y columna. Finalmente debe mostrar los datos en una tabla HTML.

pagina1.php

<html>
<head>
<title>Pruebas</title>
</head>
<body>
<?php
class Tabla {
  private $mat=array();
  private $cantFilas;
  private $cantColumnas;

  public function __construct($fi,$co)
  {
    $this->cantFilas=$fi;
    $this->cantColumnas=$co;
  }

  public function cargar($fila,$columna,$valor)
  {
    $this->mat[$fila][$columna]=$valor;
  }

  public function inicioTabla()
  {
    echo '<table border="1">';
  }
    
  public function inicioFila()
  {
    echo '<tr>';
  }

  public function mostrar($fi,$co)
  {
    echo '<td>'.$this->mat[$fi][$co].'</td>';
  }

  public function finFila()
  {
    echo '</tr>';
  }

  public function finTabla()
  {
    echo '</table>';
  }

  public function graficar()
  {
    $this->inicioTabla();
    for($f=1;$f<=$this->cantFilas;$f++)
    {
      $this->inicioFila();
      for($c=1;$c<=$this->cantColumnas;$c++)
      {
        $this->mostrar($f,$c);
      }
      $this->finFila();
    }
    $this->finTabla();
  }
}

$tabla1=new Tabla(2,3);
$tabla1->cargar(1,1,"1");
$tabla1->cargar(1,2,"2");
$tabla1->cargar(1,3,"3");
$tabla1->cargar(2,1,"4");
$tabla1->cargar(2,2,"5");
$tabla1->cargar(2,3,"6");
$tabla1->graficar();
?>
</body>
</html>

Vamos por parte, primero veamos los tres atributos definidos,el primero se trata de un array donde almacenaremos todos los valores que contendrá la tabla HTML y otros dos atributos que indican la dimensión de la tabla HTML (cantidad de filas y columnas):

  private $mat=array();
  private $cantFilas;
  private $cantColumnas;

El constructor recibe como parámetros la cantidad de filas y columnas que tendrá la tabla:

  public function __construct($fi,$co)
  {
    $this->cantFilas=$fi;
    $this->cantColumnas=$co;
  }

Otro método de vital importancia es el de cargar datos. Llegan como parámetro la fila, columna y dato a almacenar:

  public function cargar($fila,$columna,$valor)
  {
    $this->mat[$fila][$columna]=$valor;
  }

Otro método muy importante es el graficar:

  public function graficar()
  {
    $this->inicioTabla();
    for($f=1;$f<=$this->cantFilas;$f++)
    {
      $this->inicioFila();
      for($c=1;$c<=$this->cantColumnas;$c++)
      {
        $this->mostrar($f,$c);
      }
      $this->finFila();
    }
    $this->finTabla();
  }

El método graficar debe hacer las salidas de datos dentro de una tabla HTML. Para simplificar el algoritmo definimos otros cinco métodos que tienen por objetivo hacer la generación del código HTML propiamente dicho. Así tenemos el método inicioTabla que hace la salida de la marca table e inicialización del atributo border:

  public function inicioTabla()
  {
    echo '<table border="1">';
  }

De forma similar los otros métodos son:

  public function inicioFila()
  {
    echo '<tr>';
  }

  public function mostrar($fi,$co)
  {
    echo '<td>'.$this->mat[$fi][$co].'</td>';
  }

  public function finFila()
  {
    echo '</tr>';
  }

  public function finTabla()
  {
    echo '</table>';
  }

Si bien podíamos hacer todo esto en el método graficar y no hacer estos cinco métodos, la simplicidad del código aumenta a mediada que subdividimos los algoritmos. Esto es de fundamental importancia a medida que los algoritmos sean más complejos.

Lo que nos importa ahora ver es como llamamos a métodos que pertenecen a la misma clase:

  public function graficar()
  {
    $this->inicioTabla();
    for($f=1;$f<=$this->cantFilas;$f++)
    {
      $this->inicioFila();
      for($c=1;$c<=$this->cantColumnas;$c++)
      {
        $this->mostrar($f,$c);
      }
      $this->finFila();
    }
    $this->finTabla();
  }

Es decir le antecedemos el operador $this-> al nombre del método a llamar. De forma similar a como accedemos a los atributos de la clase.

Por último debemos definir un objeto de la clase Tabla y llamar a los métodos respectivos:

$tabla1=new Tabla(2,3);
$tabla1->cargar(1,1,"1");
$tabla1->cargar(1,2,"2");
$tabla1->cargar(1,3,"3");
$tabla1->cargar(2,1,"4");
$tabla1->cargar(2,2,"5");
$tabla1->cargar(2,3,"6");
$tabla1->graficar();

Es importante notar que donde definimos un objeto de la clase Tabla no llamamos a los métodos inicioTabla(), inicioFila(), etc.

6 - Llamada de métodos dentro de la clase.

Retornar