Uma classe abstrata em Java é uma classe que não pode ser instanciada diretamente. O objetivo disso é atuar como uma classe base da qual as outras classes podem ser herdadas e estendidas. Uma das características importantes de uma classe abstrata é a capacidade de definir os construtores, que são conhecidos como métodos especiais e que são invocados quando um objeto de uma classe é criado.

Regras a serem seguidas ao definir construtores em uma classe abstrata:

1. Classes abstratas podem ter construtores, mas não podem ser instanciadas diretamente. Os construtores são usados ​​quando uma subclasse concreta é criada.
2. Pode haver um ou mais métodos abstratos em uma classe abstrata, o que significa que esses métodos não são implementados pela classe. Para ser instanciada, uma subclasse que estende uma classe abstrata com métodos abstratos deve implementar os métodos. Isso significa que cada método abstrato declarado dentro de uma classe abstrata precisa ter uma implementação se uma subclasse precisar ser uma classe concreta e poder ser instanciada. Em outras palavras, a funcionalidade que a classe abstrata deixou aberta deve ser preenchida pela subclasse.
3. Quando uma subclasse estende uma classe abstrata com construtores, a subclasse precisa chamar um dos construtores dentro da superclasse com a ajuda da superpalavra-chave. Porque o construtor da superclasse inicializa o estado do objeto e une quaisquer recursos vitais. Se a subclasse agora não chamar um dos construtores da superclasse, o objeto não será bem inicializado e não funcionará de forma eficiente/correta.
4. É viável definir mais de um construtor em uma classe abstrata, semelhante a alguma outra classe. No entanto, cada construtor deve ser definido com uma lista de parâmetros diferente. Ele permite que as subclasses escolham qual construtor chamar com base em suas necessidades específicas.

Tipos de construtores implementados usando classe abstrata:

Existem três tipos de construtores:

1. Construtor padrão
2. Construtor parametrizado
3. Copiar Construtor

1. Construtor padrão: O construtor é criado automaticamente via Java se nenhum outro construtor estiver definido na classe. Ele não possui parâmetros e não executa nenhum movimento além de inicializar valores padrão para campos de classe.

ALGORITMO:

Passo 1: Defina uma classe abstrata chamada 'Shape'.

sistema de arquivos no linux

Passo 2: Declare duas variáveis ​​inteiras 'x' e 'y' como protegidas.

Etapa 3: Crie um construtor padrão da classe Shape e defina 'x' e 'y' como 0.

Passo 4: Agora crie um método 'getArea()', é um método abstrato que retornará um valor duplo

Etapa 5: Em seguida, crie dois métodos não abstratos 'printPosition()' e 'setPosition(int x, int y)' que pertencem à classe Shape.

Etapa 6: O método setPosition define os valores de x e y.

Etapa 7: O método printPosition imprime os valores de x e y.

Etapa 8: Defina uma classe Circle que estende a classe Shape.

Etapa 9: Declare uma variável dupla chamada 'radius' como protegida na classe Circle.

Etapa 10: Defina um construtor para a classe Circle que aceite um valor duplo para o raio.

Etapa 11: Implemente o método getArea para a classe Circle que calcula a área do círculo.

Etapa 12: Defina uma classe Square que estenda a classe Shape.

Etapa 13: Declare uma variável dupla chamada 'side' como protegida na classe Square.

Etapa 14: Defina um construtor para a classe Square que aceite um valor duplo para o lado.

Etapa 15: Implemente o método getArea para a classe Square que calcula a área do quadrado.

Etapa 16: Defina uma classe principal.

Etapa 17: Defina a função principal na classe Main.

Etapa 18: Crie um objeto Circle e um objeto Square.

Etapa 19: Chame o método setPosition para os objetos Circle e Square.

Etapa 20: Chame o método getArea para os objetos Circle e Square e imprima os resultados.

Etapa 21: Chame o método printPosition para os objetos Circle e Square e imprima os resultados.

Implementação:

Aqui está a implementação das etapas acima

