Dans ce didacticiel, nous allons découvrir 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 appelée lorsqu'un objet de la classe est créé.
Contrairement aux méthodes Java, un constructeur porte le même nom que celui de la classe et n'a pas de type de retour. Par exemple,
class Test (Test () (// corps du constructeur))
Ici, Test()est un constructeur. Il porte 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 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 :
Constructeur appelé: le nom est Programiz
Dans l'exemple ci-dessus, nous avons créé un constructeur nommé Main(). À l'intérieur du constructeur, nous initialisons la valeur de la variable de nom.
Notez l'instruction de création d'un objet de la classe Main.
Main obj = new Main();
Ici, lorsque l'objet est créé, le Main()constructeur est appelé. Et, la valeur de la variable de nom est initialisée.
Par conséquent, le programme imprime la valeur des variables de nom comme Programiz.
Types de constructeur
En Java, les constructeurs peuvent être divisés en 3 types:
- Constructeur No-Arg
- Constructeur paramétré
- Constructeur par défaut
1. Constructeurs Java No-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 connu sous le nom de 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 :
Le constructeur est appelé Valeur de 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 accessible depuis l'extérieur de la classe. Ainsi, la création d'objets depuis l'extérieur de la classe est interdite à l'aide du constructeur privé.
Ici, nous créons l'objet dans la même classe. Par conséquent, le programme est capable d'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 comme public.
Exemple 3: Constructeurs Java publics sans argument
class Company ( String name; // public constructor public Company() ( name = "Programiz"; ) ) public 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 :
Nom de l'entreprise = 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. De tels 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 :
Langage de programmation Java Langage de programmation Python Langage de programmation C
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");
Here, we are passing the single value to the constructor. Based on the argument passed, the language variable is initialized inside the constructor.
3. Java Default Constructor
If we do not create any constructor, the Java compiler automatically create a no-arg constructor during the execution of the program. This constructor is called default constructor.
Example 5: Default Constructor
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); ) )
Output:
a = 0 b = false
Here, we haven't created any constructors. Hence, the Java compiler automatically creates the default constructor.
The default constructor initializes any uninitialized instance variables with default values.
| Type | Default Value |
|---|---|
boolean | false |
byte | 0 |
short | 0 |
int | 0 |
long | 0L |
char | u0000 |
float | 0.0f |
double | 0.0d |
object | Reference null |
In the above program, the variables a and b are initialized with default value 0 and false respectively.
The above program is equivalent to:
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); ) )
The output of the program is the same as Example 5.
Important Notes on Java Constructors
- Constructors are invoked implicitly when you instantiate objects.
- The two rules for creating a constructor are:
The name of the constructor should be the same as the class.
A Java constructor must not have a return type. - If a class doesn't have a constructor, the Java compiler automatically creates a default constructor during run-time. The default constructor initializes instance variables with default values. For example, the
intvariable will be initialized to0 - Constructor types:
No-Arg Constructor - a constructor that does not accept any arguments
Parameterized constructor - a constructor that accepts arguments
Default Constructor - a constructor that is automatically created by the Java compiler if it is not explicitly defined. - A constructor cannot be
abstractorstaticorfinal. - A constructor can be overloaded but can not be overridden.
Constructors Overloading in Java
Similar to Java method overloading, we can also create two or more constructors with different parameters. This is called constructors overloading.
Example 6: Java Constructor Overloading
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(); ) )
Output:
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 passé 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, visitez Java Call One Constructor from Another.
Remarque : Nous avons utilisé un thismot-clé pour spécifier la variable de la classe. Pour en savoir plus sur le thismot-clé, visitez Java ce mot-clé.
