De voorwerp is een fundamentele bouwsteen van een OOP's taal. In Java , kunnen we geen enkel programma uitvoeren zonder een voorwerp . Er zijn verschillende manieren om Creëer een object op Java die we in deze sectie zullen bespreken, en ook zullen leren hoe u een object in Java maakt.
Java biedt vijf manieren om een object te maken.
- Gebruik makend van nieuw Trefwoord
- Gebruik makend van kloon() methode
- Gebruik makend van nieuweInstance() werkwijze van de Klas klas
- Gebruik makend van nieuweInstance() werkwijze van de Constructeur klas
- Gebruik makend van Deserialisatie
Nieuw zoekwoord gebruiken
De ... gebruiken nieuw trefwoord is de meest populaire manier om een object of instantie van de klasse te maken. Wanneer we een instantie van de klasse maken met behulp van het nieuwe sleutelwoord, wijst deze geheugen (heap) toe voor de nieuw gemaakte voorwerp en geeft ook de referentie van dat object naar die herinnering. Het nieuwe trefwoord wordt ook gebruikt om een array te maken. De syntaxis voor het maken van een object is:
ClassName object = new ClassName();
Laten we een programma maken dat new trefwoord gebruikt om een object te maken.
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(); } } Uitgang:
Welcome to javaTpoint
Door het nieuwe sleutelwoord te gebruiken, kunnen we ook de constructor (standaard of geparametriseerd) van de klasse aanroepen.
CreateObjectExample2.java
discrete wiskundige ontkenning
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(); } } Uitgang:
Welcome to javaTpoint
Met behulp van de clone()-methode
De kloon() methode is de methode van Voorwerp klas. Er wordt een kopie van een object gemaakt en dezelfde kopie geretourneerd. De JVM creëert een nieuw object wanneer de clone() methode wordt aangeroepen. Het kopieert alle inhoud van het eerder gemaakte object naar een nieuw object. Merk op dat er geen enkele constructor wordt aangeroepen. Wij moeten de implementatie uitvoeren Kloonbaar interface tijdens het gebruik van de clone()-methode. De methode gooit CloneNotSupportedException uitzondering als de klasse van het object de Cloneable-interface niet ondersteunt. De subklassen die de methode clone() overschrijven, kunnen een uitzondering genereren als een instantie niet kan worden gekloond.
Opmerking: de methode maakt een kopie van het object en geen nieuw object.
Syntaxis:
protected Object clone() throws CloneNotSupportedException
We gebruiken de volgende instructie om een nieuw object te maken.
ClassName newobject = (ClassName) oldobject.clone();
CreateObjectExample3.java
iets voor vriendjes
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(); } } } Uitgang:
New Object Created
Met behulp van newInstance() Methode van klasseklasse
De nieuweInstance() methode van de klasse Class wordt ook gebruikt om een object te maken. Het roept de standaardconstructor aan om het object te maken. Het retourneert een nieuw gemaakte instantie van de klasse die door het object wordt vertegenwoordigd. Het gebruikt intern de methode newInstance() van de klasse Constructor.
Syntaxis:
public T newInstance() throws InstantiationException, IllegalAccessException
Het gooit de Illegale toegangUitzondering, InstantiationException, ExceptionInInitializerError uitzonderingen.
We kunnen op de volgende manieren een object maken:
ClassName object = ClassName.class.newInstance();
Of
ClassName object = (ClassName) Class.forName('fully qualified name of the class').newInstance();
In de bovenstaande verklaring staat voorNaam() is een statische methode van Class-klasse. Het parseert een parameter naam van de klasse van het type String. Het retourneert het object voor de klasse met de volledig gekwalificeerde naam. Het laadt de klasse, maar creëert geen enkel object. Het gooit ClassNotFoundException als de klasse niet kan worden geladen en Koppelingsfout als de koppeling mislukt.
Om het object te maken, gebruiken we de nieuweInstance() methode van de klasse Class. Het werkt alleen als we de naam van de klasse kennen en de klasse een openbare standaardconstructor heeft.
In het volgende programma hebben we een nieuw object gemaakt met behulp van de methode newInstance().
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(); } } } Uitgang:
A new object created.
Met behulp van newInstance() Methode van Constructor-klasse
Het is vergelijkbaar met de nieuweInstance() werkwijze van de Klas klas. Het staat bekend als een reflecterende manier om objecten te creëren. De methode is gedefinieerd in de Constructeur klasse die de klasse is vanjava.lang.reflectpakket. We kunnen ook de geparametriseerde constructor en de privéconstructor aanroepen met behulp van de nieuweInstance() methode. Het heeft algemeen de voorkeur in vergelijking met de newInstance()-methode van de klasse Class.
instellingenmenu openen
Syntaxis:
public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
De methode ontleedt een array van objecten als argument. De waarden van primitieve typen verpakt in een wrapper-object van het juiste type. Het retourneert een nieuw object dat is gemaakt door de constructor aan te roepen. Het gooit IllegalAccessException, IllegalArgumentException, InstantiationException, InvocationTargetException, ExceptionInInitializerError-uitzonderingen .
We kunnen op de volgende manier een object maken:
Constructor constructor = Employee.class.getConstructor(); Employee emp3 = constructor.newInstance();
Laten we een programma maken dat een object maakt met behulp van de newInstance() -methode.
CreateObjectExample5.java
teken om Java te stringen
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(); } } } Uitgang:
JavaTpoint
Deserialisatie gebruiken
Op Java, serialisatie is het proces waarbij een object wordt omgezet in een reeks bytestreams. Het omgekeerde proces (byte-stream naar object) van serialisatie wordt aangeroepen deserialisatie . De JVM maakt een nieuw object wanneer we een object serialiseren of deserialiseren. Er wordt geen constructor gebruikt om een object te maken. Bij gebruik van deserialisatie wordt de Serialiseerbaar interface (markerinterface) moet in de klasse worden geïmplementeerd.
Serialisatie: De schrijfObject() werkwijze van de ObjectOutputStream klasse wordt gebruikt om een object te serialiseren. Het stuurt het object naar de uitvoerstroom.
Syntaxis:
public final void writeObject(object x) throws IOException
Deserialisatie: De methode leesObject() van ObjectInputStream klasse wordt gebruikt om een object te deserialiseren. Het verwijst naar objecten uit een stream.
Syntaxis:
public final Object readObject() throws IOException,ClassNotFoundException
Opmerking: Maak het bestand statisch of tijdelijk als we geen veld als onderdeel van het object willen opnemen. Het wordt niet opgenomen in het serialisatieproces.
Laten we de serialisatie en deserialisatie via een programma begrijpen.
Werknemer.java
wat is een hashset in 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; } } We hebben een klasse gemaakt met de naam Medewerker waarvan het doel is om te serialiseren en te deserialiseren.
Serialisatie van Java-object:
In het volgende programma hebben we een object van de klasse Employee geserialiseerd met behulp van de schrijfObject() methode van de ObjectOutputStream-klasse. De status van het object wordt opgeslagen in het medewerker.txt bestand.
SerialisatieVoorbeeld.java
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); } } } Uitgang:
Successfully Created
Deserialisatie van Java-object:
In het volgende programma gaan we een object deserialiseren dat we in het bovenstaande programma hebben geserialiseerd.
DeserialisatieExample.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); } } } Uitgang:
198054 Andrew
Bij de bovenstaande vijf methoden hebben we gemerkt dat de nieuw trefwoord en beide nieuweInstance() methoden gebruiken de constructor om objecten te maken, terwijl de overige twee methoden de constructor niet gebruiken.