Pause café #134. Ce qu'il faut éviter lors de l'écriture de code Java. Comment final, final et finalize sont utilisés en Java

Ce qu'il faut éviter lors de l'écriture de code Java

Source : Medium Nous attirons votre attention sur un article répertoriant les erreurs courantes que commettent les développeurs lors de l'écriture de code Java.

Utilisation d'Enum.values

Que cela soit considéré comme un bug m'a surpris puisque j'utilisais régulièrement Enum.values ​​​​. Le problème ici est que Enum.values() est censé être une liste immuable par spécification. Pour ce faire, il doit renvoyer une nouvelle instance du tableau avec les valeurs enum à chaque appel.

public enum Fruits {
    APPLE, PEAR, ORANGE, BANANA;

    public static void main(String[] args) {
        System.out.println(Fruits.values());
        System.out.println(Fruits.values());
    }
}
// output
// [Lcom.test.Fruits;@7ad041f3
// [Lcom.test.Fruits;@251a69d7

Il y a deux objets distincts en mémoire ici, donc cela ne semble pas être un gros problème. Mais si vous utilisez Fruit.values() lors du traitement d'une requête et que votre charge est élevée, cela peut entraîner des problèmes de mémoire. Vous pouvez facilement résoudre ce problème en introduisant une variable finale statique privée VALUES pour la mise en cache.

Passer des paramètres facultatifs en tant que paramètre de méthode

Considérez le code suivant :

LocalDateTime getCurrentTime(Optional<ZoneId> zoneId) {
    return zoneId.stream()
        .map(LocalDateTime::now)
        .findFirst()
        .orElse(LocalDateTime.now(ZoneId.systemDefault()));
}

Nous passons le paramètre facultatif zoneId et, en fonction de sa présence, décidons s'il faut donner l'heure dans le fuseau horaire du système ou utiliser le fuseau spécifié. Cependant, ce n'est pas la bonne façon de travailler avec Optionnel. Nous devrions éviter de les utiliser comme paramètres et utiliser plutôt la surcharge de méthodes.

LocalDateTime getCurrentTime(ZoneId zoneId) {
  return LocalDateTime.now(zoneId);
}

LocalDateTime getCurrentTime() {
  return getCurrentTime(ZoneId.systemDefault());
}

Le code que vous voyez ci-dessus est beaucoup plus facile à lire et à déboguer.

Utiliser StringBuilder

Les chaînes en Java sont immuables. Cela signifie qu'une fois créés, ils ne sont plus modifiables. La JVM maintient un pool de chaînes et, avant d'en créer un nouveau, appelle la méthode String.intern() , qui renvoie une instance du pool de chaînes correspondant à la valeur, si elle existe. Disons que nous voulons créer une longue chaîne en y concaténant des éléments.

String longString = new StringBuilder()
  .append("start")
  .append("middle")
  .append("middle")
  .append("middle")
  .append("end")
  .toString();

On nous a récemment dit que c'était une très mauvaise idée car les anciennes versions de Java faisaient ce qui suit :

• à la ligne 1, la chaîne « start » est insérée dans le pool de chaînes et pointée par longString
• la ligne 2 ajoute la chaîne « startmiddle » au pool et pointe vers elle avec longString
• à la ligne 3 nous avons « startmiddlemiddle »
• à la ligne 4 - "startmiddlemiddlemiddle"
• et enfin, à la ligne 5, nous ajoutons « startmiddlemiddlemiddleend » au pool et y pointons longString

Toutes ces lignes restent dans le pool et ne sont jamais utilisées, ce qui entraîne un gaspillage d'une grande quantité de RAM. Pour éviter cela, nous pouvons utiliser StringBuilder.

String longString = new StringBuilder()
  .append("start")
  .append("middle")
  .append("middle")
  .append("middle")
  .append("end")
  .toString();

StringBuilder ne crée qu'une seule chaîne lorsque la méthode toString est appelée , éliminant ainsi toutes les chaînes intermédiaires initialement ajoutées au pool. Cependant, après Java 5, cela est fait automatiquement par le compilateur , il est donc préférable d'utiliser la concaténation de chaînes en utilisant « + ».

Utiliser des wrappers primitifs lorsqu'ils ne sont pas nécessaires

Considérons les deux fragments suivants :

int sum = 0;
for (int i = 0; i < 1000 * 1000; i++) {
  sum += i;
}
System.out.println(sum);

Integer sum = 0;
for (int i = 0; i < 1000 * 1000; i++) {
  sum += i;
}
System.out.println(sum);

Le premier exemple s'exécute six fois plus vite que le second sur mon ordinateur. La seule différence est que nous utilisons une classe wrapper Integer. La façon dont Integer fonctionne est qu'à la ligne 3, le runtime doit convertir la variable de somme en un entier primitif (déballage automatique), et une fois l'ajout effectué, le résultat est ensuite encapsulé dans une nouvelle classe Integer. (emballage automatique). Cela signifie que nous créons 1 million de classes Integer et effectuons deux millions d’opérations de packaging, ce qui explique le ralentissement spectaculaire. Les classes Wrapper ne doivent être utilisées que lorsqu'elles doivent être stockées dans des collections. Cependant, les futures versions de Java prendront en charge les collections de types primitifs, ce qui rendra les wrappers obsolètes.

Comment final, final et finalize sont utilisés en Java

Source : Newsshare Dans cet article, vous apprendrez où, quand et pourquoi le mot-clé Finalize est utilisé, et s'il vaut la peine de l'utiliser en Java. Vous apprendrez également les différences entre final, enfin et finaliser.

Où est utilisé un bloc final ?

Le bloc final en Java est utilisé pour héberger des parties importantes du code telles que le code de nettoyage, la fermeture d'un fichier ou la fermeture d'une connexion, par exemple. Le bloc final s'exécute indépendamment du fait qu'une exception soit levée ou qu'elle soit gérée. A contient enfin toutes les déclarations importantes, qu'une exception se produise ou non.

Comment finaliser une variable en Java ?

Il existe 3 façons d'initialiser une variable Java finale :

• Vous pouvez initialiser une variable finale lorsqu'elle est déclarée. Cette approche est la plus courante.
• Une variable finale vide est initialisée dans un bloc ou un constructeur d'initialisation d'instance.
• Une variable statique finale vide est initialisée à l'intérieur d'un bloc statique.

Pouvons-nous appeler la méthode finalize manuellement en Java ?

La méthode finalize() n’est pas nécessaire et il n’est pas recommandé de l’appeler lorsqu’un objet sort de la portée. Parce qu'on ne sait pas à l'avance quand (ou si) la méthode finalize() sera exécutée . En général, finalize n’est pas la meilleure méthode à utiliser, sauf en cas de besoin spécifique. À partir de Java 9, il est obsolète.

Quand la méthode finalize est-elle appelée ?

La méthode finalize() est appelée pour effectuer un nettoyage juste avant le garbage collection.

Quelle est la différence entre final, enfin et finaliser ?

La principale différence entre final, enfin et finalize est que final est un modificateur d'accès, enfin est un bloc de gestion des exceptions et finalize est une méthode d'une classe d'objets.

Est-il possible de remplacer les méthodes finales ?

Non, les méthodes déclarées finales ne peuvent pas être remplacées ou masquées.

Pouvons-nous utiliser try sans catch ?

Oui, il est possible d'avoir un bloc try sans bloc catch en utilisant un bloc final . Comme nous le savons, le bloc final sera toujours exécuté même si une exception autre que System se produit dans le bloc try.

Quelles sont les méthodes finales ?

Les méthodes finales ne peuvent pas être remplacées ou masquées par les sous-classes. Ils sont utilisés pour empêcher un comportement inattendu d'une sous-classe modifiant une méthode qui peut être critique pour le fonctionnement ou la cohérence de la classe.

Un constructeur peut-il être définitif ?

Les constructeurs ne peuvent JAMAIS être déclarés définitifs. Votre compilateur générera toujours une erreur du type « modificateur final non autorisé ». Final lorsqu'il est appliqué aux méthodes signifie que la méthode ne peut pas être substituée dans une sous-classe. Les constructeurs ne sont PAS des méthodes régulières.

A quoi sert le mot-clé final ?

