`
quzhan87com
  • 浏览: 55342 次
  • 性别: Icon_minigender_1
  • 来自: 西安
社区版块
存档分类
最新评论

java clone

    博客分类：
  • java
 
阅读更多
以下文章摘自：http://ttitfly.iteye.com/blog/155422

1.java里的clone分为：
A:浅复制（浅克隆）: 浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
b:深复制（深克隆）：深复制把要复制的对象所引用的对象都复制了一遍。
Java中对象的克隆,为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。必须要遵循下面三点
1.在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。
2.在派生类的clone()方法中，调用super.clone()。
3.在派生类中实现Cloneable接口。

Object类里的clone方法是浅复制（浅克隆）

浅复制（浅克隆）的例子如下： 

package com.test;   
  
//浅复制（浅克隆）: 浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。   
//深复制（深克隆）：深复制把要复制的对象所引用的对象都复制了一遍。   
//   
//Java中对象的克隆,为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。必须要遵循下面三点   
//1.在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。   
//2.在派生类的clone()方法中，调用super.clone()。   
//3.在派生类中实现Cloneable接口。   
  
//[color=red]Object类里的clone方法是浅复制（浅克隆）[/color]public class CloneTest {   
  
    public static void main(String[] args) throws Exception{   
        //teacher对象将被clone出来的Student对象共享.   
        Teacher teacher = new Teacher();   
        teacher.setAge(40);   
        teacher.setName("Teacher zhang");   
           
        Student student1 = new Student();   
        student1.setAge(20);   
        student1.setName("zhangsan");   
        student1.setTeacher(teacher);   
           
        //复制出来一个对象student2   
        Student student2 = (Student)student1.clone();   
        System.out.println(student2.getAge());   
        System.out.println(student2.getName());   
           
           
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");   
        System.out.println(student1.getTeacher().getAge());   
        System.out.println(student1.getTeacher().getName());   
           
           
        //修改student2的引用对象   
        student2.getTeacher().setAge(50);   
        student2.getTeacher().setName("Teacher Li");   
           
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");   
        System.out.println(student1.getTeacher().getAge());   
        System.out.println(student1.getTeacher().getName());   
    }   
}   
  
class Teacher {   
    public int age;   
    public String name;   
       
    public int getAge() {   
        return age;   
    }   
    public void setAge(int age) {   
        this.age = age;   
    }   
    public String getName() {   
        return name;   
    }   
    public void setName(String name) {   
        this.name = name;   
    }   
       
       
}   
  
class Student implements Cloneable{   
       
    public int age ;   
    public String name;   
    public Teacher teacher;   
    public int getAge() {   
        return age;   
    }   
    public void setAge(int age) {   
        this.age = age;   
    }   
    public String getName() {   
        return name;   
    }   
    public void setName(String name) {   
        this.name = name;   
    }   
    public Teacher getTeacher() {   
        return teacher;   
    }   
    public void setTeacher(Teacher teacher) {   
        this.teacher = teacher;   
    }   
    @Override  
    public Object clone() throws CloneNotSupportedException {   
        return super.clone();   
    }   
       
       
}   
输出结果为：   
20  
zhangsan   
~~~~~~~~~~~~~~~~~~~~~~   
40  
Teacher zhang   
~~~~~~~~~~~~~~~~~~~~~~   
50  
Teacher Li


2.深复制（深Clone）例子： 

package com.test1;   
  
//深clone   
public class DeepCloneTest {   
  
    public static void main(String[] args) throws Exception{   
        //teacher对象将不被clone出来的Student对象共享.   
        Teacher teacher = new Teacher();   
        teacher.setAge(40);   
        teacher.setName("Teacher zhang");   
           
        Student student1 = new Student();   
        student1.setAge(20);   
        student1.setName("zhangsan");   
        student1.setTeacher(teacher);   
           
        //复制出来一个对象student2   
        Student student2 = (Student)student1.clone();   
        System.out.println(student2.getAge());   
        System.out.println(student2.getName());   
           
           
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");   
        System.out.println(student1.getTeacher().getAge());   
        System.out.println(student1.getTeacher().getName());   
           
           
        //修改student2的引用对象   
        student2.getTeacher().setAge(50);   
        student2.getTeacher().setName("Teacher Li");   
           
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");   
        System.out.println(student1.getTeacher().getAge());   
        System.out.println(student1.getTeacher().getName());   
    }   
}   
  
class Teacher implements Cloneable{   
    public int age;   
    public String name;   
       
    public int getAge() {   
        return age;   
    }   
    public void setAge(int age) {   
        this.age = age;   
    }   
    public String getName() {   
        return name;   
    }   
    public void setName(String name) {   
        this.name = name;   
    }   
    @Override  
    public Object clone() throws CloneNotSupportedException {   
        return super.clone();   
    }   
       
}   
  
class Student implements Cloneable{   
       
    public int age ;   
    public String name;   
    public Teacher teacher;   
    public int getAge() {   
        return age;   
    }   
    public void setAge(int age) {   
        this.age = age;   
    }   
    public String getName() {   
        return name;   
    }   
    public void setName(String name) {   
        this.name = name;   
    }   
    public Teacher getTeacher() {   
        return teacher;   
    }   
    public void setTeacher(Teacher teacher) {   
        this.teacher = teacher;   
    }   
    @Override  
    public Object clone() throws CloneNotSupportedException {   
        Student student = (Student)super.clone();   
        //将引用的对象teacher也clone下   
        student.setTeacher((Teacher)(student.getTeacher().clone()));   
        return student;   
    }   
       
       
}   
输出结果为：   
20  
zhangsan   
~~~~~~~~~~~~~~~~~~~~~~   
40  
Teacher zhang   
~~~~~~~~~~~~~~~~~~~~~~   
40  
Teacher zhang

3.利用序列化来做深复制,把对象写到流里的过程是序列化（Serilization）过程，而把对象从流中读出来的过程则叫做反序列化（Deserialization）过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。，利用这个特性，可以做深拷贝 
package com.test3;   
  
import java.io.ByteArrayInputStream;   
import java.io.ByteArrayOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.Serializable;   
//利用序列化来做深复制   
//深clone   
public class DeepCloneTest {   
  
    public static void main(String[] args) throws Exception{   
        //teacher对象将不被clone出来的Student对象共享.   
        Teacher teacher = new Teacher();   
        teacher.setAge(40);   
        teacher.setName("Teacher zhang");   
           
        Student student1 = new Student();   
        student1.setAge(20);   
        student1.setName("zhangsan");   
        student1.setTeacher(teacher);   
           
        //复制出来一个对象student2   
        Student student2 = (Student)student1.deepCopy();   
        System.out.println(student2.getAge());   
        System.out.println(student2.getName());   
           
           
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");   
        System.out.println(student1.getTeacher().getAge());   
        System.out.println(student1.getTeacher().getName());   
           
           
        //修改student2的引用对象   
        student2.getTeacher().setAge(50);   
        student2.getTeacher().setName("Teacher Li");   
           
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");   
        System.out.println(student1.getTeacher().getAge());   
        System.out.println(student1.getTeacher().getName());   
    }   
}   
  
class Teacher implements Serializable{   
       
    private static final long serialVersionUID = -8834559347461591191L;   
       
    public int age;   
    public String name;   
       
    public int getAge() {   
        return age;   
    }   
    public void setAge(int age) {   
        this.age = age;   
    }   
    public String getName() {   
        return name;   
    }   
    public void setName(String name) {   
        this.name = name;   
    }   
       
}   
  
class Student implements Serializable{   
       
    //serialVersionUID 如果你的对象序列化后存到硬盘上面后，可是后来你却更改了类的field(增加或减少或改名)，当你反序列化时，就会出现Exception的，这样就会造成不兼容性的问题。    
    //但当serialVersionUID相同时，它就会将不一样的field以type的缺省值赋值(如int型的是0,String型的是null等)，这个可以避开不兼容性的问题。所以最好给serialVersionUID赋值   
    private static final long serialVersionUID = 7991552226614088458L;   
       
    public int age ;   
    public String name;   
    public Teacher teacher;   
    public int getAge() {   
        return age;   
    }   
    public void setAge(int age) {   
        this.age = age;   
    }   
    public String getName() {   
        return name;   
    }   
    public void setName(String name) {   
        this.name = name;   
    }   
    public Teacher getTeacher() {   
        return teacher;   
    }   
    public void setTeacher(Teacher teacher) {   
        this.teacher = teacher;   
    }   
       
    public Object deepCopy() throws Exception{   
        //将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝   
        ByteArrayOutputStream bos = new ByteArrayOutputStream();   
  
        ObjectOutputStream oos = new ObjectOutputStream(bos);   
  
        oos.writeObject(this);   
  
        //将流序列化成对象   
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());   
  
        ObjectInputStream ois = new ObjectInputStream(bis);   
  
        return ois.readObject();   
    }   
       
       
}   
输出结果为：   
20  
zhangsan   
~~~~~~~~~~~~~~~~~~~~~~   
40  
Teacher zhang   
~~~~~~~~~~~~~~~~~~~~~~   
40  
Teacher zhang
分享到：
jsp的自定义标签和函数
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java clone的小例子

    在Java编程语言中，`clone()`方法是一个非常重要的概念，特别是在对象复制和克隆方面。这个小例子将帮助初学者理解如何在Java中使用`clone()`来创建对象的副本。让我们深入探讨`clone()`方法以及它在实际编程中的...

    Java clone方法使用

    详细的描述了Java中 clone方法使用

    java Clone

    Java中的`clone`方法是Java语言提供的一种复制对象的方式，它允许创建一个对象的副本，这个副本与原对象具有相同的属性值，但它们是两个独立的对象，修改副本不会影响原对象。`clone`方法存在于Java的`java.lang....

    Java Clone深拷贝与浅拷贝的两种实现方法

    Java Clone 深拷贝与浅拷贝的两种实现方法 Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅...

    Java Clone(类的复制)实例代码

    在Java编程语言中，`Clone`机制是一种对象复制的方式，允许创建一个现有对象的副本。在Java中，对象的默认复制是浅复制（shallow copy），这意味着只复制对象本身，而不复制它引用的对象。要实现深复制（deep copy）...

    java_clone用法

    ### Java中的`clone`方法详解：浅拷贝与深拷贝 #### 一、引言 在Java中，`clone`方法提供了一种快速复制对象的方式。它属于`Object`类的一部分，但需要显式地在子类中声明并实现`Cloneable`接口才能正常使用。本文...

    关于java clone的一些基本的概念

    在Java编程语言中，`clone`是一个非常重要的概念，它涉及到对象复制和对象的深拷贝与浅拷贝。本文将深入探讨Java中的`clone`方法及其相关知识点。 首先，`clone`方法是Java `Object`类的一个成员方法，定义为`...

    Java clone方法详解及简单实例

    Java中的`clone`方法是Java语言提供的一种复制对象的机制，它允许创建一个现有对象的副本，这个副本具有与原始对象相同的状态，但它们是独立的实体，对其中一个对象的修改不会影响另一个。`clone`方法是Java `Object...

    Java中的clone方法详解_动力节点Java学院

    Java中的clone方法详解_动力节点Java学院，动力节点口口相传的Java黄埔军校

    Java中的克隆(Clone)机制

    在Java编程语言中，克隆（Clone）机制是一种创建对象副本的方法，它允许开发者创建一个已有对象的新实例，这个新实例与原对象具有相同的属性值，但却是两个独立的对象，彼此的操作不会互相影响。克隆机制在某些情况...

    clone()示例源码

    在Java编程语言中，`clone()`方法是一个非常重要的概念，特别是在处理对象复制和克隆时。这个方法源自`Object`类，是所有Java类的基类。`clone()`的使用通常涉及到深度复制和浅复制的概念，这两者在数据结构和内存...

    Java中的clone方法详解_动力节点Java学院整理

    Java中的clone方法详解 在Java语言中，clone方法是一个非常重要的概念，它允许对象被复制，从而创造出一个新的对象。下面我们将详细介绍Java中的clone方法，并讨论它的实现机制和应用场景。 什么是clone方法 ...

    java 中clone()的使用方法

    Java 中 clone() 的使用方法 Java 中的 clone() 方法是对象的复制方法，其主要作用是创建一个与原对象相同的新对象。下面将详细介绍 Java 中 clone() 方法的使用方法。 什么是 clone() 方法？ clone() 方法是 ...

    Java深浅clone

    在Java编程语言中，`Cloneable`接口和`clone()`方法是两个重要的概念，它们用于对象复制。在本文中，我们将深入探讨Java中的浅克隆（shallow clone）和深克隆（deep clone），并结合测试代码进行分析。 首先，让...

    如何通过JVM角度谈谈Java的clone操作

    Java中的对象创建主要有两种方式，即使用`new`操作符创建新对象以及通过`clone`方法复制已有对象。本文将从JVM的角度深入探讨Java的`clone`操作，揭示其工作原理及其潜在的问题。 首先，让我们理解`clone`方法的...

    java中clone的用法实例

    clone的用法 希望有帮助，仅供参考 通过例子的分析，可以对克隆的方法有所深入了解

    Java clone()方法来由及用法

    并且由于Java不能通过简单的赋值来解决对象复制的问题，在开发过程中，也常常要要应用clone（）方法来复制对象。比如函数参数类型是自定义的类时，此时便是引用传递而不是值传递。以下是一个小例子： ...

Magicbox
Global site tag (gtag.js) - Google Analytics