Classe abstrata Java e métodos abstratos

Neste tutorial, aprenderemos sobre classes e métodos abstratos Java com a ajuda de exemplos. Também aprenderemos sobre abstração em Java.

Classe abstrata Java

A classe abstrata em Java não pode ser instanciada (não podemos criar objetos de classes abstratas). Usamos o abstract palavra-chave para declarar uma classe abstrata. Por exemplo,

// create an abstract class
abstract class Language {
  // fields and methods
}
...

// try to create an object Language
// throws an error
Language obj = new Language();

Uma classe abstrata pode ter métodos regulares e métodos abstratos. Por exemplo,

abstract class Language {

  // abstract method
  abstract void method1();

  // regular method
  void method2() {
    System.out.println("This is regular method");
  }
}

Para saber sobre os métodos não abstratos, visite métodos Java. Aqui, aprenderemos sobre métodos abstratos.

Método abstrato Java

Um método que não possui seu corpo é conhecido como método abstrato. Usamos o mesmo abstract palavra-chave para criar métodos abstratos. Por exemplo,

abstract void display();

Aqui, display() é um método abstrato. O corpo de display() é substituído por ; .

Se uma classe contém um método abstrato, então a classe deve ser declarada abstrata. Caso contrário, irá gerar um erro. Por exemplo,

// error
// class should be abstract
class Language {

  // abstract method
  abstract void method1();
}

Exemplo:classe e método abstrato Java

Embora as classes abstratas não possam ser instanciadas, podemos criar subclasses a partir delas. Podemos então acessar membros da classe abstrata usando o objeto da subclasse. Por exemplo,

abstract class Language {

  // method of abstract class
  public void display() {
    System.out.println("This is Java Programming");
  }
}

class Main extends Language {

  public static void main(String[] args) {
    
    // create an object of Main
    Main obj = new Main();

    // access method of abstract class
    // using object of Main class
    obj.display();
  }
}

Saída

This is Java programming

No exemplo acima, criamos uma classe abstrata chamada Language . A classe contém um método regular display() .

Criamos a classe Main que herda a classe abstrata. Observe a afirmação,

obj.display();

Aqui, obj é o objeto da classe filha Main . Estamos chamando o método da classe abstrata usando o objeto obj .

Implementação de métodos abstratos

Se a classe abstrata inclui qualquer método abstrato, todas as classes filhas herdadas da superclasse abstrata devem fornecer a implementação do método abstrato. Por exemplo,

abstract class Animal {
  abstract void makeSound();

  public void eat() {
    System.out.println("I can eat.");
  }
}

class Dog extends Animal {

  // provide implementation of abstract method
  public void makeSound() {
    System.out.println("Bark bark");
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of Dog class
    Dog d1 = new Dog();

    d1.makeSound();
    d1.eat();
  }
}

Saída

Bark bark
I can eat.

No exemplo acima, criamos uma classe abstrata Animal . A classe contém um método abstrato makeSound() e um método não abstrato eat() .

Nós herdamos uma subclasse Cão da superclasse Animal . Aqui, a subclasse Cão fornece a implementação para o método abstrato makeSound() .

Em seguida, usamos o objeto d1 do Cão classe para chamar métodos makeSound() e eat() .

Observação :Se o Cão classe não fornece a implementação do método abstrato makeSound() , Cão também deve ser declarado como abstrato. Isso ocorre porque a subclasse Cão herda makeSound() de Animais .

Construtor de acessos de classes abstratas

Uma classe abstrata pode ter construtores como a classe regular. E podemos acessar o construtor de uma classe abstrata da subclasse usando o super palavra-chave. Por exemplo,

abstract class Animal {
   Animal() {
      ….
   }
}

class Dog extends Animal {
   Dog() {
      super();
      ...
   }
}

Aqui, usamos o super() dentro do construtor de Dog para acessar o construtor do Animal .

Observe que o super deve ser sempre a primeira instrução do construtor da subclasse. Visite a super palavra-chave Java para saber mais.

Abstração Java

O principal uso de classes e métodos abstratos é obter abstração em Java.

A abstração é um conceito importante da programação orientada a objetos que nos permite ocultar detalhes desnecessários e mostrar apenas as informações necessárias.

Isso nos permite gerenciar a complexidade omitindo ou ocultando detalhes com uma ideia mais simples e de nível superior.

Um exemplo prático de abstração pode ser o freio de moto. Sabemos o que o freio faz. Quando acionamos o freio, a moto para. No entanto, o funcionamento do freio é mantido escondido de nós.

A grande vantagem de ocultar o funcionamento do freio é que agora o fabricante pode implementar o freio de forma diferente para motos diferentes, no entanto, o freio será o mesmo.

Vamos dar um exemplo que nos ajuda a entender melhor a abstração Java.

Exemplo 3:abstração Java

abstract class MotorBike {
  abstract void brake();
}

class SportsBike extends MotorBike {
    
  // implementation of abstract method
  public void brake() {
    System.out.println("SportsBike Brake");
  }
}

class MountainBike extends MotorBike {
    
  // implementation of abstract method
  public void brake() {
    System.out.println("MountainBike Brake");
  }
}

class Main {
  public static void main(String[] args) {
    MountainBike m1 = new MountainBike();
    m1.brake();
    SportsBike s1 = new SportsBike();
    s1.brake();
  }
}

Saída :

MountainBike Brake
SportsBike Brake

No exemplo acima, criamos uma superclasse abstrata MotorBike . A superclasse MotorBike tem um método abstrato brake() .

O brake() método não pode ser implementado dentro de MotorBike . É porque cada bicicleta tem implementação diferente de freios. Então, todas as subclasses de MotorBike teria uma implementação diferente de brake() .

Então, a implementação de brake() em Moto é mantido escondido.

Aqui, MountainBike faz sua própria implementação de brake() e Bicicleta Esportiva faz sua própria implementação de brake() .

Observação :Também podemos usar interfaces para obter abstração em Java. Para saber mais, visite Interface Java.

Pontos-chave a serem lembrados

Usamos o abstract palavra-chave para criar classes e métodos abstratos.
Um método abstrato não tem nenhuma implementação (corpo do método).
Uma classe contendo métodos abstratos também deve ser abstrata.
Não podemos criar objetos de uma classe abstrata.
Para implementar recursos de uma classe abstrata, herdamos subclasses dela e criamos objetos da subclasse.
Uma subclasse deve substituir todos os métodos abstratos de uma classe abstrata. No entanto, se a subclasse for declarada abstrata, não é obrigatório substituir métodos abstratos.
Podemos acessar os atributos e métodos estáticos de uma classe abstrata usando a referência da classe abstrata. Por exemplo,
```
Animal.staticMethod();
```

Java super Interface Java

Java