Java-Konstruktor

java constructor class

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Wählen Sie Das Betriebssystem Aus Wählen Sie Ein Projektionsprogramm (Optional)

Beschreiben Sie Ihr Problem

In diesem Tutorial werden der Java-Konstruktor, seine Typen und Konzepte wie das Überladen von Konstruktoren und das Verketten von Konstruktoren anhand von Codebeispielen erläutert:

Aus unseren früheren Tutorials wissen wir, dass die Instanz einer Klasse als Objekt bezeichnet wird. Ein Objekt einer Klasse wird mit dem Schlüsselwort 'new' erstellt. Eine spezielle Methode namens 'Konstruktor' wird aufgerufen, wenn wir ein Objekt mit einem neuen Schlüsselwort erstellen oder wenn das Objekt instanziiert wird.

Ein Konstruktor ist als Codeblock zum Initialisieren des Klassenobjekts definiert. Es ist identisch mit der Methode, aber es ist keine Methode. In Java kann es jedoch als „spezielle Methode“ bezeichnet werden.

=> Hier finden Sie A-Z der Java-Schulungsanleitungen.

Konstruktoren in Java

Was du lernen wirst:

Java-Konstruktor
Fazit
- Literatur-Empfehlungen

Der Java-Konstruktor wird verwendet, um das gerade erstellte Objekt zu initialisieren. Ein Objekt muss einige Daten haben, bevor es im Programm verwendet wird. Daher verwenden wir den Konstruktor, damit wir dem Objekt einige Anfangsdaten zuweisen können.

Betrachten Sie als einfaches Beispiel eine Klasse ABC, für die wir ein Objekt erstellen müssen. Erstellen wir ein Objekt 'myObj' für die Klasse ABC mit einem neuen Schlüsselwort.

ABC myObj = new ABC ();

Die obige Anweisung erstellt ein Objekt myObj. Wenn dieses Objekt erstellt wird, wird ein Konstruktor für die Klasse ABC ohne Argument aufgerufen (ABC () zeigt an, dass keine Argumente für den Konstruktor vorhanden sind). Da für den obigen Konstruktor keine Argumente angegeben sind, werden die Mitgliedsfelder von myObj auf ihre Standardanfangswerte initialisiert.

Zum Beispiel,

Numerische Datentypen wie int werden auf 0 gesetzt.
Der Wert der Variablen für den Datentyp 'Char' wird auf ein Nullzeichen (' 0') gesetzt.
Referenzen werden auf null gesetzt.

In diesem Tutorial werden die Konstruktoren zusammen mit den verschiedenen in Java verwendeten Konstruktoren ausführlich erläutert.

So erstellen Sie einen Konstruktor in Java

Um einen Konstruktor in Java zu erstellen, müssen wir die folgenden Regeln befolgen.

Der Klassenkonstruktor hat denselben Namen wie der der Klasse.
Es kann keinen Konstruktor geben, der endgültig, abstrakt, synchronisiert oder statisch ist. Dies liegt daran, dass das Finale als Konstante fungiert und abstrakt nicht instanziiert werden kann. Während der Synchronisierung wird im Fall von Multithreading verwendet, und das statische Schlüsselwort wird auf Klassenebene verwendet.
Wir können Zugriffsmodifikatoren mit den Konstruktoren verwenden.
Ein Konstruktor kann keinen Rückgabetyp haben.

Zum Beispiel,Definieren wir eine Klasse Student wie folgt:

class Student{ String name; int roll_no; }

Wir können Objekte der obigen Klasse mit dem neuen Schlüsselwort erstellen. Während das Objekt erstellt wird, können wir die aus zwei Elementen bestehenden Variablen dieser Klasse initialisieren, indem wir einen Konstruktor bereitstellen. Beachten Sie, dass selbst wenn wir keinen Konstruktor bereitstellen und nur die folgende Anweisung ausführen,

Student Student = neuer Student ();

