Exemple de tutoriel de clonage d'objets (Clone) en Java
- 零下一度original
- 2017-07-19 10:00:011538parcourir
Partie II<br>
En ce qui concerne le clonage d'objets, nous devons expliquer pourquoi les objets doivent être clonés. Tous les objets en Java sont stockés dans le tas et le tas est partagé globalement. En d'autres termes, si différentes méthodes du même programme Java peuvent obtenir une référence à un objet, le référent peut modifier les données internes de l'objet à volonté (à condition que les données internes de l'objet soient exposées via la méthode get/set). . Parfois, le code que nous écrivons souhaite que l'appelant obtienne une seule copie de l'objet (c'est-à-dire un objet avec exactement le même contenu, mais il existe deux objets de ce type dans la mémoire). Bien sûr, c'est un clone.
Partie III
Tout d'abord, nous sommes des programmeurs, et bien sûr nous communiquons dans le langage de nos programmeurs.
import java.util.Date;
public class User implements Cloneable {
private String username;
private String password;
private Date birthdate;
public User(String username, String password, Date birthdate) {
this.username = username;
this.password = password;
this.birthdate = birthdate;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public int hashCode() {
// 省略equals的实现(可用eclipse自动生成)
}
@Override
public boolean equals(Object obj) {
// 省略equals的实现(可用eclipse自动生成)
}
// 省略一大堆get/set方法
}
Le code ci-dessus construit une classe User et implémente l'interface java.lang.Cloneable. Comme son nom l'indique, Cloneable signifie que cette classe peut être clonée.
Jetons d’abord un coup d’œil à ce que possède l’interface java.lang.Cloneable.
/*
* @(#)Cloneable.java 1.17 05/11/17
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package java.lang;
/**
* A class implements the Cloneable interface to
* indicate to the {@link java.lang.Object#clone()} method that it
* is legal for that method to make a
* field-for-field copy of instances of that class.
*
* Invoking Object's clone method on an instance that does not implement the
* Cloneable interface results in the exception
* CloneNotSupportedException being thrown.
*
* By convention, classes that implement this interface should override
* Object.clone (which is protected) with a public method.
* See {@link java.lang.Object#clone()} for details on overriding this
* method.
*
* Note that this interface does not contain the clone method.
* Therefore, it is not possible to clone an object merely by virtue of the
* fact that it implements this interface. Even if the clone method is invoked
* reflectively, there is no guarantee that it will succeed.
*
* @author unascribed
* @version 1.17, 11/17/05
* @see java.lang.CloneNotSupportedException
* @see java.lang.Object#clone()
* @since JDK1.0
*/
public interface Cloneable {
}
Ne soyez pas surpris, oui, à part pas mal d'intestins de poulet, cette interface ne définit pas n'importe quoi Signature de méthode. En d’autres termes, nous voulons cloner un objet, mais cela ne me fournit pas de méthode. Alors que faire ? N'ayez pas peur, nous avons toujours la toute-puissante classe Objet. N'oubliez pas qu'il est l'ancêtre de toutes les classes (une existence quasi divine), vous devriez donc aller le saluer chaque fois que vous avez quelque chose.
/*
* @(#)Object.java 1.73 06/03/30
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package java.lang;
/**
* Class Object is the root of the class hierarchy.
* Every class has Object as a superclass. All objects,
* including arrays, implement the methods of this class.
*
* @author unascribed
* @version 1.73, 03/30/06
* @see java.lang.Class
* @since JDK1.0
*/
public class Object {
<br>
// 省略N多的代码
/**
* Creates and returns a copy of this object. The precise meaning
* of "copy" may depend on the class of the object. The general
* intent is that, for any object x, the expression:
*
*
* x.clone() != x
* will be true, and that the expression:
*
*
* x.clone().getClass() == x.getClass()
* will be true, but these are not absolute requirements.
* While it is typically the case that:
*
*
* x.clone().equals(x)
* will be true, this is not an absolute requirement.
*
* By convention, the returned object should be obtained by calling
* super.clone. If a class and all of its superclasses (except
* Object) obey this convention, it will be the case that
* x.clone().getClass() == x.getClass().
*
* By convention, the object returned by this method should be independent
* of this object (which is being cloned). To achieve this independence,
* it may be necessary to modify one or more fields of the object returned
* by super.clone before returning it. Typically, this means
* copying any mutable objects that comprise the internal "deep structure"
* of the object being cloned and replacing the references to these
* objects with references to the copies. If a class contains only
* primitive fields or references to immutable objects, then it is usually
* the case that no fields in the object returned by super.clone
* need to be modified.
*
* The method clone for class Object performs a
* specific cloning operation. First, if the class of this object does
* not implement the interface Cloneable, then a
* CloneNotSupportedException is thrown. Note that all arrays
* are considered to implement the interface Cloneable.
* Otherwise, this method creates a new instance of the class of this
* object and initializes all its fields with exactly the contents of
* the corresponding fields of this object, as if by assignment; the
* contents of the fields are not themselves cloned. Thus, this method
* performs a "shallow copy" of this object, not a "deep copy" operation.
*
* The class Object does not itself implement the interface
* Cloneable, so calling the clone method on an object
* whose class is Object will result in throwing an
* exception at run time.
*
* @return a clone of this instance.
* @exception CloneNotSupportedException if the object's class does not
* support the Cloneable interface. Subclasses
* that override the clone method can also
* throw this exception to indicate that an instance cannot
* be cloned.
* @see java.lang.Cloneable
*/
protected native Object clone() throws CloneNotSupportedException;
}
Haha, une autre grosse chaîne d'intestins de poulet, ne pense pas que je suis là pour inventer le nombre de mots, ce sont toutes des technologies écrites par Développeurs Java de Sun. Articles, lisez plus et parlez moins.
Oui, c'est une méthode native. C'est effectivement une chose profonde, mais encore faut-il en profiter. De plus, sa méthode est protégée, et il nous demande clairement d'en profiter.
Continuez à regarder le code de test ci-dessous.
import java.util.Date;
import org.junit.Test;
public class TestCase {
<br>
@Test
public void testUserClone() throws CloneNotSupportedException {
User u1 = new User("Kent", "123456", new Date());
User u2 = u1;
User u3 = (User) u1.clone();
<br>
System.out.println(u1 == u2); // true
System.out.println(u1.equals(u2)); // true
<br>
System.out.println(u1 == u3); // false
System.out.println(u1.equals(u3)); // true
}
<br>
}
Cette méthode clone() est vraiment géniale. Elle clone notre objet en une seule fois. Les résultats d'exécution sont également conformes à nos attentes. Les adresses de u1 et u3 sont différentes mais le contenu l'est. le même.
Partie IV
A travers l'exemple ci-dessus, nous pouvons voir qu'il y a en réalité deux étapes pour cloner un objet :
1. Laissez cette classe implémenter l'interface java.lang.Cloneable ;
2. Remplacez (remplacez) la méthode clone() de la classe Object.
Mais est-ce vraiment aussi simple ? Regardez à nouveau le code ci-dessous.
public class Administrator implements Cloneable {
private User user;
private Boolean editable;
public Administrator(User user, Boolean editable) {
this.user = user;
this.editable = editable;
}
<br>
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public int hashCode() {
// 老规矩
}
@Override
public boolean equals(Object obj) {
// 老规矩
}
// 老规矩
}
Ce qui précède définit une classe Administrateur, qui contient un objet de classe Utilisateur. Examinons ensuite l'effet du clonage de l'objet Administrateur.
import java.util.Date;
import org.junit.Test;
public class TestCase {
@Test
public void testAdministratorClone() throws CloneNotSupportedException {
Administrator a1 = new Administrator(new User("Kent", "123456", new Date()), true);
Administrator a2 = a1;
Administrator a3 = (Administrator) a1.clone();
<br>
System.out.println(a1 == a2); // true
System.out.println(a1.equals(a2)); // true
<br>
System.out.println(a1 == a3); // false
System.out.println(a1.equals(a3)); // true
<br>
System.out.println(a1.getUser() == a3.getUser()); //true ! It's not our expected!!!!!
System.out.println(a1.getUser().equals(a3.getUser())); //true
}
}
Héhéhé ! Quelque chose s'est mal passé. Java est si facile à maîtriser !
Ici, nous pouvons introduire deux termes professionnels : le clone superficiel et le clone profond.
Le clonage dit superficiel, comme son nom l'indique, est un clone très superficiel Si nous voulons cloner l'objet Administrateur, nous clonons uniquement lui-même et les adresses de référence de tous les. objets qu'il contient.
Le clonage profond n'est pas un clonage superficiel. Clonez tous les objets sauf lui-même, y compris toutes les instances d'objet contenues par lui-même. Quant au niveau de clonage profond, il est déterminé par des besoins spécifiques. Il existe également un dicton de « clonage de niveau N ».
Cependant, toutes les données de type primitif, qu'il s'agisse d'un clone superficiel ou d'un clone profond, seront clonées par valeur d'origine. Après tout, ce ne sont pas des objets et ne sont pas stockés dans le tas. Remarque : Les types de données de base n'incluent pas leurs classes wrapper correspondantes.
Si nous voulons que l'objet soit profondément cloné, nous pouvons modifier la classe Administrateur comme ceci.
@Override
protected Object clone() throws CloneNotSupportedException {
Administrator admin = (Administrator) super.clone();
admin.user = (User) admin.user.clone();
return admin;
}
Puisque Boolean mettra en cache la valeur, nous n'avons pas besoin de cloner l'objet booléen. Et la classe booléenne n'implémente pas l'interface java.lang.Cloneable.
Partie V
1. 让该类实现java.lang.Cloneable接口；
2. 确认持有的对象是否实现java.lang.Cloneable接口并提供clone()方法；
3. 重写（override）Object类的clone()方法，并且在方法内部调用持有对象的clone()方法；
4. ……
5. 多麻烦啊，调来调去的，如果有N多个持有的对象，那就要写N多的方法，突然改变了类的结构，还要重新修改clone()方法。
难道就没有更好的办法吗？
Part VI
接下来要重点介绍一下使用java.lang.Serializable来实现对象的深度克隆。
首先，我们编写一个工具类并提供cloneTo()方法。
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public abstract class BeanUtil {
@SuppressWarnings("unchecked")
public static T cloneTo(T src) throws RuntimeException {
ByteArrayOutputStream memoryBuffer = new ByteArrayOutputStream();
ObjectOutputStream out = null;
ObjectInputStream in = null;
T dist = null;
try {
out = new ObjectOutputStream(memoryBuffer);
out.writeObject(src);
out.flush();
in = new ObjectInputStream(new ByteArrayInputStream(memoryBuffer.toByteArray()));
dist = (T) in.readObject();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
if (out != null)
try {
out.close();
out = null;
} catch (IOException e) {
throw new RuntimeException(e);
}
if (in != null)
try {
in.close();
in = null;
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return dist;
}
}
看不懂，没关系，直接拿去用就可以了。嘻嘻。
接下来我们测试一下是否能通过这个工具来实现深度克隆。
又是这个可爱的TestCase，可怜的每次都要动他……
import java.util.Date;
import org.junit.Test;
public class TestCase {
<br>
@Test
public void testCloneTo() {
Administrator src = new Administrator(new User("Kent", "123456", new Date()), true);
Administrator dist = BeanUtil.cloneTo(src);
<br>
System.out.println(src == dist); // false
System.out.println(src.equals(dist)); // true
<br>
System.out.println(src.getUser() == dist.getUser()); //false ! Well done!
System.out.println(src.getUser().equals(dist.getUser())); //true
}
<br>
}
好了，无论你的对象有多么的复杂，只要这些对象都能够实现java.lang.Serializable接口，就可以进行克隆，而且这种克隆的机制是JVM完成的，不需要修改实体类的代码，方便多了。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!