Constructeurs Java

Dans ce didacticiel, nous découvrirons les constructeurs Java, leurs types et comment les utiliser à l'aide d'exemples.

Qu'est-ce qu'un constructeur ?

Un constructeur en Java est similaire à une méthode qui est invoquée lorsqu'un objet de la classe est créé.

Contrairement aux méthodes Java, un constructeur a le même nom que celui de la classe et n'a pas de type de retour. Par exemple,

class Test {
  Test() {
    // constructor body
  }
}

Ici, Test() est un constructeur. Il a le même nom que celui de la classe et n'a pas de type de retour.

Lecture recommandée : Pourquoi les constructeurs ne renvoient-ils pas de valeurs

Exemple 1 :Constructeur Java

class Main {
  private String name;

  // constructor
  Main() {
    System.out.println("Constructor Called:");
    name = "Programiz";
  }

  public static void main(String[] args) {

    // constructor is invoked while
    // creating an object of the Main class
    Main obj = new Main();
    System.out.println("The name is " + obj.name);
  }
}

Sortie :

Constructor Called:
The name is Programiz

Dans l'exemple ci-dessus, nous avons créé un constructeur nommé Main() . À l'intérieur du constructeur, nous initialisons la valeur du nom variables.

Remarquez la déclaration de création d'un objet de Main classe.

Main obj = new Main();

Ici, lors de la création de l'objet, le Main() constructeur est appelé. Et, la valeur du nom la variable est initialisée.

Par conséquent, le programme imprime la valeur du nom variables comme Programiz .

Types de constructeur

En Java, les constructeurs peuvent être divisés en 3 types :

Constructeur sans Arg
Constructeur paramétré
Constructeur par défaut

1. Constructeurs Java sans Arg

Semblable aux méthodes, un constructeur Java peut avoir ou non des paramètres (arguments).

Si un constructeur n'accepte aucun paramètre, il est appelé constructeur sans argument. Par exemple,

private Constructor() {
   // body of the constructor
}

Exemple 2 :Constructeur Java privé sans argument

class Main {

  int i;

  // constructor with no parameter
  private Main() {
    i = 5;
    System.out.println("Constructor is called");
  }

  public static void main(String[] args) {

    // calling the constructor without any parameter
    Main obj = new Main();
    System.out.println("Value of i: " + obj.i);
  }
}

Sortie :

Constructor is called
Value of i: 5

Dans l'exemple ci-dessus, nous avons créé un constructeur Main() . Ici, le constructeur n'accepte aucun paramètre. Par conséquent, il est connu comme un constructeur sans argument.

Notez que nous avons déclaré le constructeur comme privé.

Une fois qu'un constructeur est déclaré private , il n'est pas possible d'y accéder depuis l'extérieur de la classe. Ainsi, la création d'objets en dehors de la classe est interdite en utilisant le constructeur privé.

Ici, nous créons l'objet dans la même classe. Par conséquent, le programme peut accéder au constructeur. Pour en savoir plus, visitez Java Implement Private Constructor.

Cependant, si nous voulons créer des objets en dehors de la classe, nous devons déclarer le constructeur en tant que public .

Exemple 3 :Constructeurs Java publics sans argument

class Company {
  String name;

  // public constructor
  public Company() {
    name = "Programiz";
  }
}

class Main {
  public static void main(String[] args) {

    // object is created in another class
    Company obj = new Company();
    System.out.println("Company name = " + obj.name);
  }
}

Sortie :

Company name = Programiz

Lecture recommandée : Modificateur d'accès Java

2. Constructeur paramétré Java

Un constructeur Java peut également accepter un ou plusieurs paramètres. Ces constructeurs sont appelés constructeurs paramétrés (constructeur avec paramètres).

Exemple 4 :Constructeur paramétré

class Main {

  String languages;

  // constructor accepting single value
  Main(String lang) {
    languages = lang;
    System.out.println(languages + " Programming Language");
  }

  public static void main(String[] args) {

    // call constructor by passing a single value
    Main obj1 = new Main("Java");
    Main obj2 = new Main("Python");
    Main obj3 = new Main("C");
  }
}

Sortie :

Java Programming Language
Python Programming Language
C Programming Language

