Herencia en PHP orientado a objetos

Una de las principales ventajas de la programación orientada a objetos es la capacidad de reducir la duplicación de código con herencia .

La duplicación de código ocurre cuando un programador escribe el mismo código más de una vez, un problema que la herencia se esfuerza por resolver. En herencia, tenemos una clase principal con sus propios métodos y propiedades, y una clase (o clases) secundaria que puede usar el código del padre.

Mediante el uso de la herencia, podemos crear un código reutilizable que escribimos solo una vez en la clase principal y volver a utilizar todo lo que necesitemos en las clases secundarias.

 

¿Cómo puede una clase heredar el código de otra clase?

La herencia nos permite escribir el código solo una vez en el padre y luego usar el código en las clases padre e hijo.

Para declarar que una clase hereda el código de otra clase, usamos la palabra clave extend .

Veamos el caso general:

class Parent {
  // La clase del padre
}
 
class Child extends Parent {
  // la clase Hijo utiliza las propiedades de la clase Padre
}

La clase secundaria puede hacer uso de todos los métodos y propiedades no privados que hereda de la clase primaria. Esto nos permite escribir el código solo una vez en el padre y luego usarlo en las clases padre e hijo.

En el siguiente ejemplo, la clase SportsCar hereda la clase Car , por lo que tiene acceso a todos los métodos y propiedades del Car que no son privados. Esto nos permite escribir los métodos públicos setModel() y hello() solo una vez en el padre, y luego usar estos métodos en las clases padre e hijo.

 

//The parent class
class Car {
  // Private property inside the class
  private $model;
 
  //Public setter method
  public function setModel($model)
  {
    $this -> model = $model;
  }
 
  public function hello()
  {
    return "beep! I am a <i>" . $this -> model . "</i><br />";
  }
}
 
 
//The child class inherits the code from the parent class
class SportsCar extends Car {
  //No code in the child class
}

//Create an instance from the child class
$sportsCar1 = new SportsCar();
  
// Set the value of the class’ property.
// For this aim, we use a method that we created in the parent
$sportsCar1 -> setModel('Mercedes Benz');
  
//Use another method that the child class inherited from the parent class
echo $sportsCar1 -> hello();

Resultado:
¡bip! Soy un mercedes benz

 

¿Cómo puede una clase secundaria tener sus propios métodos y propiedades?

Del mismo modo que una clase secundaria puede usar las propiedades y métodos de su clase principal, también puede tener propiedades y métodos propios. Sin embargo, si bien una clase secundaria puede usar el código que heredó del padre, la clase primaria no puede usar el código de la clase secundaria.

En el ejemplo que se muestra a continuación, agregaremos un código propio a la clase secundaria agregando la propiedad $style y el método driveItWithStyle() :

 

// The parent class has its properties and methods
class Car {
  
  //A private property or method can be used only by the parent.
  private $model;
  
  // Public methods and properties can be used by both the parent and the child classes.
  public function setModel($model)
  {
    $this -> model = $model;
  }
   
  public function getModel()
  {
    return $this -> model;
  }
}
 
  
//The child class can use the code it inherited from the parent class, 
// and it can also have its own code 
class SportsCar extends Car{
 
  private $style = 'fast and furious';
 
  public function driveItWithStyle()
  {
    return 'Drive a '  . $this -> getModel() . ' <i>' . $this -> style . '</i>';
  }
}
 
 
//create an instance from the child class
$sportsCar1 = new SportsCar();
   
// Use a method that the child class inherited from the parent class
$sportsCar1 -> setModel('Ferrari');
  
// Use a method that was added to the child class
echo $sportsCar1 -> driveItWithStyle();

Resultado:
Conduce un Ferrari rápido y furioso .

 

El modificador de control de acceso protegido

Cuando declaramos una propiedad o un método como protegidos, podemos abordarlo desde las clases principales y secundarias.

En un tutorial anterior , aprendimos que podemos usar el modificador de acceso público para permitir el acceso a los métodos y propiedades de una clase tanto dentro como fuera de la clase. También aprendimos que esos métodos y propiedades que son privados solo pueden usarse desde dentro de la clase.

