Herencia de Clases en Apex de Salesforce

La herencia de clases en Apex nos permite heredar las características (métodos y atributos) de una clase padre en otra clase hijo. Además, nos permite reutilizar y extender nuestro código de una manera eficiente.

Clase Padre de una Herencia de Clases en Apex

En Salesforce, la clase padre y sus métodos deben ser virtuales o abstractos. Además, para definir este tipo de clases, podemos utilizar la palabra reservada virtual o abstract según sea necesario.

public virtual class Persona { //Métodos virtuales }

public abstract class Persona { //Métodos abstractos y virtuales. }

Los métodos de una clase virtual deben ser métodos virtuales. Por otro lado, los métodos de una clase abstracta deben ser métodos abstractos o virtuales.

Los métodos virtuales, de una clase padre, deben implementar su contenido. No obstante, en la clase hijo, se puede reemplazar este código utilizando la palabra override.

Por otro lado, los métodos abstractos deben ser únicamente declarados en la clase padre. No obstante, obligatoriamente, deben implementarse en la clase hijo utilizando la palabra override.

public abstract class Persona { 
  private String nombre;
  public Persona (String nombre) { this.nombre = nombre; }
  public virtual String getName() { return nombre; }
  public abstract void caminar ();
}

public class Ingeniero extends Persona {
  public override void caminar () { System.debug('Caminó'); }
  
}

Por último, debemos tener en cuenta que, una clase abstracta no puede ser instanciada. A diferencia de una clase virtual.

Clase Hija de una Herencia de Clases en Apex

Para que una clase hija reciba las características de su clase padre, debe utilizar la palabra extends. Además, obligatoriamente, debe implementar sus métodos abstractos.

Una clase hija, al extender a otra clase, recibe los métodos y variables declarados en la clase padre.

Una clase hija sólo puede extender una clase padre al mismo tiempo. Además, las extensiones pueden aplicarse en Interfaces.

Ejemplo

La clase padre Persona tiene diferentes características como nombre, estatura. Además puede pararse, caminar y mostrar cuál es su profesión.

Declaramos la clase Persona como abstracta (abstract) para poder declarar métodos virtuales y abstractos. El método abstracto obtenerProfesion() sólo se ha declarado en el padre y se debe implementar, obligatoriamente, en las clases hijas.

public abstract class Persona {
  public String nombre;
  public Decimal estatura;

  public Persona (String nombre, Decimal estatura) {
    this.nombre = nombre;
    this.estatura = estatura;
  }

  public virtual void pararse () {
    System.debug('Persona se paró');
  }

  public virtual void caminar () {
    System.debug('Persona Caminó');  
  }

  public abstract String obtenerProfesion ();
}

Por otro lado, un Músico y un Ingeniero son personas, por lo tanto, deben heredar todas las características de la clase padre. No obstante, ambas entidades pueden tener sus propios métodos y atributos.

public class Musico extends Persona {
    public String instrumento;
    
    public Musico (String nombre, Decimal estatura, String instrumento) {
      super(nombre, estatura);
      this.instrumento = instrumento;
    }
    
    public void tocarGuitarra () {
      System.debug(nombre + ' tocó la guitarra');
    }
    
    public override void caminar () {
      System.debug('Caminó como músico');
    }
    
    public override String obtenerProfesion () {
      return 'Musico';
    }
}

public class Ingeniero extends Persona {
    String nroColegiatura;
    
    public Ingeniero (String nombre, Decimal estatura, String nroColegiatura) {
      super(nombre, estatura);
      this.nroColegiatura = nroColegiatura;
    }
    
    public void escribirPlanos () {
      System.debug(nombre + ' empezó a escribir planos');
    }
    
    public override String obtenerProfesion () {
      return 'Ingeniero';
    }
}

Además, podemos implementar o sobrescribir los métodos virtuales y abstractos de la clase padre en la clase hijo, utilizando la palabra clave override. Así tendremos el siguiente resultado:

Musico ms = new Musico ('Piere', 1.63, 'Guitarra y Voz');
System.debug(ms.nombre + ' es ' + ms.obtenerProfesion());
ms.caminar();
/*Resultado: 
  Piere es Músico
  Caminó como Músico*/

Ingeniero ing = new Ingeniero('Carlos', 1.79, '712354');
System.debug(ing.nombre + ' es ' + ing.obtenerProfesion());
ing.escribirPlanos();
/*Resultado: 
  Carlos es Ingeniero
  Carlos empezó a escribir planos*/