Introduzione a Destructor in Java

I distruttori in Java possono essere appresi con il metodo finalize in Java. Il concetto è uguale al metodo finalize. Java funziona per tutti tranne il distruttore con l'aiuto di Garbage Collection. Pertanto, nel caso in cui sia necessario chiamare il distruttore, è possibile farlo con l'aiuto del metodo finalize. Questo metodo non è indipendente in quanto si basa su Garbage Collection. Il garbage collector è un thread che elimina o distrugge l'oggetto inutilizzato nell'area dell'heap. Dire se l'oggetto è collegato a un file o dire alcune applicazioni di database o connessioni di rete, prima di eliminare o distruggere l'oggetto deve chiudere tutte le connessioni relative a queste risorse prima che avvenga la garbage collection. La chiusura delle funzioni viene effettuata chiamando il metodo finalize.

Definizione di Distruttore in Java

“Il distruttore è un metodo chiamato quando ha luogo la distruzione di un oggetto. "L'obiettivo principale del distruttore è liberare la memoria allocata e anche ripulire le risorse come la chiusura di file aperti, la chiusura delle connessioni al database, la chiusura delle risorse di rete, ecc.

Sintassi

Class Object
(
protected void finalize()
(
//statements like closure of database connection
)
)

Come funziona Destructor in Java?

Il distruttore ha un metodo finalize () in Java che è simile al distruttore in C ++. Quando vengono creati, gli oggetti vengono archiviati nella memoria dell'heap. Questi sono accessibili da thread principali o secondari. Pertanto, quando questi oggetti non vengono più utilizzati dal thread principale o dai thread secondari, diventano idonei per la garbage collection e la memoria acquisita ora diventa disponibile quando vengono creati nuovi oggetti. Prima che un oggetto sia spazzatura raccolto dal garbage collector, JRE (Java Runtime Environment) chiama il metodo finalize () per chiudere i flussi di input-output, le connessioni al database, le connessioni di rete, ecc. Si noti che il metodo finalize chiamato è protetto. Perché finalizzare è protetto perché può essere chiamato dalla classe base o dalla classe derivata? il metodo finalize è presente nella classe Object. Pertanto, nel caso in cui si desideri chiamare questo metodo finalize da altri oggetti, è possibile modificarlo come pubblico.

Sintassi:

protected void finalize throws Throwable()
(
//Keep some resource closing operations here
)

Metodi di finalize ()

  1. Il metodo finalize () è protetto come definito nella classe java.lang.Object.
  2. Il metodo finalize () viene chiamato solo una volta.
  3. per sovrascrivere il metodo finalize (), è necessario chiamare esplicitamente il metodo finalize.
  4. GC () è un servizio di JVM per eseguire Garbage Collection, viene chiamato quando la memoria dell'heap è piena e necessita di memoria per i nuovi oggetti in arrivo.
  5. JVM ignora tutte le eccezioni tranne le eccezioni non selezionate che si verificano nel metodo finalize.

Esempio 1

Nel programma seguente, viene chiamata la classe String corrispondente al metodo finalize anziché il metodo finalize presente nel programma. Il metodo finalize viene sovrascritto qui.

Codice:

public class Demo
(
public static void main(String() args)
(
Integer i = new Integer(2);
i = null;
System.gc();
System.out.println("In the Main Method");
)
protected void finalize()
(
System.out.println("object is garbage collected ");
)
)

Produzione:

Esempio n. 2

Nel programma seguente, il metodo finalize viene chiamato internamente, non è richiesta alcuna chiamata esplicita.

Codice

public class Demo
(
public static void main(String() args)
(
Demo dm = new Demo();
dm = null;
System.gc();
System.out.println("In the Main Method");
)
protected void finalize()
(
System.out.println("object is garbage collected ");
)
)

Produzione:

Esempio n. 3

Nel programma seguente, la finalizzazione è stata chiamata internamente in base al numero di oggetti creati.

Codice

public class NewProgram(
public void finalize()(
System.out.println("object is garbage collected");
)
public static void main(String args())(
NewProgram np1=new NewProgram(); //first instantiation of Class NewProgram
NewProgram np2=new NewProgram(); //second instantiation of Class NewProgram
np1=null;
np2=null;
System.gc();
System.out.println("In the Main Method");
)
)

Produzione:

Esempio n. 4

Nel programma seguente, vengono creati due oggetti, il finalizzatore viene chiamato una volta poiché entrambi gli oggetti puntano allo stesso.

Codice:

public class NewProgram(
public void finalize()(
System.out.println("garbage collected");
)
public static void main(String args())(
NewProgram np1=new NewProgram(); //first instantiation of Class NewProgram
NewProgram np2=new NewProgram(); //second instantiation of Class NewProgram
np1 = np2; // both now pointing to same object
System.gc();
System.out.println("in the Main Method");
)
)

Produzione:

Esempio n. 5

Nel programma seguente, il metodo finalize verrà chiamato due volte in modo esplicito e internamente entrambi.

Codice

public class Demo
(
public static void main(String() args)
(
Demo dm = new Demo();
dm.finalize();
dm = null;
System.gc();
System.out.println("In the Main Method");
)
protected void finalize()
(
System.out.println("garbage collected ");
)
)

Produzione:

Esempio n. 6

Nel programma seguente, esiste un'eccezione aritmetica chiamata nel metodo finalize in quanto viene esplicitamente chiamata che provoca ulteriormente l'eccezione e interrompe l'esecuzione del programma rimanente.

Codice:

public class Demo
(
public static void main(String() args)
(
Demo dm = new Demo();
dm.finalize();
dm = null;
System.gc();
System.out.println("In the Main Method");
)
protected void finalize()
(
System.out.println("garbage collected ");
System.out.println(10 / 0);
)
)

Produzione:

Esempio n. 7

Nel seguente programma, non vi è alcuna eccezione chiamata in quanto non viene chiamata esplicitamente e continua l'esecuzione del programma rimanente.

Codice:

public class Demo
(
public static void main(String() args)
(
Demo dm = new Demo();
dm = null;
System.gc();
System.out.println("In the Main Method");
)
protected void finalize()
(
System.out.println("garbage collected ");
System.out.println(10 / 0);
)
)

Produzione:

Vantaggi di Destructor in Java

  1. Il distruttore distrugge il valore creato dal costruttore nello spazio nella memoria dell'heap.
  2. Il distruttore viene sempre chiamato alla fine del programma.
  3. Il distruttore non è mai sovraccarico Il distruttore non accetta alcun argomento.
  4. Non c'è bisogno di definire il nostro costruttore, il compilatore crea per noi uno.

Conclusione

Spero che questo articolo sia stato interessante e informativo sia per te che per imparare l'argomento. Questo articolo ha trattato quasi tutti gli argomenti che stai cercando e spero soddisfi tutti i tuoi requisiti.

Articoli consigliati

Questa è stata una guida a Destructor in Java. Qui abbiamo discusso la definizione di distruttore in Java, come funziona il distruttore in Java con metodi, vantaggi ed esempi diversi. Puoi anche consultare il nostro altro articolo suggerito per saperne di più-

  1. Cos'è l'interfaccia Java?
  2. Cos'è l'interfaccia Java?
  3. Strumenti Java
  4. Layout in Java
  5. Costruttore e distruttore in Java
  6. Esempi di distruttore in Python
  7. JRE vs JVM | Le 8 principali differenze con (Infografica)
  8. Distruttore in PHP con esempi

Categoria:

Sviluppo software