Java-Konstruktoren

In diesem Tutorial lernen wir Java-Konstruktoren, ihre Typen und ihre Verwendung anhand von Beispielen kennen.

Was ist ein Konstruktor?

Ein Konstruktor in Java ähnelt einer Methode, die aufgerufen wird, wenn ein Objekt der Klasse erstellt wird.

Im Gegensatz zu Java-Methoden hat ein Konstruktor den gleichen Namen wie die Klasse und keinen Rückgabetyp. Zum Beispiel

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

Hier, Test() ist ein Konstrukteur. Sie hat denselben Namen wie die Klasse und keinen Rückgabetyp.

Empfohlene Lektüre: Warum geben Konstruktoren keine Werte zurück

Beispiel 1:Java-Konstruktor

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

Ausgabe :

Constructor Called:
The name is Programiz

Im obigen Beispiel haben wir einen Konstruktor namens Main() erstellt . Innerhalb des Konstruktors initialisieren wir den Wert von name Variable.

Beachten Sie die Anweisung zum Erstellen eines Objekts von Main Klasse.

Main obj = new Main();

Hier wird beim Erstellen des Objekts der Main() Konstruktor aufgerufen wird. Und der Wert von name Variable wird initialisiert.

Daher gibt das Programm den Wert von name aus Variablen als Programiz .

Arten von Konstruktoren

In Java können Konstruktoren in 3 Typen unterteilt werden:

No-Arg-Konstruktor
Parametrisierter Konstruktor
Standardkonstruktor

1. Java No-Arg-Konstruktoren

Ähnlich wie Methoden kann ein Java-Konstruktor Parameter (Argumente) haben oder auch nicht.

Wenn ein Konstruktor keine Parameter akzeptiert, wird er als Konstruktor ohne Argumente bezeichnet. Zum Beispiel

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

Beispiel 2:Java privater No-Arg-Konstruktor

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

Ausgabe :

Constructor is called
Value of i: 5

Im obigen Beispiel haben wir einen Konstruktor Main() erstellt . Hier akzeptiert der Konstruktor keine Parameter. Daher ist es als No-Arg-Konstruktor bekannt.

Beachten Sie, dass wir den Konstruktor als privat deklariert haben.

Sobald ein Konstruktor deklariert ist private , kann von außerhalb der Klasse nicht darauf zugegriffen werden. Daher ist das Erstellen von Objekten außerhalb der Klasse mit dem privaten Konstruktor verboten.

Hier erstellen wir das Objekt innerhalb derselben Klasse. Daher kann das Programm auf den Konstruktor zugreifen. Weitere Informationen finden Sie unter Java Implement Private Constructor.

Wenn wir jedoch Objekte außerhalb der Klasse erstellen möchten, müssen wir den Konstruktor als public deklarieren .

Beispiel 3:Öffentliche Java-Konstruktoren ohne Argumente

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

Ausgabe :

Company name = Programiz

Empfohlene Lektüre: Java-Zugriffsmodifikator

2. Parametrisierter Java-Konstruktor

Ein Java-Konstruktor kann auch einen oder mehrere Parameter akzeptieren. Solche Konstruktoren werden als parametrisierte Konstruktoren (Konstruktor mit Parametern) bezeichnet.

Beispiel 4:Parametrisierter Konstruktor

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

Ausgabe :

Java Programming Language
Python Programming Language
C Programming Language

Im obigen Beispiel haben wir einen Konstruktor namens Main() erstellt . Hier übernimmt der Konstruktor einen einzelnen Parameter. Beachten Sie den Ausdruck,

Main obj1 = new Main("Java");

Hier übergeben wir den einzelnen Wert an den Konstruktor. Basierend auf dem übergebenen Argument wird die Sprachvariable innerhalb des Konstruktors initialisiert.

3. Java-Standardkonstruktor

Wenn wir keinen Konstruktor erstellen, erstellt der Java-Compiler während der Ausführung des Programms automatisch einen No-Arg-Konstruktor. Dieser Konstruktor wird als Standardkonstruktor bezeichnet.

Beispiel 5:Standardkonstruktor

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

Ausgabe :

a = 0
b = false

Hier haben wir keine Konstruktoren erstellt. Daher erstellt der Java-Compiler automatisch den Standardkonstruktor.

Der Standardkonstruktor initialisiert alle nicht initialisierten Instanzvariablen mit Standardwerten.

Typ	Standardwert
`boolean`	falsch
`byte`	0
`short`	0
`int`	0
`long`	0L
`char`	\u0000
`float`	0.0f
`double`	0.0d
`object`	Referenz null

Im obigen Programm sind die Variablen a und b werden mit dem Standardwert 0 initialisiert und false bzw..

Das obige Programm ist äquivalent zu:

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

Die Ausgabe des Programms ist die gleiche wie in Beispiel 5.

Wichtige Hinweise zu Java-Konstruktoren

Konstruktoren werden implizit aufgerufen, wenn Sie Objekte instanziieren.
Die beiden Regeln zum Erstellen eines Konstruktors lauten:
Der Name des Konstruktors sollte mit dem der Klasse übereinstimmen.
Ein Java-Konstruktor darf keinen Rückgabetyp haben.
Wenn eine Klasse keinen Konstruktor hat, erstellt der Java-Compiler automatisch einen Standardkonstruktor während der Laufzeit. Der Standardkonstruktor initialisiert Instanzvariablen mit Standardwerten. Beispiel:int Variable wird auf 0 initialisiert
Konstruktortypen:
No-Arg-Konstruktor - ein Konstruktor, der keine Argumente akzeptiert
Parametrisierter Konstruktor - ein Konstruktor, der Argumente akzeptiert
Standardkonstruktor - ein Konstruktor, der automatisch vom Java-Compiler erstellt wird, wenn er nicht explizit definiert ist.
Ein Konstruktor kann nicht abstract sein oder static oder final .
Ein Konstruktor kann überladen, aber nicht überschrieben werden.

Überladen von Konstruktoren in Java

Ähnlich wie beim Überladen von Java-Methoden können wir auch zwei oder mehr Konstruktoren mit unterschiedlichen Parametern erstellen. Dies wird als Überladen von Konstruktoren bezeichnet.

Beispiel 6:Überladen des Java-Konstruktors

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

Ausgabe :

Programming Language: Java
Programming Language: Python

Im obigen Beispiel haben wir zwei Konstruktoren:Main() und Main(String language) . Hier initialisieren beide Konstruktoren den Wert der Variablensprache mit unterschiedlichen Werten.

Basierend auf dem während der Objekterstellung übergebenen Parameter werden verschiedene Konstruktoren aufgerufen und verschiedene Werte zugewiesen.

Es ist auch möglich, einen Konstruktor von einem anderen Konstruktor aufzurufen. Um mehr zu erfahren, besuchen Sie Java Call One Constructor from Another.

Hinweis :Wir haben this verwendet Schlüsselwort, um die Variable der Klasse anzugeben. Um mehr über this zu erfahren Stichwort, besuchen Sie Java dieses Stichwort.

Java-Methoden Java-Strings

Java