Dennoch führt Java einen Standardkonstruktor aus, der die aus zwei Mitgliedern bestehenden Variablen auf ihre Systemstandards initialisiert. Wenn der Anfangswert von Student.name nun 'Keith' und roll_no 27 sein soll, können wir dazu die folgende Konstruktormethode erstellen.

Student () { name = 'Keith'; roll_no = 27; }

Wenn wir ein Objekt der Schülerklasse mit der folgenden Anweisung erstellen

Student student = new Student ();

Dann sind die Anfangswerte der Mitgliedsvariablen name und roll_no Keith bzw. 27.

Wann wird ein Konstruktor erstellt, der aufgerufen wird?

Ein Konstruktor wird jedes Mal aufgerufen, wenn ein Objekt mit dem neuen Schlüsselwort wie im obigen Fall erstellt wird. Wie bereits erwähnt, stellt Java, wenn kein Konstruktor angegeben ist, einen Standardkonstruktor bereit, der aufgerufen wird, wenn das Objekt mit dem neuen Schlüsselwort erstellt wird.

Konstruktorbeispiel

Das folgende Programm zeigt ein Konstruktorbeispiel, in dem wir einen einfachen Konstruktor ohne Argumente haben. Dieser Konstruktor weist seinen Mitgliedsvariablen einfach Anfangswerte zu.

//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }

Ausgabe:

Class Demo Beispielausgabe

Standardkonstruktor In Java

Der Standardkonstruktor wird auch als leerer Konstruktor bezeichnet . Dieser Konstruktor wird vom Java-Compiler in den Klassencode eingefügt, in dem kein vom Programmierer implementierter Konstruktor vorhanden ist. Der Standardkonstruktor wird während der Kompilierung eingefügt und erscheint daher nur in der Datei '.class' und nicht im Quellcode.

Betrachten Sie die folgende Java-Klasse.

Quelldatei (.java) Klassendatei (.class)

Java-Klasse

In der obigen Abbildung zeigt die erste Abbildung den Quellcode, in dem wir keinen Konstruktor angegeben haben. Wenn wir diesen Code kompilieren und die .class-Datei generiert wird, können wir sehen, dass der Java-Compiler einen Standardkonstruktor eingefügt hat, wie in der nebenstehenden Abbildung gezeigt (in blauer Farbe).

Hinweis:

Manchmal wird ein Standardkonstruktor verwendet, um den Konstruktor ohne Argumente in Java zu beschreiben. Diese beiden Begriffe unterscheiden sich jedoch in der Realität. Der No-Arg-Konstruktor ist ein Konstruktortyp in Java, der vom Programmierer angegeben wird. Der Standardkonstruktor ist der Konstruktor, der vom Java-Compiler eingefügt wird.

beste Musik MP3 Downloader für Android

Obwohl diese beiden Begriffe von den meisten Programmierern synonym verwendet werden, ist es daher ratsam, diese beiden Begriffe nicht zu verwechseln.

Wenn Java einen Standardkonstruktor einfügt und das Programm Variablen enthält, werden ihnen die Standardwerte zugewiesen.

Die folgende Tabelle zeigt die Standardwerte für jeden Datentyp.

Art	Standardwert
verkohlen	u0000
Objekt	Referenz null
Boolescher Wert	falsch
Byte	0
kurz	0
int	0
lange	0L
schweben	0.0f
doppelt	0.0d

Das folgende Programm enthält ein Beispiel für einen Standardkonstruktor in Java.

class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }

Ausgabe:

Standardkonstruktor - Ausgabe

Arten von Konstruktoren in Java

Es gibt zwei Arten von Konstruktoren in Java, wie unten gezeigt.

Arten von Konstruktoren in Java

# 1) No-Arg-Konstruktor

Ein Konstruktor ohne Argumente wird als Konstruktor ohne Argumente oder ohne Argumente bezeichnet. Wenn wir keinen Konstruktor ohne Argumente haben, erstellt der Java-Compiler keinen Standardkonstruktor für die Klasse.

