TechCodeview

A palavra-chave abstract é usada para obter abstração em Java. É um modificador sem acesso usado para criar classes e métodos abstratos.

A função de uma classe abstrata é conter métodos abstratos. No entanto, também pode conter métodos não abstratos. O método que é declarado com a palavra-chave abstrata e não possui nenhuma implementação é conhecido como método abstrato.

Sintaxe:-

 abstract class Employee { abstract void work(); } 

Nota - Não podemos declarar métodos abstratos em classes não abstratas.

Regras de palavra-chave abstrata

Não é

• Uma palavra-chave abstrata não pode ser usada com variáveis ​​e construtores.
• Se uma classe for abstrata, ela não poderá ser instanciada.
• Se um método for abstrato, ele não contém o corpo.
• Não podemos usar a palavra-chave abstract com o final .
• Não podemos declarar métodos abstratos como privado .
• Não podemos declarar métodos abstratos como estático .
• Um método abstrato não pode ser sincronizado.

O que fazer

• Uma palavra-chave abstrata só pode ser usada com classe e método.
• Uma classe abstrata pode conter construtores e métodos estáticos.
• Se uma classe estende a classe abstrata, ela também deve implementar pelo menos um dos métodos abstratos.
• Uma classe abstrata pode conter o método principal e o método final.
• Uma classe abstrata pode conter métodos abstratos sobrecarregados.
• Podemos declarar a classe interna local como abstrata.
• Podemos declarar o método abstrato com uma cláusula throw.

Exemplos de palavras-chave abstratas

Exemplo 1: Classe abstrata contendo o método abstrato

 abstract class Vehicle { abstract void bike(); } class Honda extends Vehicle { @Override void bike() { System.out.println('Bike is running'); } } public class AbstractExample1 { public static void main(String[] args) { Honda obj=new Honda(); obj.bike(); } } 

Saída:

 Bike is running 

Exemplo 2: Classe abstrata contendo o método abstrato e não abstrato

 abstract class Vehicle { abstract void bike(); void car() { System.out.println('Car is running'); } } class Honda extends Vehicle { @Override void bike() { System.out.println('Bike is running'); } } public class AbstractExample2 { public static void main(String[] args) { Honda obj=new Honda(); obj.bike(); obj.car(); } } 

Saída:

 Bike is running Car is running 

Exemplo 3: Classe abstrata contendo o construtor

 abstract class Vehicle { String msg; Vehicle(String msg) { this.msg=msg; } void display() { System.out.println(msg); } } class Honda extends Vehicle { Honda(String msg) { super(msg); } } public class AbstractExample3 { public static void main(String[] args) { Honda obj=new Honda('Constructor is invoked'); obj.display(); } } 

Saída:

 Constructor is invoked 

Exemplo 4: Classe abstrata contendo métodos abstratos sobrecarregados

 abstract class Vehicle { abstract void display(); abstract void display(String msg); } class Honda extends Vehicle { @Override void display() { System.out.println('abstract method is invoked'); } @Override void display(String msg) { System.out.println(msg); } } public class AbstractExample4 { public static void main(String[] args) { Honda obj=new Honda(); obj.display(); obj.display('overloaded abstract method is invoked'); } } 

Saída:

 abstract method is invoked overloaded abstract method is invoked 

Exemplo 5: classe abstrata interna

 class Vehicle { abstract class Car { abstract void display(); } class Honda extends Car { @Override void display() { System.out.println('inner abstract class is invoked'); } } } public class AbstractExample5 { public static void main(String[] args) { Vehicle obj=new Vehicle(); Vehicle.Car c=obj.new Honda(); c.display(); } } 

Saída:

 inner abstract class is invoked 

Exemplo 6: classe abstrata aninhada

 abstract class Vehicle { abstract class Car { abstract void display(); } } class Honda extends Vehicle { class FourWheller extends Car { @Override void display() { System.out.println('nested abstract class is invoked'); } } } public class AbstractExample6 { public static void main(String[] args) { Vehicle obj=new Honda(); Honda h=(Honda)obj; Honda.FourWheller fw=h.new FourWheller(); fw.display(); } } 

Saída:

 nested abstract class is invoked