Der Objekt ist ein Grundbaustein einer Hoppla Sprache. In Java , wir können kein Programm ausführen, ohne ein zu erstellen Objekt . Es gibt verschiedene Möglichkeiten Erstelle ein Objekt in Java die wir in diesem Abschnitt besprechen und auch lernen werden wie man ein Objekt in Java erstellt.
Java bietet fünf Möglichkeiten zum Erstellen eines Objekts.
- Benutzen neu Stichwort
- Benutzen Klon() Methode
- Benutzen newInstance() Methode der Klasse Klasse
- Benutzen newInstance() Methode der Konstrukteur Klasse
- Benutzen Deserialisierung
Verwendung eines neuen Schlüsselworts
Verwendung der neu Das Schlüsselwort ist die beliebteste Methode zum Erstellen eines Objekts oder einer Instanz der Klasse. Wenn wir mit dem Schlüsselwort new eine Instanz der Klasse erstellen, reserviert sie Speicher (Heap) für die neu erstellte Klasse Objekt und gibt auch die zurück Referenz dieses Objekts zu dieser Erinnerung. Das Schlüsselwort new wird auch zum Erstellen eines Arrays verwendet. Die Syntax zum Erstellen eines Objekts lautet:
ClassName object = new ClassName();
Lassen Sie uns ein Programm erstellen, das das Schlüsselwort new verwendet, um ein Objekt zu erstellen.
CreateObjectExample1.java
public class CreateObjectExample1 { void show() { System.out.println('Welcome to javaTpoint'); } public static void main(String[] args) { //creating an object using new keyword CreateObjectExample1 obj = new CreateObjectExample1(); //invoking method using the object obj.show(); } } Ausgabe:
Welcome to javaTpoint
Durch die Verwendung des Schlüsselworts new können wir auch den Konstruktor (Standard oder parametrisiert) der Klasse aufrufen.
CreateObjectExample2.java
wie man char in string umwandelt
public class CreateObjectExample2 { //constructor of the class CreateObjectExample2() { System.out.println('Welcome to javaTpoint'); } public static void main(String[] args) { //creating an object using new keyword CreateObjectExample2 obj = new CreateObjectExample2(); } } Ausgabe:
Welcome to javaTpoint
Verwenden der clone()-Methode
Der Klon() Methode ist die Methode von Objekt Klasse. Es erstellt eine Kopie eines Objekts und gibt dieselbe Kopie zurück. Der JVM erstellt ein neues Objekt, wenn die clone()-Methode aufgerufen wird. Es kopiert den gesamten Inhalt des zuvor erstellten Objekts in ein neues Objekt. Beachten Sie, dass kein Konstruktor aufgerufen wird. Wir müssen das umsetzen Klonbar Schnittstelle bei Verwendung der clone()-Methode. Die Methode wirft CloneNotSupportedException Ausnahme, wenn die Klasse des Objekts die Cloneable-Schnittstelle nicht unterstützt. Die Unterklassen, die die Methode clone() überschreiben, können eine Ausnahme auslösen, wenn eine Instanz nicht geklont werden kann.
Hinweis: Die Methode erstellt eine Kopie des Objekts, kein neues Objekt.
Syntax:
protected Object clone() throws CloneNotSupportedException
Wir verwenden die folgende Anweisung, um ein neues Objekt zu erstellen.
ClassName newobject = (ClassName) oldobject.clone();
CreateObjectExample3.java
Gimp Farbe ändern
public class CreateObjectExample3 implements Cloneable { @Override protected Object clone() throws CloneNotSupportedException { //invokes the clone() method of the super class return super.clone(); } String str = 'New Object Created'; public static void main(String[] args) { //creating an object of the class CreateObjectExample3 obj1 = new CreateObjectExample3(); //try catch block to catch the exception thrown by the method try { //creating a new object of the obj1 suing the clone() method CreateObjectExample3 obj2 = (CreateObjectExample3) obj1.clone(); System.out.println(obj2.str); } catch (CloneNotSupportedException e) { e.printStackTrace(); } } } Ausgabe:
New Object Created
Verwenden der Methode newInstance() der Klasse class
Der newInstance() Die Methode der Class-Klasse wird auch zum Erstellen eines Objekts verwendet. Es ruft den Standardkonstruktor auf, um das Objekt zu erstellen. Es gibt eine neu erstellte Instanz der durch das Objekt dargestellten Klasse zurück. Es verwendet intern die newInstance()-Methode der Constructor-Klasse.
Syntax:
public T newInstance() throws InstantiationException, IllegalAccessException
Es wirft die IllegalAccessException, InstantiationException, ExceptionInInitializerError Ausnahmen.
Wir können ein Objekt auf folgende Weise erstellen:
ClassName object = ClassName.class.newInstance();
Oder
ClassName object = (ClassName) Class.forName('fully qualified name of the class').newInstance();
In der obigen Aussage forName() ist eine statische Methode der Klasse Klasse. Es analysiert einen Parameter Klassenname vom Typ String. Es gibt das Objekt für die Klasse mit dem vollständig qualifizierten Namen zurück. Es lädt die Klasse, erstellt jedoch kein Objekt. Es wirft ClassNotFoundException wenn die Klasse nicht geladen werden kann und Verknüpfungsfehler wenn die Verknüpfung fehlschlägt.
Um das Objekt zu erstellen, verwenden wir die newInstance() Methode der Class-Klasse. Es funktioniert nur, wenn wir den Namen der Klasse kennen und die Klasse über einen öffentlichen Standardkonstruktor verfügt.
Im folgenden Programm haben wir mit der Methode newInstance() ein neues Objekt erstellt.
Java ist gleich
CreateObjectExample4.java
public class CreateObjectExample4 { void show() { System.out.println('A new object created.'); } public static void main(String[] args) { try { //creating an instance of Class class Class cls = Class.forName('CreateObjectExample4'); //creates an instance of the class using the newInstance() method CreateObjectExample4 obj = (CreateObjectExample4) cls.newInstance(); //invoking the show() method obj.show(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } } Ausgabe:
A new object created.
Verwendung der newInstance()-Methode der Konstruktorklasse
Es ähnelt dem newInstance() Methode der Klasse Klasse. Es ist als reflexive Art, Objekte zu erstellen, bekannt. Die Methode ist in der definiert Konstrukteur Klasse, die die Klasse von istjava.lang.reflectPaket. Wir können den parametrisierten Konstruktor und den privaten Konstruktor auch aufrufen, indem wir verwenden newInstance() Methode. Sie wird im Vergleich zur Methode newInstance() der Klasse Class weithin bevorzugt.
Syntax:
public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
Die Methode analysiert ein Array von Objekten als Argument. Die Werte primitiver Typen, verpackt in ein Wrapper-Objekt des entsprechenden Typs. Es gibt ein neues Objekt zurück, das durch den Aufruf des Konstruktors erstellt wurde. Es wirft IllegalAccessException, IllegalArgumentException, InstantiationException, InvocationTargetException, ExceptionInInitializerError Ausnahmen .
Wir können ein Objekt auf folgende Weise erstellen:
Constructor constructor = Employee.class.getConstructor(); Employee emp3 = constructor.newInstance();
Lassen Sie uns ein Programm erstellen, das mithilfe der Methode newInstance() ein Objekt erstellt.
CreateObjectExample5.java
import java.lang.reflect.*; public class CreateObjectExample5 { private String str; CreateObjectExample5() { } public void setName(String str) { this.str = str; } public static void main(String[] args) { try { Constructor constructor = CreateObjectExample5.class.getDeclaredConstructor(); CreateObjectExample5 r = constructor.newInstance(); r.setName('JavaTpoint'); System.out.println(r.str); } catch (Exception e) { e.printStackTrace(); } } } Ausgabe:
JavaTpoint
Deserialisierung verwenden
In Java, Serialisierung ist der Prozess der Konvertierung eines Objekts in eine Folge von Byteströmen. Der umgekehrte Prozess (Byte-Stream zum Objekt) der Serialisierung wird aufgerufen Deserialisierung . Die JVM erstellt ein neues Objekt, wenn wir ein Objekt serialisieren oder deserialisieren. Zum Erstellen eines Objekts wird kein Konstruktor verwendet. Bei der Verwendung der Deserialisierung wird die Serialisierbar Schnittstelle (Markerschnittstelle) muss in der Klasse implementiert sein.
Serialisierung: Der writeObject() Methode der ObjectOutputStream Die Klasse wird zum Serialisieren eines Objekts verwendet. Es sendet das Objekt an den Ausgabestream.
10 ml zu Unzen
Syntax:
public final void writeObject(object x) throws IOException
Deserialisierung: Die Methode readObject() von ObjectInputStream Die Klasse wird zum Deserialisieren eines Objekts verwendet. Es verweist auf Objekte aus einem Stream.
Syntax:
public final Object readObject() throws IOException,ClassNotFoundException
Hinweis: Machen Sie die Datei statisch oder transient, wenn wir kein Feld als Teil des Objekts einschließen möchten. Es wird nicht in den Serialisierungsprozess einbezogen.
Lassen Sie uns die Serialisierung und Deserialisierung durch ein Programm verstehen.
Employee.java
import java.io.Serializable; public class Employee implements Serializable { int empid; String empname; public Empoyee(int empid, String empname) { this.empid = empid; this.empname = empname; } } Wir haben eine Klasse mit dem Namen erstellt Mitarbeiter dessen Objekt serialisiert und deserialisiert werden soll.
Serialisierung von Java-Objekten:
Im folgenden Programm haben wir ein Objekt der Employee-Klasse mithilfe von serialisiert writeObject() Methode der ObjectOutputStream-Klasse. Der Zustand des Objekts wird im gespeichert mitarbeiter.txt Datei.
SerializationExample.java
sie sind Sänger
import java.io.*; class SerializationExample { public static void main(String args[]) { Try { //Creating the object Employee emp = new Employee(198054,'Andrew'); //Creates a stream and writes the object FileOutputStream fout=new FileOutputStream('employee.txt'); ObjectOutputStream out=new ObjectOutputStream(employeeout); out.writeObject(emp); out.flush(); //closes the output stream out.close(); System.out.println('Successfully Created'); } catch(Exception e) { System.out.println(e); } } } Ausgabe:
Successfully Created
Deserialisierung eines Java-Objekts:
Im folgenden Programm deserialisieren wir ein Objekt, das wir im obigen Programm serialisiert haben.
DeserializationExample.java
import java.io.*; class DeserializationExample { public static void main(String args[]) { try { //Creating a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('employee.txt')); Employee e=(Employee)in.readObject(); //prints the data of the serialized object System.out.println(e.empid+' '+e.empname); //closing the input stream in.close(); } catch(Exception e) { System.out.println(e); } } } Ausgabe:
198054 Andrew
Bei den oben genannten fünf Methoden ist uns aufgefallen, dass die neu Schlüsselwort und beides newInstance() Methoden verwenden den Konstruktor zum Erstellen von Objekten, während die anderen beiden Methoden den Konstruktor nicht verwenden.