O clasă abstractă în Java este o clasă care nu poate fi instanțiată direct. Scopul acestui lucru este de a acționa ca o clasă de bază de la care celelalte clase s-ar putea moșteni și extinde. Una dintre caracteristicile importante este că o clasă abstractă are capacitatea de a defini constructorii, care sunt cunoscuți ca metode speciale și care sunt invocate atunci când este creat un obiect al unei clase.
Reguli de urmat la definirea constructorilor într-o clasă abstractă:
- Clasele abstracte pot avea constructori, dar nu pot fi instanțiate direct. Constructorii sunt utilizați atunci când este creată o subclasă concretă.
- Pot exista una sau mai multe metode abstracte într-o clasă abstractă, ceea ce înseamnă că acele metode nu sunt implementate prin intermediul clasei. Pentru a fi instanțiată, o subclasă care extinde o clasă abstractă cu metode abstracte ar trebui să implementeze metodele. Înseamnă că fiecare metodă abstractă declarată într-o clasă abstractă trebuie să aibă o implementare dacă o subclasă trebuie să fie o clasă concretă și să poată fi instanțiată. Cu alte cuvinte, funcționalitatea pe care clasa abstractă a lăsat-o deschisă trebuie completată de subclasă.
- Când o subclasă extinde o clasă abstractă cu constructori, subclasa trebuie să apeleze unul dintre constructorii din interiorul superclasei cu ajutorul super-cuvântului cheie. Deoarece constructorul de superclasă inițializează starea obiectului și unește orice resurse vitale. Dacă subclasa nu apelează acum unul dintre constructorii din superclasă, obiectul nu va fi bine inițializat și acum nu va funcționa eficient/corect.
- Este posibil să se definească mai mult de un constructor într-o clasă abstractă, similar unei alte clase. Cu toate acestea, fiecare constructor trebuie să fie definit cu o listă diferită de parametri. Permite introducerea subclaselor pentru a alege ce constructor să apeleze în funcție de nevoile lor specifice.
Tipuri de constructori implementați folosind Clasa abstractă:
Există trei tipuri de constructori acolo sunt:
- Constructor implicit
- Constructor parametrizat
- Copie constructor
1. Constructor implicit: Constructorul este creat automat prin Java dacă nu este definit niciun alt constructor în clasă. Nu are parametri și nu efectuează nicio mișcare în afară de inițializarea valorilor implicite pentru câmpurile de clasă.
ALGORITM:
Pasul 1: Definiți o clasă abstractă numită „Shape”.
Pasul 2: Declarați două variabile întregi „x” și „y” ca fiind protejate.
Pasul 3: Creați un constructor implicit al clasei Shape și setați „x” și „y” la 0.
dimensiunea textului latex
Pasul 4: Acum creați o metodă „getArea()”, este o metodă abstractă care va returna o valoare dublă
Pasul 5: Apoi creați două metode non-abstracte „printPosition()” și „setPosition(int x, int y)” care aparține clasei Shape.
Pasul 6: Metoda setPosition stabilește valorile lui x și y.
Pasul 7: Metoda printPosition tipărește valorile lui x și y.
Pasul 8: Definiți o clasă Circle care extinde clasa Shape.
Pasul 9: Declarați o variabilă dublă numită „rază” ca fiind protejată în clasa Circle.
Pasul 10: Definiți un constructor pentru clasa Circle care acceptă o valoare dublă pentru rază.
Pasul 11: Implementați metoda getArea pentru clasa Circle care calculează aria cercului.
Pasul 12: Definiți o clasă Square care extinde clasa Shape.
Pasul 13: Declarați o variabilă dublă numită „side” ca fiind protejată în clasa Square.
Pasul 14: Definiți un constructor pentru clasa Square care acceptă o valoare dublă pentru latură.
Pasul 15: Implementați metoda getArea pentru clasa Square care calculează aria pătratului.
Pasul 16: Definiți o clasă principală.
Pasul 17: Definiți funcția principală în clasa Main.
Pasul 18: Creați un obiect Cerc și un obiect Pătrat.
Pasul 19: Apelați metoda setPosition atât pentru obiectele Cerc, cât și pentru Pătrat.
Pasul 20: Apelați metoda getArea atât pentru obiectele Cerc, cât și pentru Pătrat și imprimați rezultatele.
Pasul 21: Apelați metoda printPosition atât pentru obiectele Cerc, cât și pentru Pătrat și imprimați rezultatele.
Implementare:
Iată implementarea pașilor de mai sus
Nume de fișier: 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(); } } Ieșire:
Area of a circle is: 78.53981633974483 The Position:(2, 3) Area of a square is: 16.0 The Position:(5, 7)
2. Constructor parametrizat: Când creați un obiect, acest tip de constructor vă permite să îi transmiteți argumente. Când doriți să inițializați obiectul cu valori, este util. Constructorul parametrizat este definit cu unul sau parametri suplimentari, iar în timp ce un obiect este creat, valorile transmise constructorului sunt folosite pentru a inițializa câmpurile corespunzătoare ale articolului.
ALGORITM:
Pasul 1: Definiți o clasă abstractă Shape.
Pasul 2: Adăugați două variabile de instanță protejate de tip int numite x și y.
Pasul 3: Creați un constructor parametrizat care inițializează variabilele de instanță x și y și acceptă doi parametri de tip int, x și y.
Pasul 4: Definiți o clasă abstractă Shape.
redenumiți un director linux
Pasul 5: Adăugați două variabile de instanță protejate de tip int numite x și y.
Pasul 6: Creați un constructor parametrizat care inițializează variabilele de instanță x și y și acceptă doi parametri de tip int, x și y.
Pasul 7: Definiți o clasă Cerc care extinde Shape.
Pasul 8: Adăugați o variabilă de instanță protejată de tipul dublu numit rază.
Pasul 9: Definiți un constructor parametrizat care preia trei parametri de tip int x, y și double radius și inițializează variabilele de instanță x, y și radius folosind cuvântul cheie super().
Pasul 10: Implementați metoda abstractă getArea() calculând aria lui Circle.
Pasul 11: Definiți o clasă Square care extinde Shape.
Pasul 12: Adăugați o variabilă de instanță protejată de tipul dublu cu nume.
Pasul 13: Definiți un constructor parametrizat care preia trei parametri de tip int x, y și double side și inițializează variabilele de instanță x, y și side folosind cuvântul cheie super().
Pasul 14: Implementați metoda abstractă getArea() calculând aria lui Square.
Pasul 15: Definiți o clasă Main.
Pasul 16: Definiți o metodă statică numită main() care este punctul de intrare al programului.
Pasul 17: Creați un obiect Circle folosind un constructor parametrizat.
Pasul 18: Imprimați aria și poziția obiectului Circle folosind metodele getArea() și, respectiv, printPosition().
Pasul 19: Creați un obiect Square folosind constructorul parametrizat.
Pasul 20: Imprimați aria și poziția obiectului Square folosind metodele getArea() și, respectiv, printPosition().
Pasul 21: Sfârșitul programului.
Implementare:
Implementarea pașilor de mai sus menționați mai jos
Nume de fișier: 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(); } } Ieșire:
Area of circle is: 78.53981633974483 The position: (2, 3) Area of square is:16.0 The position: (5, 7)
3. Copiați constructorul: constructorul de copiere este utilizat pentru a crea un obiect nou cu valori egale ca un obiect existent (adică, elementul este creat mai devreme). Este util în timp ce trebuie să creăm un nou obiect care poate fi o replică a unui obiect care este deja prezent/existat. Constructorul de copiere este definit cu un singur argument sau un parametru care este un element de clasă identică. Apoi constructorul creează un nou obiect cu aceleași valori ca un obiect parametru.
ALGORITM:
Pasul 1: Declarați o clasă abstractă cu variabile de instanță și constructor implicit.
Pasul 2: Definiți un constructor de copiere cu un parametru de tip de clasă identic.
Pasul 3: În constructorul de copiere, apelați constructorul de copiere a superclasei folosind cuvântul cheie super pentru a copia variabilele de instanță din obiectul parametru în noul obiect.
Pasul 4: Atribuiți noului element valorile oricăror variabile de instanță suplimentare din subclasă.
Pasul 5: Implementați metoda abstractă pentru a calcula suprafața.
listbox html
Pasul 6: Definiți orice alte metode după cum este necesar.
Pasul 7: În funcția principală, creați un obiect al clasei.
Pasul 8: Setați poziția și orice alte variabile de instanță, după cum este necesar.
Pasul 9: Creați un nou obiect utilizând constructorul de copiere și trecând elementul original ca parametru.
Pasul 10: Imprimați zona și poziția obiectelor originale și copiate.
Implementare:
Implementarea pașilor de mai sus este prezentată mai jos
Nume de fișier: 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(); } } Ieșire:
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)