Una classe astratta in Java è una classe di cui non è possibile istanziare direttamente. L'obiettivo è quello di agire come una classe base da cui le altre classi potrebbero ereditare ed estendere. Una delle caratteristiche importanti di una classe astratta è la capacità di definire i costruttori, che sono noti come metodi speciali e che vengono invocati quando viene creato un oggetto di una classe.
Regole da seguire durante la definizione dei costruttori in una classe astratta:
- Le classi astratte possono avere costruttori, ma non possono essere istanziate direttamente. I costruttori vengono utilizzati quando viene creata una sottoclasse concreta.
- Potrebbero esserci uno o più metodi astratti in una classe astratta, il che significa che tali metodi non sono implementati tramite la classe. Per essere istanziata, una sottoclasse che estende una classe astratta con metodi astratti dovrebbe implementare i metodi. Ciò significa che ogni metodo astratto dichiarato all'interno di una classe astratta deve avere un'implementazione se una sottoclasse deve essere una classe concreta e poter essere istanziata. In altre parole, la funzionalità lasciata aperta dalla classe astratta deve essere riempita dalla sottoclasse.
- Quando una sottoclasse estende una classe astratta con costruttori, la sottoclasse deve chiamare uno dei costruttori all'interno della superclasse con l'aiuto della parola chiave super. Perché il costruttore della superclasse inizializza lo stato dell'oggetto e unisce tutte le risorse vitali. Se la sottoclasse ora non chiama uno dei costruttori della superclasse, l'oggetto non sarà inizializzato correttamente e non funzionerà in modo efficiente/corretto.
- È possibile definire più di un costruttore in una classe astratta, simile a qualche altra classe. Tuttavia, ciascun costruttore deve essere definito con un elenco di parametri diverso. Consente alle sottoclassi di scegliere quale costruttore chiamare in base alle loro esigenze specifiche.
Tipi di costruttori implementati utilizzando la classe astratta:
Esistono tre tipi di costruttori, eccoli:
- Costruttore predefinito
- Costruttore parametrizzato
- Copia costruttore
1. Costruttore predefinito: Il costruttore viene creato automaticamente tramite Java se nella classe non è definito nessun altro costruttore. Non ha parametri e non esegue alcuna mossa oltre all'inizializzazione dei valori predefiniti per i campi della classe.
ALGORITMO:
Passo 1: Definire una classe astratta denominata 'Shape'.
Passo 2: Dichiara due variabili intere 'x' e 'y' come protette.
Passaggio 3: Crea un costruttore predefinito della classe Shape e imposta 'x' e 'y' su 0.
Passaggio 4: Ora crea un metodo 'getArea()' è un metodo astratto che restituirà un doppio valore
finestra.apri javascript
Passaggio 5: Quindi crea due metodi non astratti 'printPosition()' e 'setPosition(int x, int y)' che appartengono alla classe Shape.
Passaggio 6: Il metodo setPosition imposta i valori di x e y.
Passaggio 7: Il metodo printPosition stampa i valori di x e y.
Passaggio 8: Definire una classe Circle che estende la classe Shape.
Passaggio 9: Dichiara una doppia variabile denominata 'raggio' come protetta nella classe Circle.
Passaggio 10: Definire un costruttore per la classe Circle che accetta un valore doppio per il raggio.
Passaggio 11: Implementa il metodo getArea per la classe Circle che calcola l'area del cerchio.
Passaggio 12: Definire una classe Square che estende la classe Shape.
Passaggio 13: Dichiara una variabile doppia denominata 'side' come protetta nella classe Square.
Passaggio 14: Definire un costruttore per la classe Square che accetta un valore double per il lato.
Passaggio 15: Implementa il metodo getArea per la classe Square che calcola l'area del quadrato.
Passaggio 16: Definire una classe principale.
numero da stringare java
Passaggio 17: Definire la funzione principale nella classe Main.
Passaggio 18: Crea un oggetto Cerchio e un oggetto Quadrato.
Passaggio 19: Chiama il metodo setPosition sia per gli oggetti Circle che per quelli Square.
Passaggio 20: Chiama il metodo getArea sia per gli oggetti Circle che per Square e stampa i risultati.
Passaggio 21: Chiama il metodo printPosition sia per gli oggetti Circle che per Square e stampa i risultati.
Implementazione:
Ecco l'implementazione dei passaggi precedenti
Nome del file: 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(); } } Produzione:
Area of a circle is: 78.53981633974483 The Position:(2, 3) Area of a square is: 16.0 The Position:(5, 7)
2. Costruttore parametrizzato: Quando si crea un oggetto, questo tipo di costruttore consente di passargli argomenti. Quando desideri inizializzare l'oggetto con valori, è utile. Il costruttore parametrizzato viene definito con uno o più parametri e, durante la creazione di un oggetto, i valori passati al costruttore vengono utilizzati per inizializzare i campi corrispondenti dell'elemento.
ALGORITMO:
Passo 1: Definire una classe astratta Shape.
Passo 2: Aggiungi due variabili di istanza protette di tipo int denominate x e y.
Passaggio 3: Creare un costruttore con parametri che inizializzi le variabili di istanza x e y e accetti due parametri di tipo int, x e y.
Passaggio 4: Definire una classe astratta Shape.
Passaggio 5: Aggiungi due variabili di istanza protette di tipo int denominate x e y.
Passaggio 6: Creare un costruttore con parametri che inizializzi le variabili di istanza x e y e accetti due parametri di tipo int, x e y.
Passaggio 7: Definire una classe Circle che estende Shape.
Passaggio 8: Aggiungi una variabile di istanza protetta di tipo double denominata raggio.
Passaggio 9: Definire un costruttore parametrizzato che accetta tre parametri di tipo int x, y e double raggio e inizializza le variabili di istanza x, y e raggio utilizzando la parola chiave super().
Passaggio 10: Implementa il metodo astratto getArea() calcolando l'area del Cerchio.
Passaggio 11: Definire una classe Square che estende Shape.
I comandi Linux creano la cartella
Passaggio 12: Aggiungi una variabile di istanza protetta di tipo double name side.
Passaggio 13: Definire un costruttore parametrizzato che accetta tre parametri di tipo int x, y e double side e inizializza le variabili di istanza x, y e side utilizzando la parola chiave super().
Passaggio 14: Implementa il metodo astratto getArea() calcolando l'area di Square.
Passaggio 15: Definire una classe Main.
Passaggio 16: Definire un metodo statico denominato main() che è il punto di ingresso del programma.
Passaggio 17: Crea un oggetto Circle utilizzando il costruttore parametrizzato.
Passaggio 18: Stampa l'area e la posizione dell'oggetto Circle utilizzando rispettivamente i metodi getArea() e printPosition().
Passaggio 19: Crea un oggetto Square utilizzando il costruttore con parametri.
Passaggio 20: Stampa l'area e la posizione dell'oggetto Square utilizzando rispettivamente i metodi getArea() e printPosition().
Passaggio 21: Fine del programma.
Implementazione:
L'implementazione dei passaggi precedenti menzionati di seguito
Nome del file: ParametrizzatoMain.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(); } } Produzione:
Area of circle is: 78.53981633974483 The position: (2, 3) Area of square is:16.0 The position: (5, 7)
3. Copia costruttore: il costruttore di copia viene utilizzato per creare un nuovo oggetto con gli stessi valori di un oggetto esistente (ovvero, l'elemento viene creato prima). È utile quando dobbiamo creare un nuovo oggetto che potrebbe essere una replica di un oggetto già presente/esisteva. Il costruttore di copie è definito con un solo argomento o un parametro che è un elemento di classe identica. Quindi il costruttore crea un nuovo oggetto con gli stessi valori di un oggetto parametro.
ALGORITMO:
classe vs oggetto in Java
Passo 1: Dichiara una classe astratta con variabili di istanza e costruttore predefinito.
Passo 2: Definire un costruttore di copie con un parametro dello stesso tipo di classe.
Passaggio 3: Nel costruttore di copie, chiama il costruttore di copie della superclasse utilizzando la parola chiave super per copiare le variabili di istanza dall'oggetto parametro al nuovo oggetto.
Passaggio 4: Assegnare i valori di eventuali variabili di istanza aggiuntive all'interno della sottoclasse al nuovo elemento.
Passaggio 5: Implementare il metodo astratto per calcolare l'area.
Passaggio 6: Definire eventuali altri metodi secondo necessità.
Passaggio 7: Nella funzione principale, crea un oggetto della classe.
Passaggio 8: Imposta la posizione e qualsiasi altra variabile di istanza secondo necessità.
Passaggio 9: Crea un nuovo oggetto utilizzando il costruttore di copia e passando l'elemento originale come parametro.
Passaggio 10: Stampa l'area e la posizione sia degli oggetti originali che di quelli copiati.
Implementazione:
L'implementazione dei passaggi precedenti è riportata di seguito
Nome del file: CopiaMain.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(); } } Produzione:
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)