I wrote a technical blog for the first time. I am very skilled and have a limited level. I would like to give you some advice on anything wrong.
LargeAll knowCIASSIt is a reference type. If a referenced variable is assigned to another referenced variable, this assignment is performed on a shortest copy. The two referenced variables point to the same object in the memory. We have such a classIs to execute this operation.
Code
Public Class Testclass
{
Private Int _ X;
Private Int _ Y;
Public Testclass ( Int X, Int Y)
{
This . _ X = X;
This . _ Y = Y;
}
Public Int X
{
Set { This . _ X = Value ;}
}
}
Static Void Main ( String [] ARGs)
{
Testclass class1 = New Testclass ( 1 , 1 );
Testclass class2 = Class1;
Class2.x = 2 ;
}
In this case, we modifyClass2OfXValueClass1MediumXThe value will also change.
In some cases, what should we do if we need a copy of an existing class instance? At this time, we need to implementIcloneableInterface.
IcloneableThe interface is defined as follows:
Code
[Comvisible ( True )]
Public Interface Icloneable
{
// Abstract:
// Creates a new object that is a copy of the current instance.
//
// Returned results:
// A new object that is a copy of this instance.
Object Clone ();
}
ComvisibleThe feature is to set whether to allowComClient Access, which is not detailed here.
If we want our custom classes to provide deep copy capabilities, there are two situations: one is that our custom classes do not contain variables of the reference type; in another case, whenIt is a variable that contains the reference type. The following two cases are described respectively.
Now ourTestclassThe class has only two member variables._ X, _ Y is a value-type variable. A value-type variable does not contain a pointer to an instance. It contains all the content of the instance.IcloneableInterfaceThe clone () method copies each value type field in order in the method. The clone method is
Public Object Clone ()
{
// Because all our fields are assigned values in the constructor, you can build a new instance with the same value.
Return New Testclass (_ x, _ y );
}
. NetAll types are ultimately inherited from the system. Object type, so we can continue to improve the above clone method, using the protected method provided by the system. Object Type
Memberwiseclone: This method creates a new type instance and sets the field to be the same as the field of this object. Now our field is of the value type, so this method can obtain the instance'sIndependent copy.
CloneMethod changed:
Public Object Clone ()
{
// Copy each field of testclass one by one
Return Base . Memberwiseclone ();
}
Now testclass is changed:
Code Public Class Testclass: icloneable
{
Private Int _ X;
Private Int _ Y;
Public Testclass ( Int X, Int Y)
{
This . _ X = X;
This . _ Y = Y;
}
Public int x
{< br> set { This . _ x = value ;}< br> }
Public Object Clone ()
{
// Copy each field of testclass one by one
Return Base . Memberwiseclone ();
}
}
In this way, we can obtain a separate copy of testclass, as shown below:
Code Static Void Main ( String [] ARGs)
{
Testclass class1 = New Testclass ( 1 , 1 );
Testclass class2 = (Testclass) class1.clone ();
// Changing class2 does not affect class1.
Class2.x = 2 ;
}
Contains the type of the referenced variable field. The method of deep copy is similar to the preceding method, note that the reference type is saved in the stack. All direct value assignment to the pointer pointing to the managed heap and the memberwiseclone method both copy the pointer address and actually point to the same instance. We need to build a new type of instance with the same value in the clone method and return it.