Classe e método abstratos Java (com exemplo)

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

Java Abstract Class

A classe abstrata em Java não pode ser instanciada (não podemos criar objetos de classes abstratas). Usamos a abstractpalavra-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 a mesma abstractpalavra-chave para criar métodos abstratos. Por exemplo,

 abstract void display();

Aqui display()está 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, um erro será gerado. Por exemplo,

 // error // class should be abstract class Language ( // abstract method abstract void method1(); )

Exemplo: classe e método abstratos 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(); ) )

Resultado

 Esta é a programação Java

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 declaração,

 obj.display();

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

Implementando Métodos Abstratos

Se a classe abstrata incluir 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(); ) )

Resultado

 Eu posso comer casca de árvore.

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().

Herdamos uma subclasse Dog da superclasse Animal. Aqui, a subclasse Dog fornece a implementação para o método abstrato makeSound().

Em seguida, usamos o objeto d1 da classe Dog para chamar os métodos makeSound()e eat().

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

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 a superpalavra - chave. Por exemplo,

 abstract class Animal ( Animal() (… . ) ) class Dog extends Animal ( Dog() ( super();… ) )

Aqui, usamos super()o construtor dentro do Cão para acessar o construtor do Animal.

Observe que superdeve ser sempre a primeira instrução do construtor da subclasse. Visite Java super keyword para saber mais.

Abstração Java

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

Abstração é um conceito importante de 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 motocicleta. Nós sabemos o que o freio faz. Quando puxamos 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 que o freio faz será o mesmo.

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

Exemplo 3: abstração Java

 abstract class Animal ( abstract void makeSound(); ) class Dog extends Animal ( // implementation of abstract method public void makeSound() ( System.out.println("Bark bark."); ) ) class Cat extends Animal ( // implementation of abstract method public void makeSound() ( System.out.println("Meows "); ) ) class Main ( public static void main(String() args) ( Dog d1 = new Dog(); d1.makeSound(); Cat c1 = new Cat(); c1.makeSound(); ) )

Produto :

 Bark bark Meows

In the above example, we have created a superclass Animal. The superclass Animal has an abstract method makeSound().

The makeSound() method cannot be implemented inside Animal. It is because every animal makes different sounds. So, all the subclasses of Animal would have different implementation of makeSound().

So, the implementation of makeSound() in Animal is kept hidden.

Here, Dog makes its own implementation of makeSound() and Cat makes its own implementation of makeSound().

Note: We can also use interfaces to achieve abstraction in Java. To learn more, visit Java Interface.

Key Points to Remember

  • We use the abstract keyword to create abstract classes and methods.
  • An abstract method doesn't have any implementation (method body).
  • 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 sobrescrever 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();

Artigos interessantes...