Una classe abstracta a Java és una classe que no es pot crear una instancia directament. L'objectiu d'això és actuar com una classe base de la qual les altres classes podrien heretar i estendre's. Una de les característiques importants que una classe abstracta té la capacitat de definir els constructors, que es coneixen com a mètodes especials i que s'invoquen quan es crea un objecte d'una classe.

Regles a seguir per definir constructors en una classe abstracta:

1. Les classes abstractes poden tenir constructors, però no es poden instanciar directament. Els constructors s'utilitzen quan es crea una subclasse concreta.
2. Hi pot haver un o més mètodes abstractes en una classe abstracta, la qual cosa significa que aquests mètodes no s'implementen mitjançant la classe. Per ser instància, una subclasse que amplia una classe abstracta amb mètodes abstractes hauria d'implementar els mètodes. Significa que cada mètode abstracte declarat dins d'una classe abstracta ha de tenir una implementació si una subclasse ha de ser una classe concreta i poder ser instanciada. En altres paraules, la funcionalitat que la classe abstracta va deixar oberta l'ha d'omplir la subclasse.
3. Quan una subclasse amplia una classe abstracta amb constructors, la subclasse ha de cridar a un dels constructors dins de la superclasse amb l'ajuda de la paraula clau super. Perquè el constructor de la superclasse inicialitza l'estat de l'objecte i unifica tots els recursos vitals. Si ara la subclasse no crida a un dels constructors de la superclasse, l'objecte no estarà ben inicialitzat i ara no funcionarà correctament/eficiència.
4. És factible definir més d'un constructor en una classe abstracta, de manera similar a alguna altra classe. Tanmateix, cada constructor s'ha de definir amb una llista de paràmetres diferent. Permet entrar subclasses per escollir quin constructor cridar en funció de les seves necessitats específiques.

Tipus de constructors implementats mitjançant la classe abstracta:

Hi ha tres tipus de constructors que hi ha:

1. Constructor per defecte
2. Constructor parametritzat
3. Copia el constructor

1. Constructor per defecte: El constructor es crea automàticament mitjançant Java si no hi ha cap altre constructor definit a la classe. No té paràmetres i no realitza cap moviment a part d'inicialitzar els valors predeterminats per als camps de classe.

ALGORITME:

Pas 1: Definiu una classe abstracta anomenada 'Shape'.

Pas 2: Declara dues variables senceres 'x' i 'y' com a protegides.

Pas 3: Creeu un constructor per defecte de la classe Shape i poseu 'x' i 'y' a 0.

Pas 4: Ara creeu un mètode 'getArea()', és un mètode abstracte que retornarà un valor doble

Pas 5: A continuació, creeu dos mètodes no abstractes 'printPosition()' i 'setPosition(int x, int y)' que pertanyen a la classe Shape.

Pas 6: El mètode setPosition estableix els valors de x i y.

Pas 7: El mètode printPosition imprimeix els valors de x i y.

Pas 8: Definiu una classe Circle que amplia la classe Shape.

Pas 9: Declara una variable doble anomenada 'radius' com a protegida a la classe Circle.

Pas 10: Definiu un constructor per a la classe Circle que accepti un valor doble per al radi.

Pas 11: Implementeu el mètode getArea per a la classe Circle que calcula l'àrea del cercle.

Pas 12: Definiu una classe Square que amplia la classe Shape.

Pas 13: Declara una variable doble anomenada 'costat' com a protegida a la classe Square.

Pas 14: Definiu un constructor per a la classe Square que accepti un valor doble per al costat.

Pas 15: Implementeu el mètode getArea per a la classe Square que calcula l'àrea del quadrat.

Pas 16: Definiu una classe principal.

Pas 17: Definiu la funció principal a la classe Main.

Pas 18: Creeu un objecte Cercle i un objecte Quadrat.

Pas 19: Truqueu al mètode setPosition tant per als objectes Circle com Square.

Pas 20: Truqueu al mètode getArea tant per als objectes Circle com Square i imprimiu els resultats.

Pas 21: Truqueu al mètode printPosition tant per als objectes Circle com Square i imprimiu els resultats.

Implementació:

Aquí teniu la implementació dels passos anteriors

Nom de l'arxiu: 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(); } } 

Sortida:

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