Dans l'exemple ci-dessus, nous avons créé un constructeur nommé Main() . Ici, le constructeur prend un seul paramètre. Remarquez l'expression,

Main obj1 = new Main("Java");

Ici, nous passons la valeur unique au constructeur. En fonction de l'argument passé, la variable de langage est initialisée à l'intérieur du constructeur.

3. Constructeur Java par défaut

Si nous ne créons aucun constructeur, le compilateur Java crée automatiquement un constructeur sans argument lors de l'exécution du programme. Ce constructeur est appelé constructeur par défaut.

Exemple 5 :Constructeur par défaut

class Main {

  int a;
  boolean b;

  public static void main(String[] args) {

    // A default constructor is called
    Main obj = new Main();

    System.out.println("Default Value:");
    System.out.println("a = " + obj.a);
    System.out.println("b = " + obj.b);
  }
}

Sortie :

a = 0
b = false

Ici, nous n'avons créé aucun constructeur. Par conséquent, le compilateur Java crée automatiquement le constructeur par défaut.

Le constructeur par défaut initialise toutes les variables d'instance non initialisées avec des valeurs par défaut.

Type	Valeur par défaut
`boolean`	faux
`byte`	0
`short`	0
`int`	0
`long`	0L
`char`	\u0000
`float`	0.0f
`double`	0.0d
`object`	Référence nulle

Dans le programme ci-dessus, les variables a et b sont initialisés avec la valeur par défaut 0 et false respectivement.

Le programme ci-dessus est équivalent à :

class Main {

  int a;
  boolean b;

  // a private constructor
  private Main() {
    a = 0;
    b = false;
  }

  public static void main(String[] args) {
    // call the constructor
    Main obj = new Main();

    System.out.println("Default Value:");
    System.out.println("a = " + obj.a);
    System.out.println("b = " + obj.b);
  }
}

La sortie du programme est la même que dans l'exemple 5.

Remarques importantes sur les constructeurs Java

Les constructeurs sont invoqués implicitement lorsque vous instanciez des objets.
Les deux règles de création d'un constructeur sont :
Le nom du constructeur doit être le même que celui de la classe.
Un constructeur Java ne doit pas avoir de type de retour.
Si une classe n'a pas de constructeur, le compilateur Java crée automatiquement un constructeur par défaut pendant l'exécution. Le constructeur par défaut initialise les variables d'instance avec des valeurs par défaut. Par exemple, le int la variable sera initialisée à 0
Types de constructeur :
Constructeur sans Arg - un constructeur qui n'accepte aucun argument
Constructeur paramétré - un constructeur qui accepte des arguments
Constructeur par défaut - un constructeur créé automatiquement par le compilateur Java s'il n'est pas explicitement défini.
Un constructeur ne peut pas être abstract ou static ou final .
Un constructeur peut être surchargé mais ne peut pas être remplacé.

Surcharge des constructeurs en Java

Semblable à la surcharge de méthode Java, nous pouvons également créer deux constructeurs ou plus avec des paramètres différents. C'est ce qu'on appelle la surcharge des constructeurs.

Exemple 6 :surcharge du constructeur Java

class Main {

  String language;

  // constructor with no parameter
  Main() {
    this.language = "Java";
  }

  // constructor with a single parameter
  Main(String language) {
    this.language = language;
  }

  public void getName() {
    System.out.println("Programming Langauage: " + this.language);
  }

  public static void main(String[] args) {

    // call constructor with no parameter
    Main obj1 = new Main();

    // call constructor with a single parameter
    Main obj2 = new Main("Python");

    obj1.getName();
    obj2.getName();
  }
}

Sortie :

Programming Language: Java
Programming Language: Python

Dans l'exemple ci-dessus, nous avons deux constructeurs :Main() et Main(String language) . Ici, les deux constructeurs initialisent la valeur de la variable language avec des valeurs différentes.

En fonction du paramètre transmis lors de la création de l'objet, différents constructeurs sont appelés et différentes valeurs sont attribuées.

Il est également possible d'appeler un constructeur à partir d'un autre constructeur. Pour en savoir plus, consultez Java Call One Constructor from Another.

Remarque :Nous avons utilisé this mot clé pour spécifier la variable de la classe. En savoir plus sur this mot-clé, visitez Java ce mot-clé.

Méthodes Java Chaînes Java

Java