POO: Finalidad de la herencia y conceptos básicos

PHP

Programación orientada a objetos en PHP

Una vez que creas una clase puede crear una derivada de esta, una subclase. La herencia en programación orientada a objetos ahorra mucho trabajo reciclando código. La finalidad de la herencia es poder pasar todo el contenido de una clase, propiedades y métodos,  a una subclase y modificar sólo las partes que sean diferentes.

Para poder extender una clase a una subclase es preciso usar el operador extends. Voy a poner de ejemplo una universidad que quiere loguearse en la intranet. Habrá usuarios pero, no todos son iguales, algunos serán profesores y otros alumnos y cada uno tendrá sus propiedades y métodos en particular pero tendrán unos cuantos en común.

En este ejemplo creo 2 clases y muestro todas las propiedades de la clase Profesor instanciada.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?php
  $objeto = new Profesor;
  $objeto->nombre = "Eduardo";
  $objeto->clave = "123456";
  $objeto->correo = "eduardo@universidad.com";
  $objeto->asginatura = "Filosofia";
  $objeto->aulas = "101, 235, 456";
  $objeto->mostrar_datos();
 
  //Esta clase es común para todos los miembros de la universidad
 
  class Usuario
  {
    public $nombre, $clave, $correo;
    function guardar_usaurio()
    {
      echo "Este mensaje indica que se ha guardado el usuario";
    }
  }
 
  //Esta clase tendrá las propiedades y métodos de usuario y a mayores tendra otras propias
  class Profesor extends Usuario
  {
    public $asginatura, $aulas;
    function mostrar_datos()
    {
      echo "Nombre:  " . $this->nombre . "<br>";
      echo "Clave:  " . $this->clave . "<br>";
      echo "Correo: " . $this->correo . "<br>";
      echo "Asginatura: ".$this->asginatura . "<br>";
      echo "Aulas: " . $this->aulas;
    }
  }
?>

La clase original usuario tiene propiedades nombre, clave y correo además de un método. La clase Profesor que hereda de Usuario cuenta con propiedades y métodos propios pero no quita que pueda usar los de la superclase o clase padre. En el método mostrar_datos, se imprimen las propiedades del objeto usando $this para hacer referencia al propio objeto.

El operador parent

Este operador permite diferenciar el método de una clase padre en caso de que el nombre del método se repita tanto en la superclase como en la sublcase.

En este caso un método se repite 2 veces en ambas clases, metodo_repetido. Al instanciar la clase Hijo si invoco el metodo_repetido llamaría al de clase Hijo. Si quiero emplear el método de clase Padre empleo el operador parent en otro método de la clase hijo para así poder llamarlo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
  $objeto = new Hijo;
  $objeto->metodo_repetido();
  $objeto->metodo();
  
  class Padre
  {
    function metodo_repetido()
    {
      echo "Hola, soy la clase Padre<br>";
    }
  }
  
  class Hijo extends Padre
  {
    function metodo_repetido()
    {
      echo "Hola, soy la clase Hijo<br>";
    }
    function metodo()
    {
      parent::metodo_repetido();
    }
  }
?>

Si quisieras llamar al método de clase actual podrías emplear el operador self

PHP
1
self::nombre_metodo();

Constructores de las subclases

Una consideración a tener en cuenta sobre la herencia es cuando extiendes una clase y creas un constructor, PHP no llama automáticamente al constructor de la clase padre. Para llamar al constructor de la clase padre, bastará con usar el operador parent y hacer referencia al constructor

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
$objeto = new Gato();
  echo "Un gato tiene...<br>";
  echo "Pelaje: " . $objeto->pelaje . "<br>";
  echo "Patas: " . $objeto->patas . "<br>";
  echo "Ronronea: " . $objeto->ronronea;
 
  class Animal
  {
    public $pelaje, $patas; // Wildcats have fur
    function __construct()
    {
      $this->pelaje = "SI";
      $this->patas = 4;
    }
  }
 
  class Gato extends Animal
  {
    public $ronronea; // Tigers have stripes
    function __construct()
    {
      parent::__construct(); // Call parent constructor first
      $this->ronronea = "SI";
    }
  }

Métodos finales

En herencia, una clase que hereda de otra puede sobrescribir los métodos de la clase padre. Para que esto no suceda, se emplea el atributo final en el método. Por ejemplo

PHP
1
2
3
4
5
6
7
8
9
<?php
  class Usuario
  {
    final function copyright()
    {
      echo "No puedes cambiar este método";
    }
  }
?>

Y hasta aqui la herencia en PHP y algunos de los conceptos más importantes. A seguir picando 🙂