2. Constructor parametritzat: Quan creeu un objecte, aquest tipus de constructor us permet passar-li arguments. Quan voleu inicialitzar l'objecte amb valors, és útil. El constructor parametritzat es defineix amb un o paràmetres addicionals, i mentre es crea un objecte, els valors passats al constructor s'utilitzen per inicialitzar els camps corresponents de l'element.

ALGORITME:

Pas 1: Definiu una classe abstracta Shape.

Pas 2: Afegiu dues variables d'instància protegides de tipus int anomenades x i y.

Pas 3: Creeu un constructor parametritzat que inicialitzi les variables d'instància x i y i accepti dos paràmetres de tipus int, x i y.

Pas 4: Definiu una classe abstracta Shape.

Pas 5: Afegiu dues variables d'instància protegides de tipus int anomenades x i y.

pitó tupla ordenat

Pas 6: Creeu un constructor parametritzat que inicialitzi les variables d'instància x i y i accepti dos paràmetres de tipus int, x i y.

Pas 7: Defineix un cercle de classe que allarga la forma.

Pas 8: Afegiu una variable d'instància protegida del tipus radi amb nom doble.

Pas 9: Definiu un constructor parametritzat que prengui tres paràmetres de tipus int x, y i double radius i inicialitzi les variables d'instància x, y i radius mitjançant la paraula clau super().

Pas 10: Implementeu el mètode abstracte getArea() calculant l'àrea de Circle.

Pas 11: Definiu una classe Square que s'estén Shape.

Pas 12: Afegiu una variable d'instància protegida del tipus doble costat amb nom.

Pas 13: Definiu un constructor parametritzat que prengui tres paràmetres de tipus int x, y i doble cara i que inicialitzi les variables d'instància x, y i side mitjançant la paraula clau super().

Pas 14: Implementeu el mètode abstracte getArea() calculant l'àrea de Square.

Pas 15: Definiu una classe Main.

Pas 16: Definiu un mètode estàtic anomenat main() que és el punt d'entrada del programa.

Pas 17: Creeu un objecte Circle mitjançant un constructor parametritzat.

Pas 18: Imprimiu l'àrea i la posició de l'objecte Circle mitjançant els mètodes getArea() i printPosition() respectivament.

Pas 19: Creeu un objecte quadrat mitjançant un constructor parametritzat.

operadors en programació Python

Pas 20: Imprimiu l'àrea i la posició de l'objecte Square mitjançant els mètodes getArea() i printPosition() respectivament.

Pas 21: Final del programa.

Implementació:

La implementació dels passos anteriors esmentats a continuació

Nom de l'arxiu: 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(); } } 

Sortida:

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

3. Copia el constructor: El constructor de còpia s'utilitza per crear un objecte nou amb els mateixos valors que un objecte existent (és a dir, l'element es crea abans). És útil mentre necessitem crear un objecte nou que pot ser una rèplica d'un objecte que ja està present/existeix. El constructor de còpia es defineix amb un sol argument o un paràmetre que és un element de classe idèntica. Aleshores, el constructor crea un objecte nou amb els mateixos valors que un objecte paràmetre.

ALGORITME:

Pas 1: Declarar una classe abstracta amb variables d'instància i constructor predeterminat.

Pas 2: Definiu un constructor de còpia amb un paràmetre del tipus de classe idèntic.

Pas 3: Al constructor de còpia, truqueu al constructor de còpia de la superclasse mitjançant la paraula clau super per copiar les variables d'instància de l'objecte paràmetre al nou objecte.

Pas 4: Assigna els valors de qualsevol variable d'instància addicional dins de la subclasse al nou element.

Pas 5: Implementar el mètode abstracte per calcular l'àrea.

Pas 6: Definiu qualsevol altre mètode segons sigui necessari.

Pas 7: A la funció principal, creeu un objecte de la classe.

Pas 8: Definiu la posició i qualsevol altra variable d'instància segons sigui necessari.

Pas 9: Creeu un objecte nou amb l'ús del constructor de còpia i passant l'element original com a paràmetre.

Pas 10: Imprimeix l'àrea i la posició tant de l'original com dels objectes copiats.

Implementació:

A continuació es mostra la implementació dels passos anteriors

Nom de l'arxiu: 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(); } } 

Sortida:

 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)