精华内容
下载资源
问答
  • Clone方法

    2016-03-19 09:51:26
    clone方法返回对象的一个副本,两个对象不相等。即x.clone!=x;(内存不相等) x.clone.getclass=x.getclass(值相等)。clone是浅拷贝,对象里面的对象还是会捆绑,所以对象里面的对象也要写clone方法。对象要贴标签...

    clone方法返回对象的一个副本,两个对象不相等。即x.clone!=x;(内存不相等) x.clone.getclass=x.getclass(值相等)。clone是浅拷贝,对象里面的对象还是会捆绑,所以对象里面的对象也要写clone方法。对象要贴标签(implements clonable)才能clone 。clone 三部曲:1声明实现  (implements clonable)   2调用super.clone 拿到一个对象 (写clone函数)  3 把浅拷贝的引用只想原型对象新的克隆体

    当要克隆的类中只有基础数据类型或者不可变的引用类型时只需 retrun super.clone();

    而引用类型的变量会捆绑时,要用深clone。  Account a=(Account)super.clone(); if(user!=null){ a.user=(user)user.clone()}

    就是对象里面的对象再克隆一边。这里要注意的是,每个对象都要贴标签,和写clone方法 我们看代码:

    主类

    package cn.hncu.clone;
    
    public class cloneDemo {
    	public static void main(String[] args) {
    		//浅克隆
    		System.out.println("浅克隆");
    		Person p=new Person("大浪B普郎东", 22);
    		try {
    			Person p1=(Person) p.clone();
    			System.out.println(p.toString());
    			System.out.println(p1.toString());
    			System.out.println("----------");
    			p.setName("大帅比东东");
    			System.out.println(p.toString());
    			System.out.println(p1.toString());
    		} catch (CloneNotSupportedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("-----------------"+"\t\n"+"深克隆\t\n*****************");
    		//深克隆
    		Student s=new Student(p, 100);
    		try {
    			Student s1=(Student) s.clone();
    			System.out.println(s.toString());
    			System.out.println(s1.toString());
    			System.out.println("************");
    			s.setScore(88);
    			System.out.println(s.toString());
    			System.out.println(s1.toString());
    			
    			
    		} catch (CloneNotSupportedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		
    		
    	}
    
    }
    

    Person类:

    package cn.hncu.clone;
    public class Person implements Cloneable{
    	private String name;
    	private int age;
    	public Person(String name, int age) {
    		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;
    	}
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	@Override
    	protected Object clone() throws CloneNotSupportedException {
    		return super.clone();
    	}
    	
    	
    }
    

    Student类:

    package cn.hncu.clone;
    
    public class Student implements Cloneable{
    	Person person;
    	private int score;
    	public Student(Person person, int score) {
    		this.person = person;
    		this.score = score;
    	}
    	@Override
    	public String toString() {
    		return "Student [person=" + person + ", score=" + score + "]";
    	}
    	public Person getPerson() {
    		return person;
    	}
    	public void setPerson(Person person) {
    		this.person = person;
    	}
    	public int getScore() {
    		return score;
    	}
    	public void setScore(int score) {
    		this.score = score;
    	}
    	@Override
    	protected Object clone() throws CloneNotSupportedException {
    		Student s=(Student) super.clone();
    		if(s!=null){
    			s.person=(Person) person.clone();
    		}
    		return s;
    	}
    	
    	
    }
    


    展开全文
  • clone方法

    2014-08-29 10:49:32
    在实际编程过程中,我们常常要遇到这种情况:有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能会需要一个和...要满足这种需求虽然有很多途径,但实现clone()方法是其中最简单,也是最高效的手段。  Jav

    在实际编程过程中,我们常常要遇到这种情况:有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能会需要一个和A完全相同新对象B,并且此后对B 任何改动都不会影响到A中的值,也就是说,A与B是两个独立的对象,但B的初始值是由A对象确定的。在Java语言中,用简单的赋值语句是不能满足这种需 求的。要满足这种需求虽然有很多途径,但实现clone()方法是其中最简单,也是最高效的手段。 

    Java的所有类都默认继承java.lang.Object类,在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点:一是拷贝对象返回的是一个新对象,而不是一个引用。二是拷贝对象与用 new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息,而不是对象的初始信息。

    3.2.怎样应用clone()方法?

    一个很典型的调用clone()代码如下: 

    class CloneClass implements Cloneable{ 
    public int aInt; 
    public Object clone(){ 
    CloneClass o = null; 
    try{ 
    o = (CloneClass)super.clone(); 
    }catch(CloneNotSupportedException e){ 
    e.printStackTrace(); 

    return o; 

    } 
    有三个值得注意的地方,

    一是希望能实现clone功能的CloneClass类实现了Cloneable接口,这个接口属于java.lang包, java.lang包已经被缺省的导入类中,所以不需要写成java.lang.Cloneable。

    另一个值得请注意的是重载了clone()方法。最 后在clone()方法中调用了super.clone(),这也意味着无论clone类的继承结构是什么样的,super.clone()直接或间接调 用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。

    应该说第三点是最重要的,仔细观察一下Object类的clone()一个native方法,native方法的效率一般来说都是远高于java中的非 native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类,然后把原始对象中的信息赋到新对象中,虽然这也实现了 clone功能。对于第二点,也要观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方 法,必须继承Object类,在Java中所有的类是缺省继承Object类的,也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为 了让其它类能调用这个clone类的clone()方法,重载之后要把clone()方法的属性设置为public。 、

    那么clone类为什么还要实现Cloneable接口呢?稍微注意一下,Cloneable接口是不包含任何方法的!其实这个接口仅仅是一个标志,而且 这个标志也仅仅是针对Object类中clone()方法的,如果clone类没有实现Cloneable接口,并调用了Objectclone()法(也就是调用了super.Clone()方法),那么Objectclone()方法就会抛出 CloneNotSupportedException异常。

    以上是clone的最基本的步骤,想要完成一个成功的clone,还要了解什么是"影子clone"和"深度clone"。

    3.3什么是影子clone?

    下面的例子包含三个类UnCloneA,CloneB,CloneMain。CloneB类包含了一个UnCloneA的实例和一个int类型变量,并且 重载clone()方法。CloneMain类初始化UnCloneA类的一个实例b1,然后调用clone()方法生成了一个b1的拷贝b2。最后考察 一下b1和b2的输出: 

    package clone; 
    class UnCloneA { 
    private int i; 
    public UnCloneA(int ii) { i = ii; } 
    public void doublevalue() { i *= 2; } 
    public String toString() { 
    return Integer.toString(i); 


    class CloneB implements Cloneable{ 
    public int aInt; 
    public UnCloneA unCA = new UnCloneA(111); 
    public Object clone(){ 
    CloneB o = null; 
    try{ 
    o = (CloneB)super.clone(); 
    }catch(CloneNotSupportedException e){ 
    e.printStackTrace(); 

    return o; 


    public class CloneMain { 
    public static void main(String[] a){ 
    CloneB b1 = new CloneB(); 
    b1.aInt = 11; 
    System.out.println("before clone,b1.aInt = "+ b1.aInt); 
    System.out.println("before clone,b1.unCA = "+ b1.unCA); 

    CloneB b2 = (CloneB)b1.clone(); 
    b2.aInt = 22; 
    b2.unCA.doublevalue(); 
    System.out.println("================================="); 
    System.out.println("after clone,b1.aInt = "+ b1.aInt); 
    System.out.println("after clone,b1.unCA = "+ b1.unCA); 
    System.out.println("================================="); 
    System.out.println("after clone,b2.aInt = "+ b2.aInt); 
    System.out.println("after clone,b2.unCA = "+ b2.unCA); 




    /** RUN RESULT: 
    before clone,b1.aInt = 11 
    before clone,b1.unCA = 111 
    ================================= 
    after clone,b1.aInt = 11 
    after clone,b1.unCA = 222 
    ================================= 
    after clone,b2.aInt = 22 
    after clone,b2.unCA = 222 
    */ 

    输出的结果说明int类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致,int类型是真正的被clone了,因为改变了 b2中的aInt变量,对b1的aInt没有产生影响,也就是说,b2.aInt与b1.aInt已经占据了不同的内存空间,b2.aInt是 b1.aInt的一个真正拷贝。相反,对b2.unCA的改变同时改变了b1.unCA,很明显,b2.unCA和b1.unCA是仅仅指向同一个对象的 不同引用!从中可以看出,调用Object类中clone()方法产生的效果是:先在内存中开辟一块和原始对象一样的空间,然后原样拷贝原始对象中的内 容。对基本数据类型,这样的操作是没有问题的,但对非基本类型变量,我们知道它们保存的仅仅是对象的引用,这也导致clone后的非基本类型变量和原始对 象中相应的变量指向的是同一个对象。 

    大多时候,这种clone的结果往往不是我们所希望的结果,这种clone也被称为"影子clone"。要想让b2.unCA指向与b2.unCA不同的对象,而且b2.unCA中还要包含b1.unCA中的信息作为初始信息,就要实现深度clone。

     

    3.4怎么进行深度clone?

    把上面的例子改成深度clone很简单,需要两个改变:一是让UnCloneA类也实现和CloneB类一样的clone功能(实现Cloneable接 口,重载clone()方法)。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone(); 

    程序如下: 

    package clone.ext; 
    class UnCloneA implements Cloneable{ 
    private int i; 
    public UnCloneA(int ii) { i = ii; } 
    public void doublevalue() { i *= 2; } 
    public String toString() { 
    return Integer.toString(i); 

    public Object clone(){ 
    UnCloneA o = null; 
    try{ 
    o = (UnCloneA)super.clone(); 
    }catch(CloneNotSupportedException e){ 
    e.printStackTrace(); 

    return o; 


    class CloneB implements Cloneable{ 
    public int aInt; 
    public UnCloneA unCA = new UnCloneA(111); 
    public Object clone(){ 
    CloneB o = null; 
    try{ 
    o = (CloneB)super.clone(); 
    }catch(CloneNotSupportedException e){ 
    e.printStackTrace(); 

    o.unCA = (UnCloneA)unCA.clone(); 
    return o; 


    public class CloneMain { 
    public static void main(String[] a){ 
    CloneB b1 = new CloneB(); 
    b1.aInt = 11; 
    System.out.println("before clone,b1.aInt = "+ b1.aInt); 
    System.out.println("before clone,b1.unCA = "+ b1.unCA); 

    CloneB b2 = (CloneB)b1.clone(); 
    b2.aInt = 22; 
    b2.unCA.doublevalue(); 
    System.out.println("================================="); 
    System.out.println("after clone,b1.aInt = "+ b1.aInt); 
    System.out.println("after clone,b1.unCA = "+ b1.unCA); 
    System.out.println("================================="); 
    System.out.println("after clone,b2.aInt = "+ b2.aInt); 
    System.out.println("after clone,b2.unCA = "+ b2.unCA); 



    /** RUN RESULT: 
    before clone,b1.aInt = 11 
    before clone,b1.unCA = 111 
    ================================= 
    after clone,b1.aInt = 11 
    after clone,b1.unCA = 111 
    ================================= 
    after clone,b2.aInt = 22 
    after clone,b2.unCA = 222 
    */ 

    可以看出,现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例,而且在 CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的值,在这里,b1.i = b2.i = 11。 

    要知道不是所有的类都能实现深度clone的。例如,如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型,看一下 JDK API中关于StringBuffer的说明,StringBuffer没有重载clone()方法,更为严重的是StringBuffer还是一个 final类,这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和 StringBuffer相似类的对象,我们有两种选择:要么只能实现影子clone,要么就在类的clone()方法中加一句(假设是 SringBuffer对象,而且变量名仍是unCA): o.unCA = new StringBuffer(unCA.toString()); //原来的是:o.unCA = (UnCloneA)unCA.clone(); 

    还要知道的是除了基本数据类型能自动实现深度clone以外,String对象,Integer,Double等是一个例外,它clone后的表现好象也实现了深度clone,虽然这只是一个假象,但却大大方便了我们的编程。 

    Clone中String和StringBuffer的区别 

    应该说明的是,这里不是着重说明String和StringBuffer的区别,但从这个例子里也能看出String类的一些与众不同的地方。 

    下面的例子中包括两个类,CloneC类包含一个String类型变量和一个StringBuffer类型变量,并且实现了clone()方法。在 StrClone类中声明了CloneC类型变量c1,然后调用c1的clone()方法生成c1的拷贝c2,在对c2中的String和 StringBuffer类型变量用相应的方法改动之后打印结果: 

    package clone; 
    class CloneC implements Cloneable{ 
    public String str; 
    public StringBuffer strBuff; 
    public Object clone(){ 
    CloneC o = null; 
    try{ 
    o = (CloneC)super.clone(); 
    }catch(CloneNotSupportedException e){ 
    e.printStackTrace(); 

    return o; 



    public class StrClone { 
    public static void main(String[] a){ 
    CloneC c1 = new CloneC(); 
    c1.str = new String("initializeStr"); 
    c1.strBuff = new StringBuffer("initializeStrBuff"); 
    System.out.println("before clone,c1.str = "+ c1.str); 
    System.out.println("before clone,c1.strBuff = "+ c1.strBuff); 

    CloneC c2 = (CloneC)c1.clone(); 
    c2.str = c2.str.substring(0,5); 
    c2.strBuff = c2.strBuff.append(" change strBuff clone"); 
    System.out.println("================================="); 
    System.out.println("after clone,c1.str = "+ c1.str); 
    System.out.println("after clone,c1.strBuff = "+ c1.strBuff); 
    System.out.println("================================="); 
    System.out.println("after clone,c2.str = "+ c2.str); 
    System.out.println("after clone,c2.strBuff = "+ c2.strBuff); 


    /* RUN RESULT 
    before clone,c1.str = initializeStr 
    before clone,c1.strBuff = initializeStrBuff 
    ================================= 
    after clone,c1.str = initializeStr 
    after clone,c1.strBuff = initializeStrBuff change strBuff clone 
    ================================= 
    after clone,c2.str = initi 
    after clone,c2.strBuff = initializeStrBuff change strBuff clone 

    */ 

    打印的结果可以看出,String类型的变量好象已经实现了深度clone,因为对c2.str的改动并没有影响到c1.str!难道Java把 Sring类看成了基本数据类型?其实不然,这里有一个小小的把戏,秘密就在于c2.str = c2.str.substring(0,5)这一语句!实质上,在clone的时候c1.str与c2.str仍然是引用,而且都指向了同一个 String对象。但在执行c2.str = c2.str.substring(0,5)的时候,它作用相当于生成了一个新的String类型,然后又赋回给c2.str。这是因为String被Sun公司的工程师写成了一个不可更改的类(immutable class),在所有String类中的函数都不能更改自身的值。下面给出很简单的一个例子: 

    package clone; public class StrTest { public static void main(String[] args) { String str1 = "This is a test for immutable"; String str2 = str1.substring(0,8); System.out.println("print str1 : " + str1); System.out.println("print str2 : " + str2); } } /* RUN RESULT print str1 : This is a test for immutable print str2 : This is */ 

    例子中,虽然str1调用了substring()方法,但str1的值并没有改变。类似的,String类中的其它方法也是如此。当然如果我们把最上面的例子中的这两条语句 

    c2.str = c2.str.substring(0,5); 
    c2.strBuff = c2.strBuff.append(" change strBuff clone"); 

    改成下面这样: 

    c2.str.substring(0,5); 
    c2.strBuff.append(" change strBuff clone"); 

    去掉了重新赋值的过程,c2.str也就不能有变化了,我们的把戏也就露馅了。但在编程过程中只调用 
    c2.str.substring(0,5); 语句是没有任何意义的。 

    应该知道的是在Java中所有的基本数据类型都有一个相对应的类,象Integer类对应int类型,Double类对应double类型等等,这些类也 与String类相同,都是不可以改变的类。也就是说,这些的类中的所有方法都是不能改变其自身的值的。这也让我们在编clone类的时候有了一个更多的 选择。同时我们也可以把自己的类编成不可更改的类。

    展开全文
  • java clone方法 日期类clone()方法 (Date Class clone() method) clone() method is available in java.util package. clone()方法在java.util包中可用。 clone() method is used to returns a copy or clone of ...

    java clone方法

    日期类clone()方法 (Date Class clone() method)

    • clone() method is available in java.util package.

      clone()方法在java.util包中可用。

    • clone() method is used to returns a copy or clone of this Date object or in other words, we can say it returns a shallow copy of this Date object.

      clone()方法用于返回此Date对象的副本或克隆,换句话说,可以说它返回此Date对象的浅表副本。

    • clone() method is a non-static method, it is accessible with the class object only and if we try to access the method with the class name then we will get an error.

      clone()方法是一个非静态方法,只能通过类对象访问,如果尝试使用类名称访问该方法,则会收到错误消息。

    • clone() method does not throw an exception at the time of cloning Date object.

      克隆Date对象时, clone()方法不会引发异常。

    Syntax:

    句法:

        public Object clone();
    
    

    Parameter(s):

    参数:

    • It does not accept any parameter.

      它不接受任何参数。

    Return value:

    返回值:

    The return type of this method is Object, it returns a cloned Date object.

    该方法的返回类型为Object ,它返回一个克隆的Date对象。

    Example:

    例:

    // Java program to demonstrate the example 
    // of Object clone () method of Date
    
    import java.util.*;
    
    public class CloneOfDate {
        public static void main(String[] args) {
            // create two Date object
            Date this_date = new Date(2016, 8, 20);
    
            // Display Date object
            System.out.println("this_date: " + this_date.toString());
    
            // By using clone() method is to clone
            // this date
            Object cloned_date = this_date.clone();
    
            // Display cloned date
            System.out.println("this_date.clone(): " + cloned_date.toString());
        }
    }
    
    

    Output

    输出量

    this_date: Wed Sep 20 00:00:00 GMT 3916
    this_date.clone(): Wed Sep 20 00:00:00 GMT 3916
    
    
    

    翻译自: https://www.includehelp.com/java/date-clone-method-with-example.aspx

    java clone方法

    展开全文
  • java clone方法 ArrayDeque类clone()方法 (ArrayDeque Class clone() method) clone() Method is available in java.lang package. clone()方法在java.lang包中可用。 clone() Method is used to returns a copy or ...

    java clone方法

    ArrayDeque类clone()方法 (ArrayDeque Class clone() method)

    • clone() Method is available in java.lang package.

      clone()方法在java.lang包中可用。

    • clone() Method is used to returns a copy or clone of this deque.

      clone()方法用于返回此双端队列的副本或克隆。

    • clone() Method is a non-static method, it is accessible with the class object only and if we try to access the method with the class name then we will get an error.

      clone()方法是一种非静态方法,只能通过类对象访问,如果尝试使用类名称访问该方法,则会收到错误消息。

    • clone() Method does not throw an exception at the time of cloning all of the elements from deque.

      从双端队列克隆所有元素时, clone()方法不会引发异常。

    Syntax:

    句法:

        public ArrayDeque<T> clone();
    
    

    Parameter(s):

    参数:

    • It does not accept any parameter.

      它不接受任何参数。

    Return value:

    返回值:

    The return type of the method is ArrayDeque<T>, it returns cloned array deque.

    该方法的返回类型为ArrayDeque <T> ,它返回克隆的数组双端队列。

    Example:

    例:

    // Java program to demonstrate the example 
    // of ArrayDeque<T> clone() method of ArrayDeque 
    
    import java.util.*;
    
    public class CloneOfArrayDeque {
        public static void main(String[] args) {
            // Creating an ArrayDeque with initial capacity of
            // storing elements
            ArrayDeque < String > d_queue1 = new ArrayDeque < String > (10);
    
            // By using add() method to add elements
            // in ArrayDeque
            d_queue1.add("C");
            d_queue1.add("C++");
            d_queue1.add("Java");
            d_queue1.add("Php");
            d_queue1.add("DotNet");
    
            // Display Deque Elements
            System.out.println("d_queue1 : ");
            System.out.println("ArrayDeque Elements = " + d_queue1);
    
            // By using clone() method to clone the elements
            // of d_queue1 to d_queue2
            ArrayDeque < String > d_queue2 = d_queue1.clone();
    
            System.out.println();
    
            // Display Deque Elements
            System.out.println("d_queue2 = d_queue1.clone(): ");
            System.out.println("ArrayDeque = " + d_queue2);
        }
    }
    
    

    Output

    输出量

    d_queue1 : 
    ArrayDeque Elements = [C, C++, Java, Php, DotNet]
    
    d_queue2 = d_queue1.clone(): 
    ArrayDeque = [C, C++, Java, Php, DotNet]
    
    
    

    翻译自: https://www.includehelp.com/java/arraydeque-clone-method-with-example.aspx

    java clone方法

    展开全文
  • java clone方法 日历类clone()方法 (Calendar Class clone() method) clone() method is available in java.util package. clone()方法在java.util包中可用。 clone() method is used to return the cloned object ...
  • java clone 方法

    2019-02-15 11:38:26
    但是简单的clone方法,是只能针对java的八大数据类型和String来做的, 其他类型没办法直接clone成功,比如list,如果clone时,虽然数据可以在新的实例中显示 但是他并没生成新的对象,依然指向被克隆的对象地址; ...
  • 详解Java中的clone方法 -- 原型模式

    万次阅读 多人点赞 2014-01-19 23:45:22
    clone顾名思义就是复制, 在Java语言中, clone方法被对象调用,所以会复制对象。所谓的复制对象,首先要分配一个和源对象同样大小的空间,在这个空间中创建一个新的对象。那么在java语言中,有几种方式可以创建对象...
  • java clone方法 语言环境类clone()方法 (Locale Class clone() method) clone() method is available in java.util package. clone()方法在java.util包中可用。 clone() method is used to return clone copy or ...
  • java clone方法 日历类clone()方法 (Calendar Class clone() method) clone() method is available in java.util package. clone()方法在java.util包中可用。 clone() method is used to return the cloned ...
  • java Object 类中clone方法使用java clone方法学习理解 一、clone方法使用步骤 1、在当前类中实现接口: java.lang.Cloneable 2、重写 clone方法,将访问修饰符由 protected 调整 public 二、浅克隆 1、 浅...
  • 详解 clone方法

    2015-10-23 18:00:46
    clone顾名思义就是复制, 在Java语言中, clone方法被对象调用,所以会复制对象。所谓的复制对象,首先要分配一个和源对象同样大小的空间,在这个空间中创建一个新的对象。那么在java语言中,有几种方式可以创建对象...
  • Java:clone方法

    2020-03-08 18:36:49
    clone 方法是Object 的一个protected 方法, 这说明你的代码不能直接调用这个方法;只有本类可以克隆本类对象实例。 浅拷贝(浅表复制) 深拷贝 IO流进行深拷贝 都是不用关闭的流 与克隆相关的所有类都...
  • HashMap的clone方法

    千次阅读 2018-05-31 13:29:58
    在网上看有关HashMap的由关文章的时候,别人都说HashMap的clone方法是浅拷贝,但在看了源码后有所疑问,为什么HashMap的方法是浅拷贝呢?下面是对HashMap的clone方法的一个验证。 浅拷贝:对一个对象进行clone生成...
  • Java中clone方法详解

    2020-04-29 13:00:10
    Java中clone方法详解一、clone简介二、Java中对象的创建:new与clone创建对象的区别三、复制对象or复制引用:第一个例子(复制引用):第二个例子(复制对象):四、深拷贝 浅拷贝原理浅拷贝深拷贝 一、clone简介 ...
  • 详解java中clone方法

    2020-09-26 17:24:41
    clone顾名思义就是复制,在java语言中,clone方法被对象调用,所以会复制对象。那么就要分配一个和源对象同样大小的空间,在这个空间中创建一个新的的对象。java中创建对象有以下两种方式。 1、使用new操作符创建一...
  • 自定义方法实现clone方法(浅拷贝) 浅拷贝有一定的限制:基本数据类型可以完全复制,引用类型则不可以。深拷贝类似,可参考博客 以Person类为例调用clone方法实现浅拷贝 person类: public class Person implements...
  • Java Clone方法原理

    千次阅读 2017-01-15 14:51:59
    Clone方法原理:Object类的clone方法的原理是从内存中(具体地说就是堆内存)以二进制流的方式进行拷贝, 重新分配一个内存块,那构造函数没有被执行也是非常正常的了
  • Object的clone方法

    2016-11-01 10:33:43
    Object的clone方法参考: https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#clone() https://docs.oracle.com/javase/7/docs/api/java/lang/Cloneable.html要复制一个对象可以调用Object的clone...
  • 首先我们来看下clone方法的源码 protected native Object clone() throws CloneNotSupportedException; 通过源代码可以发现几点: clone方法是native方法,native方法的效率远高于非native方法,因此还是使用...
  • java使用clone方法Cloning is the process of creating a copy of an Object. Java Object class comes with native clone() method that returns the copy of the existing instance. 克隆是创建对象副本的过程。 ...
  • JAVA中clone方法详解

    千次阅读 2017-04-13 14:51:38
    JAVA中clone方法详解
  • ArrayList的clone方法

    2015-05-19 19:02:55
    ArrayList的clone方法是浅表复制,对于基本数据类型,clone方法复制其值,对于引用数据类型,则复制引用所指向对象的地址。
  • Java中的clone方法

    2018-05-27 11:30:23
    Java中的clone方法 1.clone方法是Java中对类的克隆的一个概念。 2.clone方法作用于类 3.clone分为浅克隆和深克隆 浅克隆指的是,如果一个对象A中持有对另外一个对象C的引用,那么在克隆对象A形成对象A1时,A1所...
  • 浅拷贝和Clone方法

    2017-06-05 20:17:35
    要实现对象间的Clone操作,首先,自定义类是没有默认的Clone方法的,必须要继承Cloneable这个接口来重载Clone方法,如下: public class KinderGardenStu extends Student implements GamePlayable,Cloneable { ...
  • 关于Cloneable和clone方法的认识: 1.Cloneable接口是一个标记接口,没有clone方法clone方法是在Object类中的,并且是protected的 2.一般地需要实现Cloneable和重写clone方法,并将修饰符改为public 3.如果没有...
  • VB中Recordset的clone方法

    2019-09-21 04:08:20
    在用vb的时候,发现了个奇怪的问题,见下面代码,在生成Recordset的过程中,调用了recordset的clone方法,clone后沒有做任何操作,及時跟踪的过程中发现clone前的原recordset對象rectemp的recordcount是26,但是但...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,870
精华内容 7,948
关键字:

clone方法