package oop;
import java.io.Serializable;
public class Parent implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private String name;
private int age;
@Override
public String toString() {
return "Parent [age=" + age + ", name=" + name + "]";
}
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public Parent() {
}
public Parent(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package oop;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Student implements Serializable,Cloneable {//实现 序列化接口 和克隆接口
private static final long serialVersionUID = 1L;
private /*transient 可以不被序列化*/ int id;
private int age;
private char sex;
private String name;
private Parent parent; // 浅克隆 不能克隆parent
public Student() {
}
public Student(int id, int age, char sex, String name, Parent parent) {
super();
this.id = id;
this.age = age;
this.sex = sex;
this.name = name;
this.parent = parent;
}
public Student clone() throws CloneNotSupportedException {
return (Student)super.clone();
}
public Object clone2() { //用流实现深克隆
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
Object object = null;
try {
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this);
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
object = ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return object;
}
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((parent == null) ? 0 : parent.hashCode());
result = prime * result + sex;
return result;
}
@Override
public String toString() {
return "Student [age=" + age + ", id=" + id + ", name=" + name
+ ", parent=" + parent + ", sex=" + sex + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (parent == null) {
if (other.parent != null)
return false;
} else if (!parent.equals(other.parent))
return false;
if (sex != other.sex)
return false;
return true;
}
public Parent getParent() {
return parent;
}
public void setParent(Parent parent) {
this.parent = parent;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package oop;
public class Test {
public static void main(String[] args) {
Parent p = new Parent("刘老",50);
Student stu= new Student(15005,25,'男',"刘备备",p);
Student stuclone=(Student)stu.clone2(); //深克隆
try {
Student copy=stu.clone(); //浅克隆
stu.getParent().setAge(55);
System.out.println(copy);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
System.out.println(stuclone);
}
}
分享到:
相关推荐
Java 深克隆与浅克隆 Java 中的克隆机制可以让我们方便地制造出一个对象的副本来,但是在克隆过程中需要注意浅克隆和深克隆的区别。 浅克隆(Shallow Clone)是指对对象的域进行简单的 copy,对象的reference变量...
Java中的浅克隆和深克隆是对象复制的两种方式,它们主要区别在于对对象内部引用类型字段的处理。在Java中,实现克隆通常需要重写`Object`类的`clone()`方法。 **浅克隆(Shallow Clone)** 浅克隆创建一个新对象,...
Java提供了两种主要的克隆方式:深克隆和浅克隆。 1. 浅克隆(Shallow Clone): 浅克隆是通过调用对象的`clone()`方法来实现的,这个方法是Object类提供的。当一个对象被浅克隆时,新创建的对象将拥有原始对象的...
在Java编程语言中,克隆是...理解深克隆和浅克隆的概念对于编写复杂的、性能敏感的Java程序至关重要,尤其是在处理大量对象或需要保持数据独立性时。根据具体需求选择合适的克隆策略,可以提高代码的灵活性和可维护性。
Java提供了两种主要的克隆方式:浅克隆(Shallow Clone)和深克隆(Deep Clone)。下面我们将深入探讨这两种克隆方法。 ### 浅克隆 浅克隆是指创建一个新的对象,其成员变量的值与原对象相同,但引用类型成员变量...
浅克隆和深克隆在Java对象中的应用 在Java编程语言中,克隆(Clone)是一种常见的对象复制机制。克隆可以分为浅克隆(Shallow Clone)和深克隆(Deep Clone)两种。浅克隆仅复制对象的引用,而深克隆则完全复制对象...
在Java中,有两种主要的克隆方式:浅克隆(Shallow Clone)和深克隆(Deep Clone)。接下来,我们将详细讨论这两种克隆方式及其区别。 1. 对象的浅克隆: 浅克隆是指创建一个新对象,这个新对象复制了原对象的所有...
首先,Java提供了两种基本的克隆方式:浅克隆(shallow clone)和深克隆。浅克隆仅仅复制对象本身,而不复制对象所引用的对象。而深克隆则会递归地复制对象及所有引用的对象,确保新创建的对象和原始对象及其引用的...
总结来说,Java中的克隆机制提供了一种创建对象副本的方式,分为浅克隆和深克隆两种形式,适用于不同的对象结构需求。正确理解和使用克隆机制,可以帮助开发者更有效地管理和复制复杂的数据结构,避免因共享数据导致...
在Java中,克隆分为浅克隆和深克隆。浅克隆只是复制对象的引用,而深克隆则会创建对象以及所有嵌套对象的新副本。 2. **浅克隆**:通过实现`Cloneable`接口并重写`Object`类的`clone()`方法,可以实现浅克隆。浅...
本文将深入探讨Java中的浅复制和深复制,并以Android为背景,结合具体的实例讲解如何实现Java泛型深拷贝。 首先,我们要理解浅复制和深复制的概念。浅复制(Shallow Copy)是指创建一个新的对象,然后将原对象引用...
在编程领域,尤其是在Java语言中,对象的复制是常见的操作,这涉及到两个主要概念:浅拷贝(浅复制、浅克隆)和深拷贝(深复制、深克隆)。这两个概念是理解对象生命周期和内存管理的关键部分。下面将详细阐述它们的...
在Java中,克隆分为两种类型:浅克隆(Shallow Clone)和深克隆(Deep Clone)。浅克隆创建的新对象只复制了原对象的引用,这意味着如果原对象中包含可变的引用类型,如数组或复杂的数据结构,那么新对象和原对象会...
在本文中,我们将深入探讨Java中的浅克隆(shallow clone)和深克隆(deep clone),并结合测试代码进行分析。 首先,让我们理解`Cloneable`接口。在Java中,如果一个类想要支持`clone()`方法,它必须实现`...
Java中的对象复制与克隆是程序开发中常见的需求,主要用于创建一个对象的副本,而不会影响原始对象的状态。这里主要讨论两种类型的对象拷贝:浅拷贝和深拷贝。 浅拷贝,也称为表面拷贝,是创建一个新的对象,然后将...
二、浅克隆与深克隆 1. 浅克隆:默认的`clone()`方法执行的是浅克隆,它创建的新对象只复制原始对象的基本数据类型字段,对于引用类型的字段,新对象和原始对象共享同一个引用。这意味着对引用对象的修改会影响到...
在Java中,克隆分为两种类型:浅克隆(Shallow Clone)和深度克隆(Deep Clone)。 1. 浅克隆(Shallow Clone) 浅克隆是Java克隆机制的默认行为。当一个对象被克隆时,如果它的成员变量是基本类型(如int、double...