Clases abstractas en Java

Hola a todos, hoy os explicare que son y para que sirven las clases abstractas en Java.

Una clase abstracta es una clase con 0 o mas métodos sin implementar (igual que hacíamos con las interfaces). Cuando una clase es abstracta, no se pueden crear objetos de estas clases, en las clases hijas sera donde se implementen los métodos no implementados en la clase padre.

Para indicar que una clase es abstracta, escribimos abstract entre el modificador de acceso y class, así quedaría:

public abstract class Empleado

Dejamos un método sin implementar, por ejemplo, el método plus, para que cada clase hija implemente su propio método de forma diferente:

public abstract boolean plus (double sueldoPlus);

Como vemos, incluimos la palabra abstract igual que en la clase.

Veamos un ejemplo completo:

–Clase padre abstracta

/**
 * Clase Empleado
 *
 * Contiene informacion de cada empleado, es una clase abstracta
 *
 * @author Fernando
 * @version 1.0
 */
public abstract class Empleado {

	//Constantes

	/**
	 * Constante SALARIO_DEF
	 */
	protected final static double SALARIO_DEF=600;

	//Atributos

	/**
	 * Nombre del empleado
	 */
	protected String nombre;
	/**
	 * Apellido del empleado
	 */
	protected String apellido;
	/**
	 * Edad del empleado
	 */
	protected int edad;
	/**
	 * Salario del empleado
	 */
	protected double salario;

	//Metodos publicos

	/**
	 * Devuelve el nombre del empleado
	 * @return nombre del empleado
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * Modifica el nombre de un empleado
	 * @param nombre
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	/**
	 * Devuelve la edad de un empleado
	 * @return edad del empleado
	 */
	public int getEdad() {
		return edad;
	}

	/**
	 * Modifica la edad de un empleado
	 * @param edad
	 */
	public void setEdad(int edad) {
		this.edad = edad;
	}

	/**
	 * Devuelve el salarioBase
	 * @return salarioBse
	 */
	public double getSalario() {
		return salario;
	}

	/**
	 * Modifica el salarioBase de los empleados
	 * @param salarioBase
	 */
	public  void setSalario(double salario) {
		this.salario = salario;
	}

	public abstract boolean plus (double sueldoPlus);

	//Constructores
	/**
	 * Constructor por defecto
	 */
	public Empleado(){
		this ("", "", 0, SALARIO_DEF);
	}

	/**
	 * Constructor con 4 parametros
	 * @param nombre nombre del empleado
	 * @param apellido nombre del empleado
	 * @param edad edad del empleado
	 * @param salario salario del empleado
	 */
	public Empleado(String nombre, String apellido, int edad, double salario){
		this.nombre=nombre;
		this.apellido=apellido;
		this.edad=edad;
		this.salario=salario;
	}
}

–Clase hija

/**
 * Clase Comercial
 *
 * Contiene información de un comercial, un tipo de empleado
 *
 * @author Fernando
 * @version 1.0
 */
public class Comercial extends Empleado{

	//Atributos, aunque no indiquemos nada es como si tuviera los atributos del padre

	/**
	 * Comision por venta del comercial
	 */
	private double comision;

	/**
	 * Suma un plus al salario del empleado si el empleado tiene una comision menor que 50
	 * @param sueldoPlus
	 * @return</pre>
<ul>
<ul>*
	<li>true: se suma el plus al sueldo</li>
</ul>
</ul>
&nbsp;
<ul>
<ul>*
	<li>false: no se suma el plus al sueldo</li>
</ul>
</ul>
&nbsp;
<ul>*</ul>
<pre>
	 */
	public boolean plus (double sueldoPlus){

		boolean aumento=false;
		if (comision<50){
			salario+=sueldoPlus;
			aumento=true;
		}
		return aumento;
	}

	/**
	 * Constructor por defecto
	 */
	public Comercial(){
         super();
		this.comision=0;
	}

	/**
	 * Constructor con 5 parametros
	 * @param nombre nombre del comercial
	 * @param apellido apellido del comercial
	 * @param edad edad del comercial
	 * @param salario salario del comercial
	 * @param comision comision del comercial
	 */
	public Comercial(String nombre, String apellido, int edad, double salario, double comision) {
		super(nombre, apellido, edad, salario);
		this.comision=comision;
	}
}

–Clase ejecutable

public class EmpleadoApp {

	public static void main(String[] args) {

		//Nos saltara un error, no se pueden crear objetos de una clase abstracta
		Empleado empleado1=new Empleado();

		//La creacion es correcta
		Comercial comercial1=new Comercial();
	}

}

La idea de las clases abstractas es que tengamos una clase padre que sirva como plantilla para las clases hijas, en las clases hijas se implementaran los métodos abstractos de la clase padre.

Aunque no puedan crear objetos, si se pueden crear array de objetos de una clase abstracta.

Las clases abstractas tienen una gran ventaja y es que no necesita hacer casting de objetos ni utilizar el operador instanceof.

Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.

Etiquetas

4 comments

  1. En conclusion que hace todo el programa amigo no entiendo! ayuda con eso porfa

  2. Simplemente on definicion de clases, si intentas crear una instancia de una clase Empleado no te dejará, como he puesto en el post, es como una plantilla.

    Espero que te sea de ayuda.

  3. Una duda, ¿en el constructor sin argumentos de Comercial no habría que usar “super” para llamar al constructor de la clase padre?

  4. Si, tienes razón. Un despiste.

    Ya esta modificado. Gracias y un saludo

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *