Beispiel-Tutorial zum Klonen von Objekten (Clone) in Java

Teil II<br>

Wenn es um das Klonen von Objekten geht, müssen wir darüber sprechen, warum Objekte geklont werden sollten. Alle Objekte in Java werden im Heap gespeichert und der Heap wird global gemeinsam genutzt. Mit anderen Worten: Wenn verschiedene Methoden desselben Java-Programms einen Verweis auf ein Objekt erhalten können, kann der Referrer die internen Daten des Objekts nach Belieben ändern (vorausgesetzt, die internen Daten des Objekts werden über die Get/Set-Methode verfügbar gemacht). . Manchmal möchte der Code, den wir schreiben, dass der Aufrufer nur eine Kopie des Objekts erhält (d. h. ein Objekt mit genau demselben Inhalt, aber es gibt zwei solcher Objekte im Speicher). Gibt es eine Möglichkeit, dies zu tun? Natürlich ist es ein Klon.

Teil III

Zuallererst sind wir Programmierer, und natürlich kommunizieren wir in der Sprache unserer Programmierer.

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方法

}

Der obige Code erstellt eine Benutzerklasse und implementiert die java.lang.Cloneable-Schnittstelle. Wie der Name schon sagt, bedeutet Cloneable, dass diese Klasse geklont werden kann.

Werfen wir zunächst einen Blick auf die java.lang.Cloneable-Schnittstelle.

/*

 * @(#)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 {

}

Seien Sie nicht überrascht, ja, bis auf viele Hühnerdärme ist diese Schnittstelle nicht definiert irgendetwas Methodensignatur. Mit anderen Worten: Wir möchten ein Objekt klonen, aber es stellt mir keine Methode zur Verfügung. Was also tun? Haben Sie keine Angst, wir haben immer noch die allmächtige Objektklasse. Vergessen Sie nicht, dass er der Vorfahre aller Klassen ist (eine gottähnliche Existenz), also sollten Sie ihn begrüßen, wann immer Sie etwas haben.

/*

 * @(#)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, wieder eine große Reihe von Hühnerdärmen, ich glaube nicht, dass ich hier bin, um die Anzahl der Wörter zu erhöhen, das sind alles Technologien, die von geschrieben wurden Java-Entwickler von Sun. Artikel, mehr lesen und weniger reden.

Ja, es ist eine native Methode. Es ist tatsächlich eine tiefgreifende Sache, aber wir müssen sie trotzdem nutzen. Darüber hinaus ist seine Methode geschützt, und er fordert uns eindeutig auf, einen Vorteil daraus zu ziehen.

Sehen Sie sich weiterhin den Testcode unten an.

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>

}

Diese clone()-Methode ist wirklich großartig. Sie klont unser Objekt auf einmal. Die Adressen von u1 und u3 sind unterschiedlich, aber der Inhalt das gleiche.

Teil IV

Anhand des obigen Beispiels können wir sehen, dass es tatsächlich zwei Schritte zum Klonen eines Objekts gibt:

1. Lassen Sie diese Klasse die Schnittstelle java.lang.Cloneable implementieren.

2.

Aber ist es wirklich so einfach? Schauen Sie sich den Code unten noch einmal an.

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) {

		// 老规矩

	}

	// 老规矩

}

Das Obige definiert eine Administratorklasse, die ein Objekt der Benutzerklasse enthält. Schauen wir uns als Nächstes die Auswirkung des Klonens des Administratorobjekts an.

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

	}

}

Hehehe! Etwas ist schief gelaufen. Java ist so einfach zu beherrschen!

Hier können wir zwei Fachbegriffe vorstellen: flaches Klonen und tiefes Klonen.

Das sogenannte flache Klonen ist, wie der Name schon sagt, ein sehr oberflächlicher Klon. Wenn wir das Administratorobjekt klonen möchten, klonen wir nur sich selbst und die Referenzadressen aller Objekte, die es enthält.

Tiefes Klonen ist kein flaches Klonen. Klonen Sie alle Objekte außer sich selbst, einschließlich aller in ihm enthaltenen Objektinstanzen. Der Grad des tiefen Klonens wird durch spezifische Bedürfnisse bestimmt. Es gibt auch ein Sprichwort vom „Klonen auf N-Ebene“.

Allerdings werden alle Daten vom primitiven Typ, egal ob flacher Klon oder tiefer Klon, nach dem Originalwert geklont. Schließlich sind sie keine Objekte und werden nicht im Heap gespeichert. Hinweis: Grundlegende Datentypen enthalten nicht die entsprechenden Wrapper-Klassen.

Wenn wir möchten, dass das Objekt tief geklont wird, können wir die Administrator-Klasse wie folgt ändern.

@Override

protected Object clone() throws CloneNotSupportedException {

	Administrator admin = (Administrator) super.clone();

	admin.user = (User) admin.user.clone();

	return admin;

}

Da Boolean den Wert zwischenspeichert, müssen wir das Boolean-Objekt nicht klonen. Und die Boolean-Klasse implementiert nicht die java.lang.Cloneable-Schnittstelle.

Teil 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完成的，不需要修改实体类的代码，方便多了。

Das obige ist der detaillierte Inhalt vonBeispiel-Tutorial zum Klonen von Objekten (Clone) in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!