Constructeurs Java

Constructeurs Java :

Les constructeurs Java ou constructeurs en Java sont une terminologie utilisée pour construire quelque chose dans nos programmes. Un constructeur en Java est une méthode spéciale utilisée pour initialiser des objets. Le constructeur est appelé lorsqu'un objet d'une classe est créé. Il peut être utilisé pour définir les valeurs initiales des attributs d'objet.

Que sont les constructeurs en Java ? :

En Java, un Constructeur est un bloc de codes similaire à la méthode. Il est appelé lorsqu'une instance de la classe est créée. Au moment de l'appel du constructeur, la mémoire de l'objet est allouée dans la mémoire. Il s'agit d'un type spécial de méthode utilisée pour initialiser l'objet. Chaque fois qu'un objet est créé à l'aide du mot-clé new(), au moins un constructeur est appelé.

Comprendre comment utiliser efficacement les constructeurs peut améliorer considérablement vos compétences en programmation Java, en particulier lorsque vous avez affaire à des applications complexes. Il est crucial de saisir les nuances des constructeurs pour créer des logiciels évolutifs et maintenables.

Exemple de constructeur Java :

// Driver Class
class Geeks {

    // Constructor
    Geeks()
    {
        super();
        System.out.println("Constructor Called");
    }

    // main function
    public static void main(String[] args)
    {
        Geeks geek = new Geeks();
    }
}

** En quoi les constructeurs Java sont-ils différents des méthodes Java ?**

1.Les constructeurs doivent avoir le même nom que la classe au sein de laquelle ils sont définis ce n'est pas nécessaire pour la méthode en Java.
2.Les constructeurs ne renvoient aucun type tandis que les méthodes ont le type de retour ou void si ne renvoient aucune valeur.
3.Les constructeurs ne sont appelés qu'une seule fois au moment de la création de l'objet, tandis que les méthodes peuvent être appelées plusieurs fois.

Quand le constructeur Java est appelé ?

Chaque fois qu'un objet est créé à l'aide d'un mot-clé new(), au moins un constructeur (il peut s'agir du constructeur par défaut) est invoqué pour attribuer des valeurs initiales aux données membres de la même classe. Les règles d'écriture des constructeurs sont les suivantes :

1.Le(s) constructeur(s) d'une classe doivent avoir le même nom que le nom de la classe dans laquelle elle réside.
2.Un constructeur en Java ne peut pas être abstrait, final, statique ou synchronisé.
3.Les modificateurs d'accès peuvent être utilisés dans la déclaration du constructeur pour contrôler son accès, c'est-à-dire quelle autre classe peut appeler le constructeur.

Types de constructeurs en Java(TBD)

C'est le bon moment pour discuter des types de constructeur, il existe donc principalement trois types de constructeurs en Java mentionnés ci-dessous :

3.copier le constructeur

Référence :https://www.geeksforgeeks.org/constructors-in-java/

Surcharge de constructeur en Java :

En Java, on peut surcharger les constructeurs comme les méthodes. La surcharge du constructeur peut être définie comme le concept consistant à avoir plus d'un constructeur avec des paramètres différents afin que chaque constructeur puisse effectuer une tâche différente.

Ici, nous devons comprendre le but de la surcharge des constructeurs. Parfois, nous devons utiliser plusieurs constructeurs pour initialiser les différentes valeurs de la classe.

Il faut également remarquer que le compilateur java invoque un constructeur par défaut lorsque l'on n'utilise aucun constructeur dans la classe. Cependant, le constructeur par défaut n'est pas invoqué si nous avons utilisé un constructeur dans la classe, qu'il soit par défaut ou paramétré. Dans ce cas, le compilateur Java lève une exception indiquant que le constructeur n'est pas défini.

Utilisation de this () dans la surcharge du constructeur :

Cependant, nous pouvons utiliser ce mot-clé à l'intérieur du constructeur, qui peut être utilisé pour invoquer l'autre constructeur de la même classe.

Exemple

// Driver Class
class Geeks {

    // Constructor
    Geeks()
    {
        super();
        System.out.println("Constructor Called");
    }

    // main function
    public static void main(String[] args)
    {
        Geeks geek = new Geeks();
    }
}

Référence :https://www.javatpoint.com/constructor-overloading-in-java

Programme :

    public class Student {  
    //instance variables of the class  
    int id,passoutYear;  
    String name,contactNo,collegeName;  

    Student(String contactNo, String collegeName, int passoutYear){  
    this.contactNo = contactNo;  
    this.collegeName = collegeName;  
    this.passoutYear = passoutYear;  
    }  

    Student(int id, String name){  
    this("9899234455", "IIT Kanpur", 2018);  
    this.id = id;  
    this.name = name;  
    }  

    public static void main(String[] args) {  
    //object creation  
    Student s = new Student(101, "John");  
    System.out.println("Printing Student Information: \n");  
    System.out.println("Name: "+s.name+"\nId: "+s.id+"\nContact No.: "+s.contactNo+"\nCollege Name: "+s.contactNo+"\nPassing Year: "+s.passoutYear);  
    }  
    }  

Sortie :

public class SuperMarket
{
//class specific
static String name = "SB SuperMarket"; 
static int doorNo = 10; 
static boolean open = true; 
//non-static ---> Instance specific
String product_name; 
int price, discount; 

SuperMarket(String product_name, int price, int discount)
{
this.product_name = product_name; 
this.price = price; 
this.discount = discount; 
}

public static void main(String[] args)
{
SuperMarket product1 = new SuperMarket("cinthol", 22,2); 
SuperMarket product2 = new SuperMarket("biscuits",30,5);
SuperMarket product3 = new SuperMarket("cake",10,1); 
product1.sell();
product2.sell(); 
product3.sell();
product2.return_product(); 

}
public void return_product()
{
System.out.println("returning "+product_name);
}
public void sell()
{
System.out.println(product_name); 
System.out.println(price);
System.out.println(discount);
}
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!