Nome do arquivo: PadrãoMain.java

 import java.util.*; abstract class Shape { protected int x; protected int y; // default constructor public Shape() { // initialize default values for fields x = 0; y = 0; } // abstract method to calculate area public abstract double getArea(); // other methods public void setPosition(int x,int y) { this.x=x; this.y=y; } public void printPosition() { System.out.println('The Position: ('+x + ', '+ y +')'); } } class Circle extends Shape { protected double radius; // constructor public Circle(double radius) { this.radius=radius; } // implementation of getArea() for Circle public double getArea() { return Math.PI * radius * radius; } } class Square extends Shape { protected double side; // constructor public Square(double side) { this.side = side; } // implementation of getArea() for Square public double getArea() { return side * side; } } public class DefaultMain { public static void main(String args []) { // create a Circle object Circle circle = new Circle(5); circle.setPosition(2,3); // print the area and position of the Circle object System.out.println('Area of a circle is: '+circle.getArea()); circle.printPosition(); // create a Square object Square square = new Square(4); square.setPosition(5, 7); // print the area and position of the Square object System.out.println('Area of a square is: '+square.getArea()); square.printPosition(); } } 

Saída:

 Area of a circle is: 78.53981633974483 The Position:(2, 3) Area of a square is: 16.0 The Position:(5, 7) 

2. Construtor parametrizado: Ao criar um objeto, esse tipo de construtor permite passar argumentos para ele. Quando você deseja inicializar o objeto com valores, isso é útil. O construtor parametrizado é definido com um ou mais parâmetros, e enquanto um objeto é criado, os valores passados ​​ao construtor são usados ​​para inicializar os campos correspondentes do item.

ALGORITMO:

Passo 1: Defina uma classe abstrata Shape.

Passo 2: Adicione duas variáveis ​​de instância protegidas do tipo int denominadas x e y.

Etapa 3: Crie um construtor parametrizado que inicialize as variáveis ​​de instância x e y e aceite dois parâmetros do tipo int, x e y.

Passo 4: Defina uma classe abstrata Shape.

Etapa 5: Adicione duas variáveis ​​de instância protegidas do tipo int denominadas x e y.

Etapa 6: Crie um construtor parametrizado que inicialize as variáveis ​​de instância x e y e aceite dois parâmetros do tipo int, x e y.

Etapa 7: Defina uma classe Circle que estenda Shape.

Etapa 8: Adicione uma variável de instância protegida do tipo double chamada radius.

Etapa 9: Defina um construtor parametrizado que usa três parâmetros do tipo int x, y e double radius e inicializa as variáveis ​​de instância x, y e radius usando a palavra-chave super().

Etapa 10: Implemente o método abstrato getArea() calculando a área do Círculo.

Etapa 11: Defina uma classe Square que estenda Shape.

Etapa 12: Adicione uma variável de instância protegida do tipo double nomeado side.

Etapa 13: Defina um construtor parametrizado que usa três parâmetros do tipo int x, y e double side e inicializa as variáveis ​​de instância x, y e side usando a palavra-chave super().

Etapa 14: Implemente o método abstrato getArea() calculando a área do Square.

Etapa 15: Defina uma classe principal.

Etapa 16: Defina um método estático chamado main() que é o ponto de entrada do programa.

Etapa 17: Crie um objeto Circle usando um construtor parametrizado.

Etapa 18: Imprima a área e a posição do objeto Circle usando os métodos getArea() e printPosition() respectivamente.

Etapa 19: Crie um objeto Square usando um construtor parametrizado.

Etapa 20: Imprima a área e a posição do objeto Square usando os métodos getArea() e printPosition() respectivamente.

Etapa 21: Fim do programa.

Implementação:

A implementação das etapas acima mencionadas abaixo

Nome do arquivo: ParametrizadoMain.java

 import java.util.*; abstract class Shape { protected int x; protected int y; // parameterized constructor public Shape(int x,int y) { this.x=x; this.y=y; } // abstract method to calculate area public abstract double getArea(); // other methods public void setPosition(int x,int y) { this.x=x; this.y=y; } public void printPosition() { System.out.println('The position: ('+ x+', ' +y+')'); } } class Circle extends Shape { protected double radius; // parameterized constructor public Circle(int x,int y,double radius) { super(x,y); this.radius=radius; } // implementation of getArea() for Circle public double getArea() { return Math.PI * radius * radius; } } class Square extends Shape { protected double side; // parameterized constructor public Square(int x,int y,double side) { super(x, y); this.side = side; } // implementation of getArea() for Square public double getArea() { return side * side; } } public class ParameterizedMain { public static void main(String args []) { // create a Circle object with parameterized constructor Circle circle = new Circle(2, 3, 5); // print the area and position of the Circle object System.out.println('Area of circle is: '+circle.getArea()); circle.printPosition(); // create a Square object with parameterized constructor Square square = new Square(5, 7, 4); // print the area and position of the Square object System.out.println('Area of square is:' +square.getArea()); square.printPosition(); } } 

Saída:

 Area of circle is: 78.53981633974483 The position: (2, 3) Area of square is:16.0 The position: (5, 7) 

3. Copiar construtor: O construtor de cópia é usado para criar um novo objeto com valores iguais a um objeto existente (ou seja, o item é criado antes). É útil enquanto precisamos criar um novo objeto que pode ser uma réplica de um objeto que já está presente/existia. O construtor de cópia é definido com apenas um argumento ou parâmetro que é um item de classe idêntica. Em seguida, o construtor cria um novo objeto com os mesmos valores de um objeto de parâmetro.

ALGORITMO:

Passo 1: Declare uma classe abstrata com variáveis ​​de instância e construtor padrão.

Passo 2: Defina um construtor de cópia com um parâmetro de tipo de classe idêntico.

Etapa 3: No construtor de cópia, chame o construtor de cópia da superclasse usando a palavra-chave super para copiar as variáveis ​​de instância do objeto de parâmetro para o novo objeto.

Passo 4: Atribua os valores de quaisquer variáveis ​​de instância extras dentro da subclasse ao novo item.

Etapa 5: Implemente o método abstrato para calcular a área.

Etapa 6: Defina quaisquer outros métodos conforme necessário.

Etapa 7: Na função principal, crie um objeto da classe.

jframe

Etapa 8: Defina a posição e quaisquer outras variáveis ​​de instância conforme necessário.

Etapa 9: Crie um novo objeto usando o construtor de cópia e passando o item original como parâmetro.

Etapa 10: Imprima a área e a posição dos objetos originais e copiados.

Implementação:

A implementação das etapas acima é fornecida abaixo

Nome do arquivo: CopiarMain.java

 import java.util.*; abstract class Shape { protected int x; protected int y; // copy constructor public Shape(Shape other) { this.x=other.x; this.y=other.y; } // default constructor public Shape() { // initialize default values for fields x=0; y=0; } // abstract method to calculate area public abstract double getArea(); // other methods public void setPosition(int x,int y) { this.x =x; this.y =y; } public void printPosition() { System.out.println('Position: (' +x+ ', ' +y+ ')'); } } class Circle extends Shape { protected double radius; // copy constructor public Circle(Circle other) { super(other); this.radius =other.radius; } // constructor public Circle(double radius) { this.radius =radius; } // implementation of getArea() for Circle public double getArea() { return Math.PI * radius * radius; } } class Square extends Shape { protected double side; // copy constructor public Square(Square other) { super(other); this.side =other.side; } // constructor public Square(double side) { this.side=side; } // implementation of getArea() for Square public double getArea() { return side * side; } } public class CopyMain { public static void main(String[] args) { // create a Circle object Circle circle1 = new Circle(5); circle1.setPosition(2,3); // create a copy of the Circle object using the copy constructor Circle circle2 = new Circle(circle1); // print the area and position of the original and copied Circle objects System.out.println('Original Area of circle: ' +circle1.getArea()); circle1.printPosition(); System.out.println('Copied Area of circle: '+circle2.getArea()); circle2.printPosition(); // create a Square object Square square1 =new Square(4); square1.setPosition(5,7); // create a copy of the Square object using the copy constructor Square square2 = new Square(square1); // print the area and position of the original and copied Square objects System.out.println('Original Area of square: '+square1.getArea()); square1.printPosition(); System.out.println('Copied Area of square: '+square2.getArea()); square2.printPosition(); } } 

Saída:

 Original Area of circle: 78.53981633974483 Position: (2, 3) Copied Area of circle: 78.53981633974483 Position: (2, 3) Original Area of square: 16.0 Position: (5, 7) Copied Area of square: 16.0 Position: (5, 7)