Différence clé - final vs finalement vs finaliser en Java
Le final, finalement et finaliser sont des termes couramment utilisés dans la programmation Java. La finale est un mot clé. Il peut être utilisé pour des variables, des méthodes ou des classes. Les variables déclarées finales ne doivent être initialisées qu'une seule fois. Ils ne peuvent pas être modifiés. Comme Java est un langage qui prend en charge la programmation orientée objet, il permet de créer des classes à partir de classes existantes pour améliorer la réutilisabilité du code. Parfois, il peut être nécessaire d'éviter d'utiliser les classes existantes. Pour cela, final peut être utilisé. En programmation, il peut y avoir des erreurs, et il est important de les gérer pour exécuter correctement le programme. La finalize est une méthode appelée par le ramasse-miettes. Donc, tous ces termes ont des significations différentes en conséquence. Le final est un mot-clé qui empêche la modification des variables, évite le remplacement des méthodes et évite l'extension des classes. Le finally est un bloc dans la gestion des exceptions, qui s'exécutera qu'une exception soit levée ou non. La finalize est une méthode appelée par le ramasse-miettes avant qu'il ne détruise complètement l'objet. C'est la principale différence finale enfin et finaliser en Java.
Qu'est-ce qui est final en Java ?
La finale est un mot clé en Java. Comme Java prend en charge la programmation orientée objet, les sous-classes peuvent utiliser les variables et les méthodes d'une classe déjà existante. La classe déjà existante est la superclasse tandis que la nouvelle classe est la sous-classe. Si le programmeur veut empêcher la variable d'être accessible par d'autres classes, il peut déclarer la variable comme "finale". Par exemple, supposons qu'il existe une variable en tant que p. Il est déclaré final et initialisé à la valeur 10.par exemple. final int p=10. Si la valeur p est à nouveau changée en 20, cela provoquera une erreur de compilation. Le dernier mot clé empêche de changer la valeur de la variable.
Une classe peut utiliser une méthode qui est déjà dans une classe existante. Supposons qu'il existe une classe appelée B qui a une méthode display(). La nouvelle classe est C, et elle étend la classe B. Si la classe C a également une méthode appelée display(), alors la méthode originale display() de la classe B est remplacée. Si le programmeur veut éviter que la méthode soit prioritaire, il peut alors utiliser le mot clé finally. par exemple. affichage vide final(){ }. Rendre une méthode finale garantit que la fonctionnalité de la méthode ne sera jamais altérée.
Figure 01: final, enfin et finaliser
Il est également possible d'utiliser le mot clé final pour une classe. La nouvelle classe ne peut pas hériter des variables et des méthodes d'une classe finale. Ceci est utile pour augmenter la sécurité. Comme la classe est empêchée d'être utilisée par les sous-classes, les données sont protégées.
Qu'y a-t-il finalement en Java ?
En programmation, il peut y avoir des erreurs. Les erreurs peuvent provoquer des sorties incorrectes ou mettre fin à l'exécution d'un programme. Il est important d'utiliser une sorte de mécanisme pour empêcher ces résultats inattendus. Les erreurs peuvent être de deux types. Ce sont des erreurs de temps compilées et des erreurs d'exécution. Des erreurs de temps de compilation se produisent en raison d'erreurs syntaxiques. Certaines erreurs courantes de compilation manquent le point-virgule, les accolades manquantes, les identificateurs mal orthographiés, les mots-clés et les variables non déclarées. Le compilateur ne créera pas le fichier.class tant que ces erreurs ne seront pas corrigées.
Parfois, il peut y avoir des programmes qui se compilent correctement mais qui donnent une mauvaise sortie. Elles sont appelées erreurs d'exécution. Certaines erreurs d'exécution courantes consistent à plonger un entier par zéro et à accéder à un élément qui est hors des limites d'un tableau. Ces erreurs ne provoqueront pas d'erreur au moment de la compilation, mais la sortie est incorrecte. Une exception est une condition provoquée par une erreur d'exécution dans le programme.
Lorsqu'il y a une erreur d'exécution, Java crée un objet d'exception et le lance. Si l'objet exception n'est pas intercepté correctement, il affichera un message d'erreur et mettra fin au programme. Si le programmeur veut continuer l'exécution du programme avec le reste du code, il doit intercepter l'objet exception et afficher le message nécessaire pour l'action corrective. Ce processus est connu sous le nom de gestion des exceptions.
En Java, try est utilisé pour le code susceptible de provoquer une erreur et de lever une exception. Le catch est utilisé pour gérer l'exception levée par le bloc try. Il peut y avoir plusieurs instructions catch. Les instructions finally peuvent être utilisées pour gérer une exception qui n'est interceptée par aucune des instructions catch précédentes. Le bloc finally s'exécutera, qu'une exception soit levée ou non. Reportez-vous à l'exemple donné.
int p=10, q=5, r=5;
réponse entière;
essayer{
réponse=p / (q – r);
}
catch (ArithmeticException e){
System.out.println("Divisé par zéro");
}
finalement{
System.out.println("Le bloc finally est exécuté");
}
Selon l'exemple ci-dessus, la valeur p est divisée par zéro, et cela provoquera une exception. Par conséquent, il est capturé par l'instruction catch. Il imprimera le message, Divisé par zéro. Le bloc finally s'exécutera qu'une exception se soit produite ou non. Après le message Divisé par zéro, le message à l'intérieur du bloc finally s'affichera. Par conséquent, finally est un bloc utilisé dans la gestion des exceptions.
Qu'est-ce que la finalisation en Java ?
En POO, les objets sont créés à l'aide de classes. La méthode constructeur peut initialiser un objet lors de sa déclaration. Le processus est connu sous le nom d'initialisation. Java a également un concept appelé finalisation. Le runtime Java est un ramasse-miettes automatique. Il libère automatiquement les ressources mémoire utilisées par les objets. Le ramasse-miettes appelle cette méthode avant de détruire l'objet.
Certains objets peuvent contenir des ressources non-objet. Un exemple est un descripteur de fichier. Dans ces situations, le ramasse-miettes appelle la méthode finalize. par exemple. finaliser(). Cette méthode effectue un traitement de nettoyage juste avant que l'objet ne soit ramassé.
Quelle est la similarité entre final finally et finalize en Java ?
All final, finally et finalize en Java sont utilisés dans la programmation Java
Quelle est la différence entre final finally et finalize en Java ?
final vs finalement vs finalize |
|
| finale | Le final est un mot-clé en Java qui empêche la modification des variables, évite le remplacement des méthodes et évite l'extension des classes. |
| enfin | Le finally est un bloc dans la gestion des exceptions Java, qui s'exécutera qu'une exception soit levée ou non. |
| finaliser | La finalize est une méthode en Java, appelée par le ramasse-miettes avant qu'il ne détruise complètement l'objet. |
| Applicabilité | |
| finale | La finale est applicable pour les variables, les méthodes et les classes. |
| enfin | Le final est applicable avec un try and catch blocks. |
| finaliser | La finalisation est applicable pour les objets. |
Résumé - final vs finalement vs finaliser en Java
Le final, enfin et finaliser sont des termes couramment utilisés dans la programmation Java. Leurs mots semblent les mêmes, mais ils ont une différence. Le final est un mot clé qui empêche la modification des variables, évite le remplacement des méthodes et évite l'extension des classes. Le finally est un bloc dans la gestion des exceptions, qui s'exécutera qu'une exception soit levée ou non. La finalize est une méthode appelée par le ramasse-miettes avant qu'il ne détruise complètement l'objet. C'est la différence entre final, finally et finalize en programmation Java.
Télécharger le PDF de finale vs finalement vs finaliser en Java
Vous pouvez télécharger la version PDF de cet article et l'utiliser à des fins hors ligne conformément à la note de citation. Veuillez télécharger la version PDF ici: Différence entre la finale et la finalisation en Java
