Una clase abstracta en Java es una clase de la que no se puede crear una instancia directamente. El objetivo de esto es actuar como una clase base de la cual las otras clases pueden heredar y extenderse. Una de las características importantes de una clase abstracta es la capacidad de definir los constructores, que se conocen como métodos especiales y que se invocan cuando se crea un objeto de una clase.
Reglas a seguir al definir constructores en una clase abstracta:
- Las clases abstractas pueden tener constructores, pero no se pueden crear instancias de ellas directamente. Los constructores se utilizan cuando se crea una subclase concreta.
- Puede haber uno o más métodos abstractos en una clase abstracta, lo que significa que esos métodos no se implementan mediante la clase. Para crear una instancia, una subclase que extiende una clase abstracta con métodos abstractos debe implementar los métodos. Significa que cada método abstracto declarado dentro de una clase abstracta debe tener una implementación si una subclase necesita ser una clase concreta y poder ser instanciada. En otras palabras, la subclase debe completar la funcionalidad que la clase abstracta dejó abierta.
- Cuando una subclase extiende una clase abstracta con constructores, la subclase necesita llamar a uno de los constructores dentro de la superclase con la ayuda de una superpalabra clave. Porque el constructor de la superclase inicializa el estado del objeto y agrupa los recursos vitales. Si la subclase ahora no llama a uno de los constructores de la superclase, el objeto no estará bien inicializado y no funcionará de manera eficiente/correcta.
- Es factible definir más de un constructor en una clase abstracta, similar a alguna otra clase. Sin embargo, cada constructor debe definirse con una lista de parámetros diferente. Permite que las subclases elijan a qué constructor llamar en función de sus necesidades específicas.
Tipos de constructores implementados usando la clase abstracta:
Hay tres tipos de constructores:
- Constructor predeterminado
- Constructor parametrizado
- Constructor de copias
1. Constructor predeterminado: El constructor se crea automáticamente a través de Java si no se define ningún otro constructor en la clase. No tiene parámetros y no realiza ningún movimiento aparte de inicializar los valores predeterminados para los campos de clase.
ALGORITMO:
Paso 1: Defina una clase abstracta llamada 'Forma'.
Paso 2: Declare dos variables enteras 'x' e 'y' como protegidas.
Paso 3: Cree un constructor predeterminado de clase Shape y establezca 'x' e 'y' en 0.
Etapa 4: Ahora cree un método 'getArea()', es un método abstracto que devolverá un valor doble.
Paso 5: Luego cree dos métodos no abstractos 'printPosition()' y 'setPosition(int x, int y)' que pertenecen a la clase Shape.
Paso 6: El método setPosition establece los valores de xey.
Paso 7: El método printPosition imprime los valores de xey.
Paso 8: Defina una clase Círculo que extienda la clase Forma.
Paso 9: Declare una variable doble llamada 'radio' como protegida en la clase Círculo.
Paso 10: Defina un constructor para la clase Círculo que acepte un valor doble para el radio.
Paso 11: Implemente el método getArea para la clase Circle que calcula el área del círculo.
Paso 12: Defina una clase Cuadrado que extienda la clase Forma.
Paso 13: Declare una variable doble llamada 'lado' como protegida en la clase Square.
Paso 14: Defina un constructor para la clase Square que acepte un valor doble para el lado.
Paso 15: Implemente el método getArea para la clase Square que calcula el área del cuadrado.
Paso 16: Defina una clase principal.
Paso 17: Defina la función principal en la clase Main.
Paso 18: Crea un objeto Círculo y un objeto Cuadrado.
Paso 19: Llame al método setPosition para los objetos Círculo y Cuadrado.
Paso 20: Llame al método getArea para los objetos Círculo y Cuadrado e imprima los resultados.
Paso 21: Llame al método printPosition para los objetos Círculo y Cuadrado e imprima los resultados.
Implementación:
Aquí está la implementación de los pasos anteriores.
Nombre del archivo: DefaultMain.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(); } } Producción:
Area of a circle is: 78.53981633974483 The Position:(2, 3) Area of a square is: 16.0 The Position:(5, 7)
2. Constructor parametrizado: Al crear un objeto, este tipo de constructor le permite pasarle argumentos. Cuando desee inicializar el objeto con valores, resulta útil. El constructor parametrizado se define con uno o más parámetros y, mientras se crea un objeto, los valores pasados al constructor se utilizan para inicializar los campos correspondientes del elemento.
ALGORITMO:
Paso 1: Defina una clase abstracta Forma.
Paso 2: Agregue dos variables de instancia protegidas de tipo int denominadas x e y.
Paso 3: Cree un constructor parametrizado que inicialice las variables de instancia xey y acepte dos parámetros de tipo int, xey.
Etapa 4: Defina una clase abstracta Forma.
ssh forma completa
Paso 5: Agregue dos variables de instancia protegidas de tipo int denominadas x e y.
Paso 6: Cree un constructor parametrizado que inicialice las variables de instancia xey y acepte dos parámetros de tipo int, xey.
Paso 7: Defina una clase Círculo que extienda Forma.
Paso 8: Agregue una variable de instancia protegida de tipo radio con doble nombre.
Paso 9: Defina un constructor parametrizado que tome tres parámetros de tipo int x, y y radio doble e inicialice las variables de instancia x, y y radio usando la palabra clave super().
Paso 10: Implemente el método abstracto getArea() calculando el área del círculo.
Paso 11: Defina una clase Cuadrado que extienda Forma.
Paso 12: Agregue una variable de instancia protegida de tipo lado con doble nombre.
Paso 13: Defina un constructor parametrizado que tome tres parámetros de tipo int x, y y double side e inicialice las variables de instancia x, y y side usando la palabra clave super().
Paso 14: Implemente el método abstracto getArea() calculando el área de Square.
Paso 15: Defina una clase principal.
Paso 16: Defina un método estático llamado main() que es el punto de entrada del programa.
seleccione sql de varias tablas
Paso 17: Cree un objeto Círculo usando un constructor parametrizado.
Paso 18: Imprima el área y la posición del objeto Círculo usando los métodos getArea() y printPosition() respectivamente.
Paso 19: Cree un objeto Square usando un constructor parametrizado.
Paso 20: Imprima el área y la posición del objeto Square usando los métodos getArea() y printPosition() respectivamente.
Paso 21: Fin del programa.
Implementación:
La implementación de los pasos anteriores que se mencionan a continuación.
Nombre del archivo: ParameterizedMain.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(); } } Producción:
Area of circle is: 78.53981633974483 The position: (2, 3) Area of square is:16.0 The position: (5, 7)
3. Copiar constructor: El constructor de copia se utiliza para crear un nuevo objeto con los mismos valores que un objeto existente (es decir, el elemento se creó antes). Es útil cuando necesitamos crear un nuevo objeto que puede ser una réplica de un objeto que ya está presente/existía. El constructor de copia se define con un solo argumento o un parámetro que es un elemento de clase idéntica. Luego, el constructor crea un nuevo objeto con los mismos valores que un objeto de parámetro.
ALGORITMO:
Paso 1: Declare una clase abstracta con variables de instancia y constructor predeterminado.
Paso 2: Defina un constructor de copia con un parámetro del mismo tipo de clase.
Paso 3: En el constructor de copia, llame al constructor de copia de superclase usando la palabra clave super para copiar las variables de instancia del objeto de parámetro al nuevo objeto.
Etapa 4: Asigne los valores de cualquier variable de instancia adicional dentro de la subclase al nuevo elemento.
Paso 5: Implemente el método abstracto para calcular el área.
Paso 6: Defina cualquier otro método según sea necesario.
Paso 7: En la función principal, crea un objeto de la clase.
Paso 8: Establezca la posición y cualquier otra variable de instancia según sea necesario.
Paso 9: Cree un nuevo objeto utilizando el constructor de copia y pasando el elemento original como parámetro.
Paso 10: Imprima el área y la posición de los objetos originales y copiados.
Implementación:
La implementación de los pasos anteriores se detalla a continuación.
Nombre del archivo: CopyMain.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(); } } Producción:
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)