Interfaces de marqueur et copies profondes

« Salut Amigo ! »

"Salut, Bilaabo !"

"Aujourd'hui je vais vous parler des interfaces de marqueurs ."

"Les interfaces marqueurs sont des interfaces sans méthodes. Lorsqu'une classe implémente une telle interface, on dit qu'elle est marquée par elle."

« Des exemples de ces interfaces incluent : Cloneable, Serializable, Remote .

"L' interface Serializable est utilisée pour marquer les classes qui prennent en charge la sérialisation, indiquant que les instances de ces classes peuvent être automatiquement sérialisées et désérialisées."

"L' interface Remote est utilisée pour identifier les objets qui prennent en charge l'exécution à distance, c'est-à-dire les méthodes qui peuvent être invoquées à partir d'une autre machine virtuelle Java et/ou d'un ordinateur différent."

"L' interface Cloneable est utilisée pour marquer les classes qui prennent en charge le clonage."

"Oh, à propos du clonage ou de la copie."

"Il existe deux types de copie : superficielle et profonde."

" La copie superficielle consiste à créer une copie d'un objet, sans créer de doublons d'aucun des objets auxquels il fait référence."

« La copie en profondeur consiste à dupliquer un objet, y compris les objets auxquels il fait référence, et les objets auxquels ces objets font référence, etc. »

"Il existe un très bon moyen de créer de manière fiable un clone profond."

"Cette méthode fonctionne même si les développeurs ont oublié de marquer une classe comme clonable. "La seule exigence est que les objets doivent être sérialisables."

"Voici comment procéder :"

1) Créez un tampon (tableau d'octets) en mémoire.

2) Sérialisez l'objet et les sous-objets dans le tampon.

3) Désérialiser la hiérarchie d'objets enregistrée dans le buffer.

BigObject objectOriginal = new BigObject();

ByteArrayOutputStream writeBuffer = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(writeBuffer);
outputStream.writeObject(objectOriginal);
outputStream.close();

byte[] buffer = writeBuffer.toByteArray();
ByteArrayInputStream readBuffer = new ByteArrayInputStream(buffer);
ObjectInputStream inputStream = new ObjectInputStream(readBuffer);
BigObject objectCopy = (BigObject)inputStream.readObject();

"Dans la première ligne, nous créons objectOriginal , que nous allons cloner. L'objet et tous ses sous-objets doivent prendre en charge la sérialisation."

"Dans la troisième ligne, nous créons un ByteArrayOutputStream , qui se développera dynamiquement à mesure que de nouvelles données seront ajoutées (comme une ArrayList)."

"À la ligne 4, nous créons un ObjectOutputStream , qui est utilisé pour la sérialisation."

"À la ligne 5, nous sérialisons objectOriginal dans un tableau d'octets à l'aide de outputStream et l'enregistrons dans writeBuffer ."

"À la ligne 8, nous convertissons writeBuffer en un tableau d'octets ordinaire. Plus tard, nous 'lirons' notre nouvel objet à partir de ce tableau."

"À la ligne 9, nous transformons le tampon en un ByteArrayInputStream afin de le lire comme un InputStream."

"À la ligne 10, nous passons readBuffer au constructeur ObjectInputStream pour lire (désérialiser) l'objet."

"À la ligne 11, nous lisons notre objet et le convertissons en un BigObject ."

"Qu'en penses-tu?"

"C'est beau."

"Et au fait, lorsque le code est mis en évidence dans différentes couleurs, il est beaucoup plus facile à comprendre."