1. Introduction aux catégories immuables
Classe immuable: la classe dite immuable signifie qu'une fois qu'une instance de cette classe est créée, sa valeur de variable membre ne peut pas être modifiée. Par exemple, de nombreuses classes immuables qui sont livrées avec JDK: Interger, Long et String, etc.
Classes variables: Par rapport aux classes immuables, les classes mutables peuvent modifier leurs valeurs variables de membre après avoir créé des instances. La plupart des classes créées en développement appartiennent à des classes mutables.
2. Avantages des classes immuables
Après avoir parlé de la différence entre les classes mutables et les classes immuables, nous devons davantage comprendre pourquoi il y a des classes immuables? Quels avantages une telle caractéristique apporte-t-elle à Java?
1. Sécurité du fil
Les objets immuables sont en filetage et peuvent être partagés entre les threads. Il n'est pas nécessaire d'utiliser des mécanismes spéciaux pour assurer des problèmes de synchronisation, car la valeur de l'objet ne peut pas être modifiée. Il peut réduire la possibilité d'erreurs simultanées, car il n'est pas nécessaire d'utiliser certains mécanismes de verrouillage pour assurer des problèmes de cohérence de la mémoire, ce qui réduit également les frais généraux de synchronisation.
2. Facile à construire, à utiliser et à tester
3 ....
Méthode de conception de classe immuable
Pour les cours de conception immuables, je résume personnellement les principes suivants:
1. Ajoutez un modificateur final à la classe pour s'assurer que la classe n'est pas héritée.
Si une classe peut être héritée, elle détruira le mécanisme d'immuabilité de la classe, tant que la classe d'héritage l'emporte sur les méthodes de la classe parent et que la classe d'héritage peut modifier la valeur de la variable membre, alors une fois que la classe enfant apparaît comme la classe parent, il ne peut pas être garanti si la classe actuelle est mutable.
2. Assurez-vous que toutes les variables des membres doivent être privées et que une modification finale est ajoutée
De cette façon garantit que les variables des membres sont immuables. Mais il ne suffit pas de le faire, car s'il s'agit d'une variable de membre d'objet, il est possible de modifier sa valeur en externe. Donc, le quatrième point compense cette lacune.
3. Aucune méthode n'est fournie pour modifier les variables des membres, y compris les setteurs
Évitez de modifier la valeur des variables des membres à travers d'autres interfaces et de détruire les caractéristiques immuables.
4. Initialiser tous les membres via le constructeur et effectuer une copie profonde (copie profonde)
Si l'objet transmis par le constructeur est directement attribué à la variable membre, il peut toujours être modifié en modifiant l'objet entrant, ce qui entraînera la modification de la valeur de la variable interne. Par exemple:
Classe finale publique ImmutableDemo {private final int [] myArray; public ImmutableDemo (int [] array) {this.myArray = array; // faux } }Cette méthode ne peut garantir l'immuabilité. MyArray et Array pointent la même adresse mémoire. Les utilisateurs peuvent modifier la valeur à l'intérieur de MyArray en modifiant la valeur de l'objet Array en dehors de ImutableDemo.
Afin de s'assurer que la valeur interne n'est pas modifiée, la copie de profondeur peut être utilisée pour créer une nouvelle mémoire pour enregistrer la valeur entrante. Façon correcte de le faire:
classe finale publique MyImmutabledemo {private final int [] myArray; public myimmutabledemo (int [] array) {this.myArray = array.clone (); }}5. Dans la méthode Getter, ne renvoyez pas directement l'objet lui-même, mais clonez l'objet et renvoyez la copie de l'objet.
Cette approche empêche également la fuite d'objets et empêche le fonctionnement direct des variables des membres après avoir obtenu des objets membre mutables internes via des getters, entraînant des changements dans les variables des membres.
Iv. Imutabilité des objets de chaîne
L'objet String ne peut pas être modifié après la création de mémoire. La création d'objets immuables répond généralement aux 5 principes ci-dessus. Jetons un coup d'œil à la façon dont le code de chaîne est implémenté.
Classe finale publique StringImplements java.io.serializable, comparable <string>, chardequence {/ ** La valeur est utilisée pour le stockage des caractères. * / Valeur de char finale privée []; / ** Le décalage est le premier index du stockage utilisé. * / Final int private Int offset; / ** Le nombre est le nombre de caractères dans la chaîne. * / Private Final int count; / ** cache le code de hachage pour la chaîne * / private int hash; // par défaut à 0..Public String (char char []) {this.value = arrays.copyof (value, value.length); // Opération de copie profonde} ... public char [] tocharArray () {// Impossible d'utiliser des arrays.copyof en raison de l'ordre d'initialisation des classes Issues Result [] = new Char [value.length]; System.ArrayCopy (valeur, 0, résultat, 0, valeur.length); Retour Result;} ...}Comme indiqué dans le code ci-dessus, les détails de conception suivants peuvent être observés:
1. La classe de collage est modifiée par finale et ne peut pas être héritée
2. Tous les membres de la chaîne sont définis comme des variables privées
3. Le secteur de valeur n'existe pas
4. et définissez la valeur et le décalage à la finale.
5. Lorsque vous transmettez une valeur de tableau de variable [], copiez-le au lieu de copier la valeur [] directement à la variable interne.
6. Lors de l'obtention de la valeur, il ne renvoie pas directement la référence de l'objet, mais renvoie la copie de l'objet.
Cela est cohérent avec les caractéristiques du type invariant résumé ci-dessus, et garantit également que le type de chaîne est une classe immuable.
5. Avantages et inconvénients de l'immuabilité des objets de chaîne
D'après l'analyse de la section précédente, les données de chaîne sont immuables, alors quels sont les avantages de définir une telle fonctionnalité? Je l'ai résumé comme suit:
1. Exigences pour les pools constants à cordes.
Les pools constants à cordes peuvent réutiliser certaines constantes de caractères dans le pool constant, en évitant de recréer le même objet à chaque fois et d'économiser un espace de stockage. Mais si la chaîne est variable, la chaîne du même contenu pointe également vers le même espace mémoire du pool constant. Lorsqu'une variable modifie la valeur de cette mémoire, les autres valeurs traversées changent également. Par conséquent, il n'est pas conforme à l'intention d'origine de la conception de piscine constante.
2. Considérations de sécurité en fil.
La même instance de chaîne peut être partagée par plusieurs threads. De cette façon, il n'est pas nécessaire d'utiliser la synchronisation en raison de problèmes de sécurité des fils. Les cordes sont en sécurité.
3. Les chargeurs de classe doivent utiliser les chaînes et l'immuabilité assure la sécurité afin que la bonne classe soit chargée. Par exemple, si vous souhaitez charger la classe java.sql.connection et que cette valeur est modifiée en myhacked.connection, elle entraînera des dommages inconnus à votre base de données.
4. Soutenir la cartographie du hachage et la mise en cache.
Parce que les chaînes sont immuables, le code de hash est mis en cache lorsqu'il est créé et n'a pas besoin d'être recalculé. Cela rend les chaînes très appropriées comme clés dans la carte, et la vitesse de traitement des chaînes est plus rapide que les autres objets clés. C'est pourquoi les clés de Hashmap utilisent souvent des chaînes.
défaut:
1. S'il est nécessaire de modifier la valeur de l'objet String, un grand nombre d'objets String seront créés.
6. L'objet String est-il vraiment immuable?
Bien que l'objet String définit la valeur à Final, il garantit également que ses variables membre sont immuables par divers mécanismes. Cependant, il peut encore être modifié par le mécanisme de réflexion. Par exemple:
// Créez la chaîne "Hello World" et attribuez-le à la référence sString s = "Hello World"; System.out.println ("S =" + S); // Hello world // Obtenez le champ de valeur dans le champ de classe de chaîne ValueFieldOfString = String.class.getDeclaredField ("Value"); // Modifie l'autorisation d'accès de la valeur d'attribut de valeur '_'; System.out.println ("S =" + S); //Bonjour le mondeLe résultat de l'impression est:
S = Hello Worlds = Hello_world
Il a été constaté que la valeur de la chaîne a changé. C'est-à-dire que l'objet soi-disant "immuable" peut être modifié par réflexion.
Résumer
Une classe immuable est la valeur de la traversée des membres qui ne peut pas être modifiée après la création de l'instance. Cette fonctionnalité permet aux classes immuables de fournir des fonctionnalités de filetage mais apporte également la surcharge de la création d'objets. Chaque changement d'attribut consiste à recréer un nouvel objet. JDK fournit également de nombreuses classes immuables telles que entier, double, chaîne, etc. Les caractéristiques immuables de la chaîne sont principalement pour répondre aux besoins de la mise en commun constante, de la sécurité des filetages et du chargement des classes. L'utilisation rationnelle des cours immuables peut apporter de grands avantages.
Ce qui précède est le mécanisme immuable du Java (immuable) et l'immuabilité de la chaîne (recommandée) présentée par l'éditeur. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!