palavra-chave abstract em Java

A palavra-chave abstract em Java é usada para declarar uma classe ou um método que não pode ser instanciado diretamente ou que deve ser implementado por subclasses, respectivamente. É uma parte fundamental do mecanismo de abstração do Java, permitindo que os desenvolvedores definam classes e métodos abstratos que fornecem um modelo para outras classes.

Uso

Classe abstrata

Uma classe abstrata é uma classe que não pode ser instanciada por si só e pode conter métodos abstratos que devem ser implementados por subclasses.

Método abstrato

Um método abstrato é um método que é declarado sem uma implementação. As subclasses da classe abstrata devem fornecer uma implementação para esses métodos.

Sintaxe

Classe abstrata

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

Método abstrato

abstract void methodName();

Exemplos

Exemplo 1: Classe abstrata e método

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...
    }
}

Neste exemplo, Animal é uma classe abstrata com um método abstrato makeSound() e um método concreto sleep(). A classe Dog estende a Animal e fornece uma implementação para o método makeSound().

Exemplo 2: Vários métodos abstratos

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
    }
}

Aqui, Shape é uma classe abstrata com dois métodos abstratos: draw() e area(). Circle estende Shape e fornece implementações para ambos os métodos abstratos.

Dicas e práticas recomendadas

• Use classes abstratas para código compartilhado: Use classes abstratas quando você tiver código compartilhado que deva ser herdado por várias subclasses. As classes abstratas podem conter métodos abstratos e concretos.
• Implementação obrigatória: Assegure-se de que todos os métodos abstratos em uma classe abstrata sejam implementados por suas subclasses.
• Não é possível instanciar: Lembre-se de que você não pode criar instâncias de uma classe abstrata diretamente. Você deve criar uma instância de uma subclasse que implemente todos os métodos abstratos.
• Use métodos abstratos para interfaces: Se você tiver uma classe que servirá como base com métodos que devem ser substituídos, use métodos abstratos para impor esse contrato.
• Combinação com interfaces: As classes abstratas podem implementar interfaces e fornecer implementações para alguns dos métodos, deixando outros como abstratos para serem implementados pelas subclasses.  

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

• Construtor na classe abstrata: As classes abstratas podem ter construtores, que podem ser chamados durante a instanciação de uma subclasse.  

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

• Classes abstratas versus interfaces: Use classes abstratas quando você precisar compartilhar código entre classes intimamente relacionadas e use interfaces quando precisar definir um contrato que possa ser implementado por qualquer classe, independentemente de sua posição na hierarquia de classes.
• Métodos e campos estáticos: As classes abstratas podem ter campos e métodos estáticos, que podem ser acessados sem a criação de uma instância da classe.

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