En este tutorial, aprenderemos sobre un tercer modificador: el modificador protegido , que permite el uso del código tanto desde dentro de la clase como desde sus clases secundarias.

El primer ejemplo demuestra lo que podría suceder cuando declaramos la propiedad $ model en el padre como privada, pero aún así intentamos acceder a ella desde su clase secundaria.

¿Qué crees que puede pasar cuando intentamos llamar a un método privado o propiedad desde fuera de la clase?

Aquí está el código:

// The parent class
class Car {
  //The $model property is private, thus it can be accessed 
  // only from inside the class
  private $model;
  
  //Public setter method
  public function setModel($model)
  {
    $this -> model = $model;
  }
}
  
   
// The child class
class SportsCar extends Car{
  //Tries to get a private property that belongs to the parent
  public function hello()
  {
    return "beep! I am a <i>" . $this -> model . "</i><br />";
  }
}
   
//Create an instance from the child class
$sportsCar1 = new SportsCar();
  
//Set the class model name
$sportsCar1 -> setModel('Mercedes Benz');
   
//Get the class model name
echo $sportsCar1 -> hello();

Resultado:
Aviso: Propiedad indefinida: SportsCar :: $model

 

Obtenemos un error porque el método hello() en la clase secundaria está intentando acercarse a una propiedad privada, $model , que pertenece a la clase primaria.

Podemos solucionar el problema declarando la propiedad $model en el padre como protegida, en lugar de privada, porque cuando declaramos una propiedad o un método como protegidos, podemos abordarlo desde las clases padre e hijo.

 

// The parent class
class Car {
  //The $model property is now protected, so it can be accessed 
  // from within the class and its child classes
  protected $model;
   
  //Public setter method
  public function setModel($model)
  {
    $this -> model = $model;
  }
}
  
// The child class
class SportsCar extends Car {
  //Has no problem to get a protected property that belongs to the parent
  public function hello()
  {
    return "beep! I am a <i>" . $this -> model . "</i><br />";
  }
}
  
//Create an instance from the child class
$sportsCar1 = new SportsCar();
  
//Set the class model name
$sportsCar1 -> setModel('Mercedes Benz');
  
//Get the class model name
echo $sportsCar1 -> hello();

Resultado:
¡bip! Soy un mercedes benz

Ahora funciona, porque podemos acceder a un código protegido que pertenece a un padre de una clase secundaria.       

 

¿Cómo anular las propiedades y métodos de los padres en la clase secundaria?

De la misma manera que la clase secundaria puede tener sus propias propiedades y métodos, puede anular las propiedades y métodos de la clase primaria. Cuando anulamos las propiedades y métodos de la clase, reescribimos un método o propiedad que existe en el padre nuevamente en el hijo, pero le asignamos un valor o código diferente.

En el ejemplo que se muestra a continuación, creamos un método hello() en la clase principal que devuelve la cadena «bip» y lo anula en la clase secundaria con un método con el mismo nombre que devuelve una cadena diferente, «Halllo» .

Aquí está el código:

// The parent class has hello method that returns "beep".
 
class Car {
  final public function hello()
  {
    return "beep";
  }
}
 
//The child class has hello method that tries to override the hello method in the parent
class SportsCar extends Car {
  public function hello()
  {
    return "Hallo";
  }
}
  
 
//Create a new object
$sportsCar1 = new SportsCar();
  
//Get the result of the hello method
echo $sportsCar1 -> hello();

Resultado:
Fatal error: Cannot override final method Car::hello()

 

Dado que declaramos el método hello como final en el padre, no podemos anular el método en la clase secundaria.

Conclusión

Usamos la herencia para reducir la duplicación de código mediante el uso de código de la clase primaria en las clases secundarias. En este tutorial hemos aprendido uno de los principios de la programación orientada a objetos, el concepto de herencia .

Usamos la herencia para reducir la duplicación de código mediante el uso de código de la clase primaria en las clases secundarias. 

En el siguiente post aprenderemos algo muy util para nuestro código, la abstracción.