Wenn wir in unserer Klasse einen Konstruktor definieren, wird der Standardkonstruktor im Allgemeinen nicht vom Java-Compiler eingefügt.

Im Folgenden finden Sie ein Beispiel für den No-Arg-Konstruktor

import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } }

Ausgabe:

No-Arg-Konstruktor

In diesem Programm haben wir einen Konstruktor ohne Argumente bereitgestellt. Hier drucken wir einige Nachrichten einschließlich der Mitgliedsvariablen. Wir können in der Ausgabe sehen, dass die Nachrichten vom Konstruktor angezeigt werden, die anzeigen, dass der Konstruktor no-args ausgeführt wird.

# 2) Parametrisierter Konstruktor

Ein parametrisierter Konstruktor hat einen oder mehrere Parameter. Wir können einen parametrisierten Konstruktor verwenden, falls wir einige Anfangswerte an die Mitgliedsvariable der Klasse übergeben müssen.

import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } }

Ausgabe:

Parametrisierter Konstruktor in Java

Hier haben wir einen parametrisierten Konstruktor bereitgestellt, der zwei Argumente akzeptiert, d. H. Name und ID.

Innerhalb des Konstruktorkörpers werden die Argumente dem Mitgliedsvariablennamen bzw. der ID als Werte zugewiesen.

Wenn wir dann in der Hauptmethode ein neues Objekt mit dem neuen Schlüsselwort erstellen, übergeben wir nach einem neuen Schlüsselwort zwei Werte an den Klassennamen. Dies zeigt an, dass wir den parametrisierten Konstruktor aufrufen. Wenn wir die Elementvariablen anzeigen, können wir sehen, dass sie die Werte haben, die wir beim Erstellen des Objekts übergeben haben.

Überladene Konstruktoren in Java

Nun stellt sich die Frage, ob eine Klasse mehr als einen Konstruktor haben kann oder ob eine Klasse nur einen Konstruktor haben kann.

Nun, wir können mehrere Konstruktoren in einer Klasse haben. Eine Klasse kann so viele Konstruktoren enthalten, wie sie ordnungsgemäß überladen sind.

Was genau ist mit Überladung von Konstruktoren gemeint?

Konstruktorüberladung ist ein Mechanismus, mit dem eine Klasse so viele Konstruktoren haben kann, dass alle diese Konstruktoren je nach Parametertyp oder Reihenfolge der Parameter unterschiedliche Parameterlisten haben.

Das folgende Programm demonstriert das Überladen von Konstruktoren.

//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }

Ausgabe:

Überladen - Ausgabe

Im obigen Programm haben wir eine Klasse, die drei Konstruktoren enthält. Der erste Konstruktor ist ein Konstruktor ohne Argumente, und dann haben wir jeweils einen mit jeweils einem Argument und zwei Argumenten. Da der Konstruktor eine eindeutige Parameterliste hat, können wir sagen, dass die Konstruktoren überladen sind.

Konstruktor 'this ()' in Java

Was ist, wenn wir in einer Klasse mit mehreren Konstruktoren einen Konstruktor von einem anderen Konstruktor in dieser Klasse aufrufen möchten?

Zu diesem Zweck verwenden wir das Schlüsselwort 'this' innerhalb des Konstruktors, von dem aus wir einen anderen Konstruktor aufrufen möchten.

Wenn eine Klasse mehrere Konstruktoren, einen Konstruktor ohne Argumente und einen parametrisierten Konstruktor hat, verwenden wir das Schlüsselwort 'this', um einen parametrisierten Konstruktor aus dem Konstruktor ohne Argumente aufzurufen. Dies wird auch genannt 'Expliziter Aufruf des Konstruktors'.

Warum brauchen wir dieses Schlüsselwort?

Wir brauchen es, weil der explizite Aufruf von Konstruktoren nicht direkt möglich ist, wenn nur der Konstruktorname verwendet wird.

Zu beachtende Punkte:

