abstract (palabra clave).

Una clase abstracta es aquella que posee al menos un método abstracto. Un método abstracto es aquél que está declarado, pero que no posee implementación alguna (es decir no tiene cuerpo). Está incompleto. Debido a esta carencia, es imposible declarar objetos de una clase abstracta. ¿Para qué sirve entonces una clase abstracta? Una clase abstracta sirve para establecer un marco de trabajo que deben cumplir todas las clases que hereden de ella. Las clases que heredan de ella sí deben dotar de una implementación a los métodos abstractos del padre. Si no lo hacen, automáticamente se convierten también en abstractas. También es posible definir una clase abstracta sin que posea métodos abstractos.

Las clases y métodos abstractos llevan la palabra clave abstract. Es importante que tengas en cuenta que no pueden llevar el modificador abstract:

• los constructores
• los métodos estáticos
• los métodos privados

Ejemplo 1.
La clase abstracta Mascota declara un método abstracto hablar que deberá ser redefinido por las subclases Gato, Perro y Pato. Observa que la clase Mascota solo se está utilizando para declarar el método hablar, de modo que las clases hijas la puedan usar.

/**
 * Abstract class Mascota - Representa una mascota 
 */
public abstract class Mascota
{
    /**
     * Método abstracto hablar para las mascotas
     */
    abstract public void hablar();

}   //fin de la clase Mascota

/**
 * La clase Gato que hereda de la clase Mascota.
 */
public class Gato extends Mascota
{   
    /**
     * Implementación del método hablar
     */
    public void hablar() {
        System.out.println( "Meow" );
    }   // fin del método hablar
}   // fin de la clase Gato

/**
 * La clase Perro que hereda de la clase Mascota. 
 */
public class Perro extends Mascota
{
    /**
     * Implementación del método hablar
     */
    public void hablar() {
        System.out.println( "Woof" );
    }   // fin del método hablar
}   // fin de la clase Perro

/**
 * La clase Pato que hereda de la clase Mascota.
 */
public class Pato extends Mascota
{
    /**
     * Implementación del método hablar
     */
    public void hablar() {
        System.out.println( "Quack" );
    }   // fin del método hablar

}   // fin de la clase Pato

/**
 * Clase controladora para los objetos Gato, Perro, Pato.
 * 
 */
public class Granja
{  
    /**
     * Método principal de la aplicación
     */
    public static void main( String[] args )
    {
       Mascota[] misMascotas = new Mascota[4];
       misMascotas[0] = new Pato();
       misMascotas[1] = new Perro();
       misMascotas[2] = new Gato();
       misMascotas[3] = new Pato();
  
       for( int i = 0; i < misMascotas.length; i++ )
           misMascotas[i].hablar();
   
    }   //fin del método main
}   //fin de la clase Granja

Ejemplo 2.
La clase abstracta Producto incluye un método abstracto imprimirDatos. Observa el uso de la palabra clave abstract antes del nombre de la clase a fin de informar al compilador de Java que la clase incluye un método abstracto, o más. En virtud de que la clase abstracta no define todos sus métodos no se pueden crear instancias de la clase Producto.

/**
 * Abstract class Producto - Representa el producto de una tienda 
 * 
 */
public abstract class Producto
{
    // variables de instancia
    protected double precioVenta;
    protected double costoFabrica;
    protected String nombreProducto;

    /**
     * Constructor para Producto
     * 
     * @param   nombre  El nombre del producto
     * @param   precioVenta  El precio de venta del producto
     * @param   costoFabrica El costo de fábrica del producto
     */
    public Producto( String nombre, double precio, double costo )
    {
        nombreProducto = nombre;
        precioVenta = precio;
        costoFabrica = costo;
    }   // fin del constructor Producto
    
    /**
     * Método abstracto para imprimirDatos
     */
    public abstract String imprimirDatos();
   
}   // fin de la clase Producto

Observa que las clases Libro y DVD que extienden de la clase abstracta Producto e implementan el método abstracto imprimirDatos.

/**
 * Clase Libro que hereda de la clase Producto.
 */
public class Libro extends Producto
{
    /**
     * Constructor para los objetos de la clase Libro
     * @param   titulo  El título del libro
     * @param   precio  El precio de venta del libro
     * @param   costo   El costo de fábrica del libro

     */
    public Libro( String titulo, double precio, double costo )
    {
        super( titulo, precio, costo );
    }

    /**
     * Imprime los datos asociados con el libro
     * 
     * @return  los datos del libro en un String 
     */
    public String imprimirDatos()
    {
        return "Libro: " + nombreProducto + "\tPrecio: $" + precioVenta;
    }   // fin del método imprimirDatos
    
}   // fin de la clase Libro

/**
 * Clase Libro que hereda de la clase Producto.
 */
public class DVD extends Producto
{
    /**
     * Constructor para los objetos de la clase DVD
     * @param   titulo  El título del DVD
     * @param   precio  El precio de venta del DVD
     * @param   costo   El costo de fábrica del DVD
     */
    public DVD( String titulo, double precio, double costo )
    {
        super( titulo, precio, costo );
    }

    /**
     * Imprime los datos asociados con el DVD
     * 
     * @return  los datos del DVD en un String 
     */
    public String imprimirDatos()
    {
        return "DVD: " + nombreProducto + "\tPrecio: $" + precioVenta;
    }   //fin del método imprimirDatos
    
}   //fin de la clase DVD

/**
 * Clase controladora para los objetos de DVD y Libros.
 */
public class PruebaProducto
{   
    /**
     * Método principal de la aplicación
     */
    public static void main( String[] args )
    {
        Libro miLibro = new Libro( "Biblioteca del programador", 54.95, 39.95 );
        DVD miDVD = new DVD( "Curso multimedia de Java", 29.95, 19.95 );
        
        System.out.println( "Los datos de mis productos." );
        System.out.println( miLibro.imprimirDatos() );
        System.out.println( miDVD.imprimirDatos() );
    }   //fin del método main

}   //fin de la clase PruebaProducto

Véase: