Grafico comparativo
| Base per il confronto | Finale | Finalmente | ultimare |
|---|---|---|---|
| Di base | Final è una "Parola chiave" e un "modificatore di accesso" in Java. | Finalmente è un "blocco" in Java. | Finalizzare è un "metodo" in Java. |
| Applicabile | Finale è una parola chiave applicabile a classi, variabili e metodi. | Infine è un blocco che è sempre associato con try e catch block. | finalize () è un metodo applicabile agli oggetti. |
| Lavoro | (1) La variabile finale diventa costante e non può essere riassegnata. (2) Un metodo finale non può essere sovrascritto dalla classe figlio. (3) La classe finale non può essere estesa. | Un blocco "finally", ripulisce le risorse utilizzate nel blocco "try". | Il metodo Finalize esegue le attività di pulizia relative all'oggetto prima della sua distruzione. |
| Esecuzione | Il metodo finale viene eseguito al momento della chiamata. | Il blocco "Finally" viene eseguito subito dopo l'esecuzione del blocco "try-catch". | Il metodo finalize () viene eseguito immediatamente prima della distruzione dell'oggetto. |
Definizione di finale
"Finale" è una parola chiave in Java. È un modificatore di accesso. La parola chiave "finale" è applicabile a classi, metodi e variabili. Vediamo come funziona con ciascuno di essi.
Variabile finale
- Quando una parola chiave finale viene applicata alla variabile, non può essere ulteriormente modificata.
- Una variabile finale deve essere inizializzata quando viene dichiarata.
- In una comune convenzione di codifica, le variabili finali sono dichiarate in MAIUSCOLO.
- La variabile finale non occupa memoria su base istanza.
final int FILE_OPEN = 2;
Metodi finali
- Quando un metodo in classe è dichiarato definitivo, non può essere sostituito dalla sua sottoclasse.
- I piccoli metodi dichiarati definitivi possono essere resi "in linea" dal compilatore, riducendo il sovraccarico delle chiamate alle funzioni e aumentando i miglioramenti delle prestazioni.
- Chiamata di metodi sottoposti a override, vengono risolti dinamicamente, ma quando un metodo viene dichiarato definitivo, non può essere sovrascritto. Quindi, la chiamata alla funzione può essere risolta al momento della compilazione.
class A {final void meth () {System.out.println ("Questo è un metodo finale."); }} la classe B estende A {void meth () {// Clas B non può ereditare il metodo della classe A. System.out.println ("Non sovrascrive"); }} Classe finale
- Quando una classe viene dichiarata definitiva, non può essere ereditata da alcuna sottoclasse.
- Dichiarare una classe come definitiva dichiarerà automaticamente tutti i suoi metodi definitivi.
- Non puoi dichiarare una classe sia come "astratta" che come "finale".
la classe finale A {// ...} la classe B estende A {// la classe B non può ereditare la classe A // ...} Definizione di Finally
- In Java "finally" è un blocco che è sempre associato al blocco try / catch.
- Il blocco "finally" viene eseguito dopo il blocco try / catch e prima del codice che segue il blocco try / catch.
- Il blocco "finally" eseguirà se l'eccezione è lanciata o meno.
- Quando viene lanciata un'eccezione e nessun blocco catch corrisponde all'eccezione anche in quel momento, viene eseguito il blocco "finally".
- Quando un metodo ritorna al chiamante dall'interno del blocco try / catch tramite un'eccezione non rilevata o un'istruzione return esplicita, il blocco "finally" viene eseguito appena prima che il metodo ritorni al chiamante.
- Il blocco "finally" viene utilizzato per ripulire le risorse o liberare la memoria utilizzata nel blocco "try".
- Il blocco "finally" è facoltativo, ma è buona norma scrivere blocco finally dopo il blocco try / catch.
class FinallyExample {// Questo metodo genera un'eccezione dal metodo. static void procA () {try {System.out.println ("inside procA"); lanciare una nuova RuntimeException ("demo"); } infine {System.out.println ("procA's finally"); }} // Torna da un blocco try. static void procB () {try {System.out.println ("inside procB"); ritorno; } infine {System.out.println ("procB's finally"); }} // Esegue normalmente un blocco try. static void procC () {try {System.out.println ("inside procC"); } infine {System.out.println ("procC's finally"); }} public static void main (String args []) {try {procA (); } catch (Exception e) {System.out.println ("Eccezione rilevata"); } procB (); procC (); }} // output all'interno di procA procA's finally Eccezionalmente catturato all'interno di procB procB finalmente all'interno di procC procC's finalmente Definizione di Finalize
- Finalizzare è un metodo in una classe di oggetti.
- Un oggetto può contenere alcune risorse non java come handle di file; quindi deve essere liberato prima che venga distrutto.
- Questo metodo viene richiamato dal garbage collector prima che distrugga completamente l'oggetto.
- Questo metodo esegue le attività di pulizia per l'oggetto prima che venga distrutto.
La forma generale del metodo finalize () è la seguente.
protected void finalize () {// codice di finalizzazione qui} Il metodo finalize è dichiarato protetto in modo che non possa essere accessibile dall'esterno della classe.
Questo metodo viene sempre chiamato prima della garbage collection.
Differenze chiave tra finale, finale e finale
- La parola chiave final è un modificatore di accesso, infine è un blocco e finalize è un metodo.
- La parola chiave final è applicabile alle classi, variabili e metodi delle classi, infine è un blocco associato al blocco catch try che viene utilizzato per gestire le eccezioni, finalize è un metodo che opera solo sugli oggetti.
- La variabile dichiarata come definitiva diventa costante e non può essere nuovamente assegnata, un metodo dichiarato come finale non può essere sovrascritto e la classe dichiarata come definitiva non può mai essere ereditata. Il blocco finally viene utilizzato per ripulire le risorse utilizzate da try e catch block. Il metodo finalize viene utilizzato per ripulire le risorse utilizzate da un oggetto prima che l'oggetto venga distrutto.
Conclusione:
Finale, finalmente e finalizzato ha un effetto diverso se applicato su un metodo.