Das Schlüsselwort 'this' sollte die erste Anweisung im aufrufenden Konstruktor sein.
Wenn ein Konstruktor das Schlüsselwort 'this' hat, kann er nicht 'super' haben. Dies bedeutet, dass der Konstruktor entweder super oder this haben kann.

class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }

Ausgabe:

Konstruktor

Im obigen Programm haben wir eine 'TestClass' mit zwei Konstruktoren. Wir nennen dies ('SoftwareTestingHelp') vom Konstruktor no-args. Dies ist der explizite Aufruf des parametrisierten Konstruktors.

Konstruktor in Java kopieren

Wir kennen den Kopierkonstruktor in C ++. Der Kopierkonstruktor ist ein Konstruktor, der eine Objektreferenz als Argument hat und aus den Daten des Referenzobjekts ein neues Objekt erstellt wird.

C ++ stellt einen Standardkopierkonstruktor bereit, wenn dieser nicht im Programm enthalten ist.

Java bietet auch Unterstützung für den Kopierkonstruktor, jedoch keinen Standardkopierkonstruktor.

Das folgende Java-Programm demonstriert den Kopierkonstruktor am klassischen Beispiel komplexer Zahlen mit reellen und imaginären Komponenten.

class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } }

Ausgabe:

Kopieren Sie den Konstruktor in Java 7

Das obige Programm verfügt über eine 'Complex'-Klasse mit einem parametrisierten Konstruktor und einem Kopierkonstruktor. In der Hauptmethode erstellen wir zuerst ein Objekt c1 mit einem parametrisierten Konstruktor. Verwenden Sie dann die folgende Anweisung:

Complex c2 = new Complex (c1);

Die obige Anweisung ruft den Kopierkonstruktor auf, wenn die Referenz c1 beim Erstellen eines neuen Objekts c2 an den Konstruktor übergeben wird.

Konstruktorkette in Java

Die Konstruktorkettung ist ein Prozess, bei dem ein Konstruktor einen anderen Konstruktor derselben Klasse aufruft.

Selbst wenn wir von einer Basisklasse geerbt haben, wird der Konstruktor der Basisklasse zuerst aufgerufen, wenn das untergeordnete Klassenobjekt erstellt wird. Dies ist auch ein Beispiel für die Verkettung von Konstruktoren.

In Java kann die Konstruktorkettung mit zwei Ansätzen erreicht werden:

Innerhalb derselben Klasse : Wenn wir einen Konstruktor von einem anderen Konstruktor derselben Klasse aufrufen, können wir dieses Schlüsselwort () verwenden.
Aus der Basisklasse: Ein Konstruktor der Basisklasse kann von dem der abgeleiteten Klasse mit dem Schlüsselwort super aufgerufen werden.

Warum brauchen wir Konstruktorketten?

Wenn wir mehrere Aufgaben in unserem Konstruktor ausführen möchten, teilen wir die Aufgaben nicht in einem Konstruktor auf, sondern teilen sie in mehrere Konstruktoren auf und rufen dann Konstruktoren voneinander auf, was zu einer Verkettung der Konstruktoren führt.

Im Folgenden sind einige der Regeln aufgeführt, die wir bei der Verkettung von Konstruktoren befolgen müssen.

Die Verkettung der Konstruktoren erfolgt in beliebiger Reihenfolge und führt zu den gleichen Ergebnissen.
Der Ausdruck 'this' sollte der erste Ausdruck im Konstruktor sein.
Wir sollten mindestens einen Konstruktor ohne dieses Schlüsselwort haben.

Wenn wir eine Vererbung in unserem Programm haben, können wir auch eine Konstruktorkettung durchführen. In diesem Fall ruft die Unterklasse den Konstruktor der Basisklasse auf. Auf diese Weise beginnt die Erstellung von Unterklassenobjekten mit der Initialisierung der Mitglieder der Oberklasse.

Jetzt implementieren wir die Konstruktorkettung in Java unter Verwendung der obigen Ansätze.

# 1) Konstruktorkette innerhalb derselben Klasse

