Java-constructeurs

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

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

Uitvoer :

Constructor Called:
The name is Programiz

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

Let op de verklaring van het maken van een object van de Main klasse.

Main obj = new Main();

Hier, wanneer het object wordt gemaakt, wordt de Main() constructeur wordt genoemd. En de waarde van de naam variabele is geïnitialiseerd.

Daarom print het programma de waarde van de naam variabelen als Programiz .

Typen constructeurs

In Java kunnen constructors worden onderverdeeld in 3 typen:

1. No-Arg Constructor
2. Geparameteriseerde constructor
3. Standaardconstructor

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 het bekend als een constructor zonder argumenten. 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);
  }
}

Uitvoer :

Constructor is called
Value of i: 5

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

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

Zodra een constructor is gedeclareerd private , het is niet toegankelijk van buiten de klas. Het is dus verboden om objecten van buiten de klasse te maken met behulp van 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:Openbare Java-constructors zonder arg

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

Uitvoer :

Company name = Programiz

Aanbevolen literatuur: Java-toegangsmodificatie

2. Java-geparametriseerde constructor

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

Voorbeeld 4:Geparametriseerde 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");
  }
}

Uitvoer :

Java Programming Language
Python Programming Language
C Programming Language

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

Hier geven we de enkele waarde door aan de constructor. Op basis van het doorgegeven argument wordt de taalvariabele geïnitialiseerd in de constructor.

3. Java-standaardconstructor

Als we geen constructor maken, maakt de Java-compiler automatisch een no-arg-constructor aan tijdens de uitvoering van het programma. Deze constructor wordt de standaardconstructor genoemd.

Voorbeeld 5:Standaardconstructor

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

Uitvoer :

a = 0
b = false

Hier hebben we geen constructors gemaakt. Daarom maakt de Java-compiler automatisch de standaardconstructor.

De standaardconstructor initialiseert alle niet-geïnitialiseerde instantievariabelen met standaardwaarden.

In het bovenstaande programma zijn de variabelen a en b worden geïnitialiseerd met de standaardwaarde 0 en false respectievelijk.

Het bovenstaande programma is gelijk aan:

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

De uitvoer van het programma is hetzelfde als voorbeeld 5.

Belangrijke opmerkingen over Java-constructors

• Constructeurs worden impliciet aangeroepen wanneer u objecten instantieert.
• De twee regels voor het maken van een constructor zijn:
  De naam van de constructor moet hetzelfde zijn als de klasse.
  Een Java-constructor mag geen retourtype hebben.
• Als een klasse geen constructor heeft, maakt de Java-compiler automatisch een standaardconstructor tijdens de looptijd. De standaardconstructor initialiseert instantievariabelen met standaardwaarden. Bijvoorbeeld de int variabele wordt geïnitialiseerd op 0
• Typen constructeurs:
  No-Arg Constructor - een constructor die geen argumenten accepteert
  Geparameteriseerde constructor - een constructor die argumenten accepteert
  Standaard Constructor - een constructor die automatisch wordt gemaakt door de Java-compiler als deze niet expliciet is gedefinieerd.
• Een constructor kan niet abstract zijn of static of final .
• Een constructor kan worden overbelast, maar kan niet worden overschreven.

Constructeurs overbelasten in Java

Net als bij overbelasting van de Java-methode, kunnen we ook twee of meer constructors maken met verschillende parameters. Dit wordt overbelasting door constructeurs genoemd.

Voorbeeld 6:Java Constructor Overbelasting

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

Uitvoer :

Programming Language: Java
Programming Language: Python

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

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

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

Opmerking :We hebben this gebruikt trefwoord om de variabele van de klasse op te geven. Meer weten over this zoekwoord, bezoek Java dit zoekwoord.