Une classe abstraite en Java est une classe qui ne peut pas être instanciée directement. Le but est d’agir comme une classe de base dont les autres classes pourraient hériter et s’étendre. L'une des caractéristiques importantes d'une classe abstraite est sa capacité à définir les constructeurs, appelés méthodes spéciales et qui sont invoqués lors de la création d'un objet d'une classe.
Règles à suivre lors de la définition des constructeurs dans une classe abstraite :
- Les classes abstraites peuvent avoir des constructeurs, mais elles ne peuvent pas être instanciées directement. Les constructeurs sont utilisés lorsqu'une sous-classe concrète est créée.
- Il peut y avoir une ou plusieurs méthodes abstraites dans une classe abstraite, ce qui signifie que ces méthodes ne sont pas implémentées au moyen de la classe. Pour être instanciée, une sous-classe qui étend une classe abstraite avec des méthodes abstraites doit implémenter les méthodes. Cela signifie que chaque méthode abstraite déclarée dans une classe abstraite doit avoir une implémentation si une sous-classe doit être une classe concrète et pouvoir être instanciée. En d’autres termes, la fonctionnalité laissée ouverte par la classe abstraite doit être remplie par la sous-classe.
- Lorsqu'une sous-classe étend une classe abstraite avec des constructeurs, la sous-classe doit appeler l'un des constructeurs à l'intérieur de la superclasse à l'aide d'un super mot-clé. Parce que le constructeur de la superclasse initialise l'état de l'objet et regroupe toutes les ressources vitales. Si la sous-classe n'appelle plus l'un des constructeurs de la superclasse, l'objet ne sera pas bien initialisé et ne fonctionnera plus efficacement/correctement.
- Il est possible de définir plusieurs constructeurs dans une classe abstraite, similaire à une autre classe. Cependant, chaque constructeur doit être défini avec une liste de paramètres différente. Il permet aux sous-classes de sélectionner le constructeur à appeler en fonction de leurs besoins spécifiques.
Types de constructeurs implémentés à l'aide de la classe abstraite :
Il existe trois types de constructeurs :
- Constructeur par défaut
- Constructeur paramétré
- Copier le constructeur
1. Constructeur par défaut : Le constructeur est automatiquement créé via Java si aucun autre constructeur n'est défini dans la classe. Il n'a aucun paramètre et n'effectue aucun déplacement en dehors de l'initialisation des valeurs par défaut pour les champs de classe.
ALGORITHME:
Étape 1: Définissez une classe abstraite nommée « Shape ».
Étape 2: Déclarez deux variables entières 'x' et 'y' comme protégées.
Étape 3: Créez un constructeur par défaut de classe Shape et définissez « x » et « y » sur 0.
Étape 4: Créez maintenant une méthode 'getArea()' c'est une méthode abstraite qui va renvoyer une valeur double
Étape 5 : Créez ensuite deux méthodes non abstraites 'printPosition()' et 'setPosition(int x, int y)' qui appartiennent à la classe Shape.
Étape 6 : La méthode setPosition définit les valeurs de x et y.
Étape 7 : La méthode printPosition imprime les valeurs de x et y.
Étape 8 : Définissez une classe Circle qui étend la classe Shape.
Étape 9 : Déclarez une variable double nommée 'radius' comme protégée dans la classe Circle.
Étape 10 : Définissez un constructeur pour la classe Circle qui accepte une valeur double pour le rayon.
nom des caractères spéciaux
Étape 11 : Implémentez la méthode getArea pour la classe Circle qui calcule l'aire du cercle.
Étape 12 : Définissez une classe Square qui étend la classe Shape.
Étape 13 : Déclarez une variable double nommée 'side' comme protégée dans la classe Square.
Étape 14 : Définissez un constructeur pour la classe Square qui accepte une valeur double pour le côté.
Étape 15 : Implémentez la méthode getArea pour la classe Square qui calcule l'aire du carré.
Étape 16 : Définissez une classe principale.
Étape 17 : Définissez la fonction principale dans la classe Main.
Étape 18 : Créez un objet Cercle et un objet Carré.
Étape 19 : Appelez la méthode setPosition pour les objets Circle et Square.
Étape 20 : Appelez la méthode getArea pour les objets Circle et Square et imprimez les résultats.
Étape 21 : Appelez la méthode printPosition pour les objets Circle et Square et imprimez les résultats.
Mise en œuvre:
Voici la mise en œuvre des étapes ci-dessus
Nom de fichier: 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(); } } Sortir:
Area of a circle is: 78.53981633974483 The Position:(2, 3) Area of a square is: 16.0 The Position:(5, 7)
2. Constructeur paramétré : Lors de la création d'un objet, ce type de constructeur permet de lui passer des arguments. Lorsque vous souhaitez initialiser l'objet avec des valeurs, cela est utile. Le constructeur paramétré est défini avec un ou plusieurs paramètres supplémentaires, et lors de la création d'un objet, les valeurs transmises au constructeur sont utilisées pour initialiser les champs correspondants de l'élément.
ALGORITHME:
Étape 1: Définissez une classe abstraite Shape.
chaîne et sous-chaîne
Étape 2: Ajoutez deux variables d'instance protégées de type int nommées x et y.
Étape 3: Créez un constructeur paramétré qui initialise les variables d'instance x et y et accepte deux paramètres de type int, x et y.
Étape 4: Définissez une classe abstraite Shape.
Étape 5 : Ajoutez deux variables d'instance protégées de type int nommées x et y.
Étape 6 : Créez un constructeur paramétré qui initialise les variables d'instance x et y et accepte deux paramètres de type int, x et y.
Étape 7 : Définissez une classe Circle qui étend Shape.
Étape 8 : Ajoutez une variable d'instance protégée de type rayon à double nom.
Étape 9 : Définissez un constructeur paramétré qui prend trois paramètres de type int x, y et double radius et initialise les variables d'instance x, y et radius à l'aide du mot-clé super().
Étape 10 : Implémentez la méthode abstraite getArea() en calculant l'aire du cercle.
Étape 11 : Définissez une classe Square qui étend Shape.
Étape 12 : Ajoutez une variable d'instance protégée de type double côté nommé.
Étape 13 : Définissez un constructeur paramétré qui prend trois paramètres de type int x, y et double side et initialise les variables d'instance x, y et side à l'aide du mot-clé super().
Étape 14 : Implémentez la méthode abstraite getArea() en calculant l'aire de Square.
Étape 15 : Définissez une classe Main.
Étape 16 : Définissez une méthode statique nommée main() qui est le point d'entrée du programme.
Étape 17 : Créez un objet Circle à l'aide d'un constructeur paramétré.
Étape 18 : Imprimez la zone et la position de l'objet Circle en utilisant respectivement les méthodes getArea() et printPosition().
Étape 19 : Créez un objet Square à l'aide d'un constructeur paramétré.
Étape 20 : Imprimez la zone et la position de l'objet Square en utilisant respectivement les méthodes getArea() et printPosition().
Étape 21 : Fin du programme.
Mise en œuvre:
La mise en œuvre des étapes ci-dessus mentionnées ci-dessous
Nom de fichier: ParamétréMain.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(); } } Sortir:
Area of circle is: 78.53981633974483 The position: (2, 3) Area of square is:16.0 The position: (5, 7)
3. Copier le constructeur : Le constructeur de copie est utilisé pour créer un nouvel objet avec les mêmes valeurs qu'un objet existant (c'est-à-dire que l'élément est créé avant). C'est utile lorsque nous devons créer un nouvel objet qui peut être une réplique d'un objet déjà présent/existé. Le constructeur de copie est défini avec un seul argument ou un seul paramètre qui est un élément de classe identique. Ensuite, le constructeur crée un nouvel objet avec les mêmes valeurs qu'un objet paramètre.
ALGORITHME:
Étape 1: Déclarez une classe abstraite avec des variables d'instance et un constructeur par défaut.
Étape 2: Définissez un constructeur de copie avec un paramètre du type de classe identique.
types de tests
Étape 3: Dans le constructeur de copie, appelez le constructeur de copie de superclasse à l'aide du mot-clé super pour copier les variables d'instance de l'objet paramètre vers le nouvel objet.
Étape 4: Attribuez les valeurs de toutes les variables d'instance supplémentaires de la sous-classe au nouvel élément.
Étape 5 : Implémentez la méthode abstraite pour calculer la superficie.
Étape 6 : Définissez toute autre méthode si nécessaire.
Étape 7 : Dans la fonction principale, créez un objet de la classe.
Étape 8 : Définissez la position et toute autre variable d'instance si nécessaire.
Étape 9 : Créez un nouvel objet en utilisant le constructeur de copie et en passant l'élément d'origine en tant que paramètre.
Étape 10 : Imprimez la zone et la position des objets originaux et copiés.
Mise en œuvre:
La mise en œuvre des étapes ci-dessus est indiquée ci-dessous
Nom de fichier: CopierMain.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(); } } Sortir:
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)