Le mot-clé enfin est utilisé pour créer un bloc de code suite à un bloc try. Le bloc final est toujours exécuté, qu'une exception se produise ou non. L'utilisation d'un bloc final vous permet d'exécuter toutes les instructions de type déroulement que vous souhaitez exécuter, indépendamment de ce qui se passe dans le code protégé.

A quoi ça sert finalement ?

Un bloc enfin en Java est un bloc utilisé pour exécuter des parties de code telles que la fermeture d'une connexion et autres. Le bloc final en Java est toujours exécuté, que l'exception soit gérée ou non. Par conséquent, il contient toutes les instructions nécessaires qui doivent être imprimées, qu'une exception se produise ou non.

Pourquoi la méthode Finalize est-elle protégée ?

Pourquoi le modificateur d'accès à la méthode finalize() est- il protégé ? Pourquoi cela ne peut-il pas être public ? Il n'est pas public car il ne doit être appelé que par la JVM. Cependant, il doit être protégé afin qu'il puisse être remplacé par des sous-classes qui doivent définir son comportement.

La méthode finalize est-elle toujours appelée en Java ?

La méthode finalize est appelée lorsqu'un objet est sur le point d'être récupéré. Cela peut se produire à tout moment après qu’il soit devenu éligible au garbage collection. Notez qu'il est tout à fait possible que l'objet ne soit jamais récupéré (et donc que finalize ne soit jamais appelé).

Quelle est la différence entre lancer et lancers ?

Le mot-clé throw est utilisé pour lever intentionnellement une exception. Le mot-clé throws permet de déclarer une ou plusieurs exceptions, séparées par des virgules. Lors de l'utilisation de throw, une seule exception est levée.

Quelle est la différence entre les mots-clés try catch et enfin ?

Ce sont deux concepts différents : un bloc catch n'est exécuté que si une exception se produit dans le bloc try. Le bloc final est toujours exécuté après le bloc try(-catch), qu'une exception ait été levée ou non.

Pouvons-nous l'utiliser enfin sans essayer en Java ?

Un bloc final doit être associé à un bloc try, vous ne pouvez pas l'utiliser finalement sans bloc try. Vous devez placer dans ce bloc les instructions qui doivent toujours être exécutées.

Pouvons-nous hériter de la méthode finale ?

La méthode finale est-elle héritée ? Oui, la méthode finale est héritée, mais vous ne pouvez pas la remplacer.

Quelle méthode ne peut pas être remplacée ?

Nous ne pouvons pas remplacer les méthodes statiques car le remplacement des méthodes est basé sur des liaisons dynamiques au moment de l'exécution et les méthodes statiques sont liées à l'aide de liaisons statiques au moment de la compilation. Ainsi, il n’est pas possible de remplacer les méthodes statiques.

Que se passe-t-il si la méthode finale est remplacée ?

Une méthode finale déclarée dans une classe parent ne peut pas être remplacée par une classe enfant. Si nous essayons de remplacer la dernière méthode, le compilateur lèvera une exception au moment de la compilation.

Le mot-clé final et la méthode finalize fonctionnent-ils de la même manière ?

Il n'y a aucune similitude dans leurs fonctions, à l'exception de noms similaires. Le mot-clé final peut être utilisé avec une classe, une méthode ou une variable en Java. Une classe finale n'est pas extensible en Java, une méthode finale ne peut pas être remplacée et une variable finale ne peut pas être modifiée.

Quel est le super mot-clé en Java ?

Le super mot-clé en Java est une variable de référence utilisée pour faire référence à l'objet immédiat de la classe parent. Chaque fois que vous instanciez une sous-classe, une instance de la classe parent est créée en parallèle, qui est référencée par la variable de référence super. Le super mot-clé peut être utilisé pour appeler directement une méthode d’une classe parent.

Quelle est la différence entre les mots-clés statiques et finaux ?

La principale différence entre les mots-clés static et final est que le mot-clé static est utilisé pour définir un membre d'une classe qui peut être utilisé indépendamment de tout objet de cette classe. Le mot-clé Final est utilisé pour déclarer une variable constante, une méthode qui ne peut pas être remplacée et une classe qui ne peut pas être héritée.