Java Constructors (met voorbeelden)

Inhoudsopgave

Wat is een constructeur?
Voorbeeld 1: Java Constructor
1. Java No-Arg Constructors
2. Java Parameterized Constructor
3. Java Default Constructor
Important Notes on Java Constructors
Constructors Overloading in Java

In deze zelfstudie leren we met behulp van voorbeelden over Java-constructors, hun typen en hoe u ze kunt gebruiken.

Wat is een constructeur?

Een constructor in Java is vergelijkbaar met een methode die wordt aangeroepen wanneer een object van de klasse wordt gemaakt.

In tegenstelling tot Java-methoden heeft een constructor dezelfde naam als die van de klasse en heeft hij geen retourtype. Bijvoorbeeld,

 class Test (Test () (// constructor body))

Hier Test()is een constructeur. Het heeft dezelfde naam als die van de klasse en heeft geen retourtype.

Aanbevolen literatuur: waarom retourneren constructeurs geen waarden

Voorbeeld 1: Java Constructor

 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); ) )

Uitgang :

 Constructor Called: De naam is Programiz

In het bovenstaande voorbeeld hebben we een constructor gemaakt met de naam Main(). Binnen de constructor initialiseren we de waarde van de naamvariabele.

Let op de instructie om een object van de klasse Main te creëren.

 Main obj = new Main();

Hier, wanneer het object is gemaakt, wordt de Main()constructor aangeroepen. En de waarde van de naamvariabele wordt geïnitialiseerd.

Daarom drukt het programma de waarde van de naamvariabelen af als Programiz.

Soorten Constructor

In Java kunnen constructeurs worden onderverdeeld in 3 typen:

No-Arg Constructor
Geparametriseerde constructor
Standaard Constructor

1. Java No-Arg Constructors

Net als bij methoden, kan een Java-constructor al dan niet parameters (argumenten) hebben.

Als een constructor geen parameters accepteert, staat deze bekend als een constructor zonder argument. Bijvoorbeeld,

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

Voorbeeld 2: Java private no-arg constructor

 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); ) )

Uitgang :

 Constructor heet Waarde van i: 5

In het bovenstaande voorbeeld hebben we een constructor gemaakt Main(). Hier accepteert de constructor geen parameters. Daarom staat het bekend als een constructor zonder argumenten.

Merk op dat we de constructor als privé hebben verklaard.

Als een constructor eenmaal is gedeclareerd private, kan deze niet van buiten de klasse worden geopend. Het maken van objecten van buiten de klasse is dus verboden met de private constructor.

Hier maken we het object binnen dezelfde klasse. Daarom heeft het programma toegang tot de constructor. Ga voor meer informatie naar Java Implement Private Constructor.

Als we echter objecten buiten de klasse willen maken, moeten we de constructor declareren als public.

Voorbeeld 3: Java openbare no-arg constructors

 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); ) )

Uitgang :

 Bedrijfsnaam = Programiz

Aanbevolen literatuur: Java Access Modifier

2. Java Parameterized Constructor

Een Java-constructor kan ook een of meer parameters accepteren. Dergelijke constructors staan bekend als geparametriseerde constructors (constructor met parameters).

Voorbeeld 4: Geparameteriseerde constructor

 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"); ) )

Uitgang :

 Programmeertaal Java Programmeertaal Python C Programmeertaal

In het bovenstaande voorbeeld hebben we een constructor gemaakt met de naam Main(). Hier neemt de constructor een enkele parameter. Let op de uitdrukking,

 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 int variable will be initialized to 0
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 abstract or static or final.
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

In het bovenstaande voorbeeld hebben we twee constructors: Main()en Main(String language). Hier initialiseert zowel de constructor de waarde van de variabele taal met verschillende waarden.

Op basis van de parameter die is doorgegeven tijdens het maken van een object, worden verschillende constructors aangeroepen en worden verschillende waarden toegewezen.

Het is ook mogelijk om een constructor aan te roepen vanuit een andere constructor. Ga voor meer informatie naar Java Call One Constructor from Another.

Opmerking : we hebben thistrefwoord gebruikt om de variabele van de klasse te specificeren. Voor meer informatie over thistrefwoord, bezoek Java dit trefwoord.