IL oggetto è un elemento costitutivo di base di un Ops lingua. In Giava , non possiamo eseguire alcun programma senza creare un file oggetto . Esistono vari modi per farlo creare un oggetto in Java di cui parleremo in questa sezione e impareremo anche come creare un oggetto in Java.
Giava fornisce cinque modi per creare un oggetto.
- Utilizzando nuovo Parola chiave
- Utilizzando clone() metodo
- Utilizzando nuova istanza() metodo del Classe classe
- Utilizzando nuova istanza() metodo del Costruttore classe
- Utilizzando Deserializzazione
Utilizzo della nuova parola chiave
Usando il nuovo La parola chiave è il modo più popolare per creare un oggetto o un'istanza della classe. Quando creiamo un'istanza della classe utilizzando la parola chiave new, alloca memoria (heap) per quella appena creata oggetto e restituisce anche il file riferimento di quell'oggetto a quel ricordo. La nuova parola chiave viene utilizzata anche per creare un array. La sintassi per creare un oggetto è:
ClassName object = new ClassName();
Creiamo un programma che utilizza la nuova parola chiave per creare un oggetto.
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(); } } Produzione:
Welcome to javaTpoint
Utilizzando la parola chiave new possiamo anche invocare il costruttore (predefinito o parametrizzato) della classe.
CreateObjectExample2.java
eseguire script in Linux
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(); } } Produzione:
Welcome to javaTpoint
Utilizzando il metodo clone()
IL clone() il metodo è il metodo di Oggetto classe. Crea una copia di un oggetto e restituisce la stessa copia. IL JVM crea un nuovo oggetto quando viene richiamato il metodo clone(). Copia tutto il contenuto dell'oggetto creato in precedenza in un nuovo oggetto. Tieni presente che non chiama alcun costruttore. Dobbiamo implementare il Clonabile interfaccia durante l'utilizzo del metodo clone(). Il metodo lancia CloneNotSupportedException eccezione se la classe dell'oggetto non supporta l'interfaccia Cloneable. Le sottoclassi che sovrascrivono il metodo clone() possono lanciare un'eccezione se un'istanza non può essere clonata.
Nota: il metodo crea una copia dell'oggetto e non un nuovo oggetto.
Sintassi:
protected Object clone() throws CloneNotSupportedException
Usiamo la seguente istruzione per creare un nuovo oggetto.
ClassName newobject = (ClassName) oldobject.clone();
CreateObjectExample3.java
gimp cambia colore
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(); } } } Produzione:
New Object Created
Utilizzo del metodo newInstance() della classe Class
IL nuova istanza() Il metodo della classe Class viene utilizzato anche per creare un oggetto. Chiama il costruttore predefinito per creare l'oggetto. Restituisce un'istanza appena creata della classe rappresentata dall'oggetto. Utilizza internamente il metodo newInstance() della classe Constructor.
Sintassi:
public T newInstance() throws InstantiationException, IllegalAccessException
Lancia il IllegalAccessException, InstantiationException, ExceptionInInitializerError eccezioni.
Possiamo creare un oggetto nei seguenti modi:
ClassName object = ClassName.class.newInstance();
O
ClassName object = (ClassName) Class.forName('fully qualified name of the class').newInstance();
Nella dichiarazione di cui sopra, perNome() è un metodo statico della classe Class. Analizza un parametro nome della classe di tipo String. Restituisce l'oggetto per la classe con il nome completo. Carica la classe ma non crea alcun oggetto. Lancia ClassNotFoundException se la classe non può essere caricata e Errore di collegamento se il collegamento fallisce.
Per creare l'oggetto, utilizziamo il file nuova istanza() metodo della classe Class. Funziona solo quando conosciamo il nome della classe e la classe ha un costruttore pubblico predefinito.
Nel seguente programma, abbiamo creato un nuovo oggetto utilizzando il metodo 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(); } } } Produzione:
un milione in numeri
A new object created.
Utilizzo del metodo newInstance() della classe Costruttore
È simile al nuova istanza() metodo del Classe classe. È noto come un modo riflessivo per creare oggetti. Il metodo è definito nell'art Costruttore classe che è la classe dijava.lang.reflectpacchetto. Possiamo anche chiamare il costruttore parametrizzato e il costruttore privato utilizzando il metodo nuova istanza() metodo. È ampiamente preferito rispetto al metodo newInstance() della classe Class.
Sintassi:
public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
Il metodo analizza un array di oggetti come argomento. I valori dei tipi primitivi racchiusi in un wrapper Object del tipo appropriato. Restituisce un nuovo oggetto creato chiamando il costruttore. Lancia Eccezioni IllegalAccessException, IllegalArgumentException, InstantiationException, InvocationTargetException, ExceptionInInitializerError .
Possiamo creare un oggetto nel modo seguente:
Constructor constructor = Employee.class.getConstructor(); Employee emp3 = constructor.newInstance();
Creiamo un programma che crea un oggetto utilizzando il metodo newInstance().
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(); } } } Produzione:
JavaTpoint
Utilizzo della deserializzazione
A Giava, serializzazione è il processo di conversione di un oggetto in una sequenza di flusso di byte. Viene chiamato il processo inverso (dal flusso di byte all'oggetto) della serializzazione deserializzazione . La JVM crea un nuovo oggetto quando serializziamo o deserializziamo un oggetto. Non utilizza il costruttore per creare un oggetto. Durante l'utilizzo della deserializzazione, il file Serializzabile L'interfaccia (interfaccia marcatore) deve essere implementata nella classe.
Serializzazione: IL scrivereOggetto() metodo del OggettoOutputStream La classe viene utilizzata per serializzare un oggetto. Invia l'oggetto al flusso di output.
Sintassi:
bash altrimenti se
public final void writeObject(object x) throws IOException
Deserializzazione: Il metodo leggiOggetto() Di OggettoInputStream La classe viene utilizzata per deserializzare un oggetto. Fa riferimento a oggetti fuori da un flusso.
Sintassi:
public final Object readObject() throws IOException,ClassNotFoundException
Nota: rendere il campo statico o transitorio se non vogliamo includere un campo come parte dell'oggetto. Non sarà incluso nel processo di serializzazione.
Comprendiamo la serializzazione e la deserializzazione attraverso un programma.
Dipendente.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; } } Abbiamo creato una classe denominata Dipendente il cui oggetto è essere serializzato e deserializzato.
Serializzazione dell'oggetto Java:
Nel seguente programma, abbiamo serializzato un oggetto della classe Employee utilizzando il metodo scrivereOggetto() metodo della classe ObjectOutputStream. Lo stato dell'oggetto viene salvato nel file dipendente.txt file.
SerializationExample.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); } } } Produzione:
Shilpa Shetty
Successfully Created
Deserializzazione dell'oggetto Java:
Nel programma seguente deserializzeremo un oggetto che abbiamo serializzato nel programma precedente.
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); } } } Produzione:
198054 Andrew
Nei cinque metodi precedenti, abbiamo notato che il file nuovo parola chiave ed entrambi nuova istanza() i metodi utilizzano il costruttore per creare oggetti, mentre gli altri due metodi non utilizzano il costruttore.