class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } }

Ausgabe:

Verkettung innerhalb derselben Klasse

Wie bereits erwähnt, erreichen wir die Verkettung von Konstruktoren innerhalb derselben Klasse mit dem Schlüsselwort 'this'. Im obigen Programm haben wir drei Konstruktoren und rufen einen Konstruktor von einem anderen mit dem Schlüsselwort 'this' auf.

Aus der Basisklasse

Wenn eine Klasse eine andere Klasse erbt, wird der Konstruktor der übergeordneten Klasse zuerst aufgerufen, wenn wir ein Objekt einer abgeleiteten Klasse erstellen, bei der es sich um eine Konstruktorkettung handelt.

Wenn wir den Basisklassenkonstruktor in der abgeleiteten Klasse explizit aufrufen möchten, sollten wir zu diesem Zweck das Schlüsselwort 'super' verwenden. Mit dem Schlüsselwort 'super' können wir die Konstruktoren der Oberklasse in der Vererbungshierarchie aufrufen, bis wir die oberste Klasse erreichen.

Das folgende Programm demonstriert die Verwendung eines 'Super' -Schlüsselworts für die Konstruktorkettung.

grep-Befehle unter Unix mit Beispielen

class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }

Ausgabe:

Aus der Basisklasse

Im obigen Programm rufen wir den parametrisierten Konstruktor der abgeleiteten Klasse mit dem Wert 'Java' auf. Dieser Konstruktor hat wiederum einen Aufruf an den Basisklassenkonstruktor mit 'super (name);' Hiermit wird der parametrisierte Konstruktor der Basisklasse ausgeführt.

Häufig gestellte Fragen

F # 1) Wie erstellt man einen Konstruktor in Java?

Antworten: Wir erstellen einen Konstruktor als spezielle Methode, die denselben Namen wie der Name der Klasse hat. Ein Konstruktor kann auch keinen Rückgabetyp haben. Es kann Zugriffsmodifikatoren haben, aber es kann nicht endgültig, statisch, abstrakt oder synchronisiert sein.

Wenn ABC eine Klasse ist, können wir ihren Konstruktor als definieren

ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructor

F # 2) Was ist der Vorteil eines Konstruktors in Java?

Antworten: Mit dem Konstruktor können wir die Mitglieder der Klasse als erstes initialisieren, wenn das Objekt erstellt wird. Der Konstruktor macht das implizite Aufrufen normaler Methoden überflüssig.

Wir können verschiedene Aufgaben im Zusammenhang mit dem Initialisieren, Starten von Aufgaben usw. im Konstruktor ausführen, wenn Konstruktoren während der Objekterstellungsphase aufgerufen werden.

F # 3) Warum werden Konstruktoren verwendet?

Antworten: Konstruktoren werden hauptsächlich zum Initialisieren der Mitglieder der Klasse verwendet und beim Aufrufen des Objekts der Klasse aufgerufen.

F # 4) Kann der Konstruktor privat sein?

Antworten: Ja, wir können einen privaten Konstruktor haben. Wenn der Konstruktor privat ist, kann verhindert werden, dass die Klasse instanziiert.

F # 5) Kann der Konstruktor endgültig sein?

Antworten: Nein, wir können keinen endgültigen Konstruktor haben.

Fazit

In diesem Tutorial haben wir unsere Diskussion über Konstruktoren in Java begonnen. Wir haben die Grundlagen des Konstruktors, seine Erstellung und die zu befolgenden Regeln gelernt. Wir haben auch Kopierkonstruktoren in Java besprochen.

Der Standardkonstruktor und die Konstruktortypen sowie Konzepte wie Konstruktorüberladung und Konstruktorkettung wurden anhand von Beispielen erläutert. Als Teil dieser Themen haben wir auch die Verwendung des Schlüsselworts 'this' in Konstruktoren gesehen.

=> Lesen Sie die Easy Java Training Series durch.

Java-Konstruktor - Klassen-, Kopier- und Standardkonstruktoren