palabra clave abstracta en Java

La palabra clave abstract en Java se utiliza para declarar una clase o un método que no puede instanciarse directamente o que debe ser implementado por subclases, respectivamente. Es una parte clave del mecanismo de abstracción de Java, que permite a los desarrolladores definir clases y métodos abstractos que proporcionan un modelo para otras clases.

Utilización

Clase abstracta

Una clase abstracta es una clase que no puede instanciarse por sí misma y que puede contener métodos abstractos que deben ser implementados por las subclases.

Método abstracto

Un método abstracto es un método que se declara sin una implementación. Las subclases de la clase abstracta deben proporcionar una implementación de estos métodos.

Syntax

Clase abstracta

abstract class ClassName {
    // Abstract methods
    abstract void methodName();
    
    // Concrete methods
    void concreteMethod() {
        // Method body
    }
}

Método abstracto

abstract void methodName();

Ejemplos

Ejemplo 1: Clase y método abstractos

abstract class Animal {
    // Abstract method
    abstract void makeSound();

    // Concrete method
    void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    // Implementing the abstract method
    void makeSound() {
        System.out.println("Bark");
    }
}

public class AbstractExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // Outputs: Bark
        dog.sleep();     // Outputs: Sleeping...
    }
}

En este ejemplo, Animal es una clase abstracta con un método abstracto makeSound() y un método concreto sleep(). La clase Dog amplía Animal y proporciona una implementación del método makeSound().

Ejemplo 2: Múltiples métodos abstractos

abstract class Shape {
    abstract void draw();
    abstract double area();
}

class Circle extends Shape {
    private double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    void draw() {
        System.out.println("Drawing Circle");
    }

    double area() {
        return Math.PI * radius * radius;
    }
}

public class ShapeExample {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        circle.draw(); // Outputs: Drawing Circle
        System.out.println("Area: " + circle.area()); // Outputs: Area: 78.53981633974483
    }
}

Aquí, Shape es una clase abstracta con dos métodos abstractos: draw() y area(). Circle extiende a Shape y proporciona implementaciones para ambos métodos abstractos.

Consejos y buenas prácticas

• Utiliza Clases Abstractas para el Código Compartido: Utiliza clases abstractas cuando tengas código compartido que deba ser heredado por varias subclases. Las clases abstractas pueden contener métodos abstractos y concretos.
• Aplicación obligatoria: Asegúrate de que todos los métodos abstractos de una clase abstracta son implementados por sus subclases.
• No se puede instanciar: Recuerda que no puedes crear instancias de una clase abstracta directamente. Debes crear una instancia de una subclase que implemente todos los métodos abstractos.
• Utiliza métodos abstractos para las interfaces: Si tienes una clase que servirá de base con métodos que deben ser sobrescritos, utiliza métodos abstractos para hacer cumplir este contrato.
• Combinar con interfaces: Las clases abstractas pueden implementar interfaces y proporcionar implementaciones para algunos de los métodos, dejando otros como abstractos para que los implementen las subclases.  

  abstract class Vehicle implements Movable {
      abstract void start();
  }

• Constructor en Clase Abstracta: Las clases abstractas pueden tener constructores, que pueden ser llamados durante la instanciación de una subclase.  

  abstract class Base {
      Base() {
          System.out.println("Base Constructor");
      }
  }

• Clases abstractas frente a interfaces: Utiliza clases abstractas cuando necesites compartir código entre clases estrechamente relacionadas, y utiliza interfaces cuando necesites definir un contrato que pueda ser implementado por cualquier clase, independientemente de su posición en la jerarquía de clases.
• Métodos y campos estáticos: Las clases abstractas pueden tener campos y métodos estáticos, a los que se puede acceder sin crear una instancia de la clase.

abstract class Utility {
    static void printMessage() {
        System.out.println("Utility Message");
    }
}