标签：赋值 veth 访问 避免 属性 prot 隔离 区别 over
在开始之前，我们先来看以下代码存在什么问题？class
CloneTest
{
public
static
void
main
(
String
[]
args
)
throws
CloneNotSupportedException
{
// 等号赋值（ 基本类型）
int
number
=
6
;
int
number2
=
number
;
// 修改 number2 的值
number2
=
9
;
System
.
out
.
println
(
"number："
+
number
);
System
.
out
.
println
(
"number2："
+
number2
);
// 等号赋值（对象）
Dog
dog
=
new
Dog
();
dog
.
name
=
"旺财"
;
dog
.
age
=
5
;
Dog
dog2
=
dog
;
// 修改 dog2 的值
dog2
.
name
=
"大黄"
;
dog2
.
age
=
3
;
System
.
out
.
println
(
dog
.
name
+
"，"
+
dog
.
age
+
"岁"
);
System
.
out
.
println
(
dog2
.
name
+
"，"
+
dog2
.
age
+
"岁"
);
}
}程序执行结果：
number
：
6
number2
：
9
大黄，
3
岁
大黄，
3
岁可以看出，如果使用等号复制时，对于值类型来说，彼此之间的修改操作是相对独立的，而对于引用类型来说，因为复制的是引用对象的内存地址，所以修改其中一个值，另一个值也会跟着变化，原理如下图所示：
因此为了防止这种问题的发生，就要使用对象克隆来解决引用类型复制的问题。
1）浅克隆
默认的 clone() 方法，为浅克隆，代码如下：
class
CloneTest
{
public
static
void
main
(
String
[]
args
)
throws
CloneNotSupportedException
{
Dog
dog
=
new
Dog
();
dog
.
name
=
"旺财"
;
dog
.
age
=
5
;
// 克隆
Dog
dog3
=
(
Dog
)
dog
.
clone
();
dog3
.
name
=
"小白"
;
dog3
.
age
=
2
;
System
.
out
.
println
(
dog
.
name
+
"，"
+
dog
.
age
+
"岁"
);
System
.
out
.
println
(
dog3
.
name
+
"，"
+
dog3
.
age
+
"岁"
);
}
}
class
Dog
implements
Cloneable
{
public
String
name
;
public
int
age
;
@Override
protected
Object
clone
()
throws
CloneNotSupportedException
{
return
super
.
clone
();
}
}程序执行结果：
旺财，
5
岁
小白，
2
岁可以看出使用克隆就可以解决引用类型复制的问题了，原理如下图所示：
以上这种复制方式叫做浅克隆。浅克隆的实现条件：需要克隆的对象必须实现 Cloneable 接口，并重写 clone() 方法，即可实现对此对象的克隆。然而使用浅克隆也会存在一个问题，请参考以下代码。
class
CloneTest
{
public
static
void
main
(
String
[]
args
)
throws
CloneNotSupportedException
{
DogChild
dogChild
=
new
DogChild
();
dogChild
.
name
=
"二狗"
;
Dog
dog4
=
new
Dog
();
dog4
.
name
=
"大黄"
;
dog4
.
dogChild
=
dogChild
;
Dog
dog5
=
(
Dog
)
dog4
.
clone
();
dog5
.
name
=
"旺财"
;
dog5
.
dogChild
.
name
=
"狗二"
;
System
.
out
.
println
(
"dog name 4："
+
dog4
.
name
);
System
.
out
.
println
(
"dog name 5："
+
dog5
.
name
);
System
.
out
.
println
(
"dog child name 4："
+
dog4
.
dogChild
.
name
);
System
.
out
.
println
(
"dog child name 5："
+
dog5
.
dogChild
.
name
);
}
}
class
Dog
implements
Cloneable
{
public
String
name
;
public
DogChild
dogChild
;
@Override
protected
Object
clone
()
throws
CloneNotSupportedException
{
return
super
.
clone
();
}
}
class
DogChild
{
public
String
name
;
}程序执行结果：
dog name
4
：大黄
dog name
5
：旺财
dog child name
4
：狗二
dog child name
5
：狗二也就是说浅克隆，只会复制对象的值类型，而不会复制对象的引用类型。原因如下图所示：
要处理引用类型不被复制的问题，就要使用到深克隆。
2）深克隆
定义：深克隆就是复制整个对象信息，包含值类型和引用类型。深克隆的实现方式通常包含以下两种。
实现思路：先将要拷贝对象写入到内存中的字节流中，然后再从这个字节流中读出刚刚存储的信息，作为一个新对象返回，那么这个新对象和原对象就不存在任何地址上的共享，自然实现了深拷贝。请参考以下代码：
class
CloneTest
{
public
static
void
main
(
String
[]
args
)
throws
CloneNotSupportedException
{
BirdChild
birdChild
=
new
BirdChild
();
birdChild
.
name
=
"小小鸟"
;
Bird
bird
=
new
Bird
();
bird
.
name
=
"小鸟"
;
bird
.
birdChild
=
birdChild
;
// 使用序列化克隆对象
Bird
bird2
=
CloneUtils
.
clone
(
bird
);
bird2
.
name
=
"黄雀"
;
bird2
.
birdChild
.
name
=
"小黄雀"
;
System
.
out
.
println
(
"bird name:"
+
bird
.
name
);
System
.
out
.
println
(
"bird child name:"
+
bird
.
birdChild
.
name
);
System
.
out
.
println
(
"bird name 2:"
+
bird2
.
name
);
System
.
out
.
println
(
"bird child name 2:"
+
bird2
.
birdChild
.
name
);
}
}
class
CloneUtils
{
public
static
<
T
extends
Serializable
>
T clone
(
T obj
)
{
T cloneObj
=
null
;
try
{
//写入字节流
ByteArrayOutputStream
bo
=
new
ByteArrayOutputStream
();
ObjectOutputStream
oos
=
new
ObjectOutputStream
(
bo
);
oos
.
writeObject
(
obj
);
oos
.
close
();
//分配内存,写入原始对象,生成新对象
ByteArrayInputStream
bi
=
new
ByteArrayInputStream
(
bo
.
toByteArray
());
//获取上面的输出字节流
ObjectInputStream
oi
=
new
ObjectInputStream
(
bi
);
//返回生成的新对象
cloneObj
=
(
T
)
oi
.
readObject
();
oi
.
close
();
}
catch
(
Exception
e
)
{
e
.
printStackTrace
();
}
return
cloneObj
;
}
}程序执行结果：
bird name
:小鸟
bird child name
:小小鸟
bird name
2
:黄雀
bird child name
2
:小黄雀深克隆实现方式二：所有引用类型都实现克隆
class
SerializableTest
{
public
static
void
main
(
String
[]
args
)
throws
IOException
,
ClassNotFoundException
{
ParrotChild
parrotChild
=
new
ParrotChild
();
parrotChild
.
name
=
"小鹦鹉"
;
Parrot
parrot
=
new
Parrot
();
parrot
.
name
=
"大鹦鹉"
;
parrot
.
parrotChild
=
parrotChild
;
// 克隆
Parrot
parrot2
=
(
Parrot
)
parrot
.
clone
();
parrot2
.
name
=
"老鹦鹉"
;
parrot2
.
parrotChild
.
name
=
"少鹦鹉"
;
System
.
out
.
println
(
"parrot name:"
+
parrot
.
name
);
System
.
out
.
println
(
"parrot child name:"
+
parrot
.
parrotChild
.
name
);
System
.
out
.
println
(
"parrot name 2:"
+
parrot2
.
name
);
System
.
out
.
println
(
"parrot child name 2:"
+
parrot2
.
parrotChild
.
name
);
}
}
class
Parrot
implements
Cloneable
{
public
String
name
;
public
ParrotChild
parrotChild
;
@Override
protected
Object
clone
()
throws
CloneNotSupportedException
{
Parrot
bird
=
(
Parrot
)
super
.
clone
();
bird
.
parrotChild
=
(
ParrotChild
)
parrotChild
.
clone
();
return
bird
;
}
}
class
ParrotChild
implements
Cloneable
{
public
String
name
;
@Override
protected
Object
clone
()
throws
CloneNotSupportedException
{
return
super
.
clone
();
}
}程序执行结果：
parrot name
:大鹦鹉
parrot child name
:小鹦鹉
parrot name
2
:老鹦鹉
parrot child name
2
:少鹦鹉相关面试题
使用克隆有什么好处？
好处包含以下几点：
使用方便：假如要复制一个对象，但这个对象中的部分属性已经被修改过了，如果不使用克隆的话，需要给属性手动赋值，相比克隆而已麻烦很多；
性能高：查看 clone 方法可以知道，它是 native 方法，native 方法是原生函数，使用操作系统底层的语言实现的，因此执行效率更高；
隔离性：克隆可以确保对象操作时相互隔离。
clone() 源代码，如下图：
浅克隆和深克隆有什么区别？
答：区别主要在对引用类型的复制上，具体信息如下。
以下代码执行的结果是？
import
java
.
util
.
Arrays
;
class
CloneTest
{
public
static
void
main
(
String
[]
args
)
throws
CloneNotSupportedException
{
CloneObj
cloneObj
=
new
CloneObj
();
cloneObj
.
name
=
"老王"
;
cloneObj
.
age
=
30
;
cloneObj
.
sistersAge
=
new
int
[]{
18
,
19
};
CloneObj
cloneObj2
=
(
CloneObj
)
cloneObj
.
clone
();
cloneObj2
.
name
=
"磊哥"
;
cloneObj2
.
age
=
33
;
cloneObj2
.
sistersAge
[
0
]
=
20
;
System
.
out
.
println
(
cloneObj
.
name
+
"|"
+
cloneObj2
.
name
);
System
.
out
.
println
(
cloneObj
.
age
+
"|"
+
cloneObj2
.
age
);
System
.
out
.
println
(
Arrays
.
toString
(
cloneObj
.
sistersAge
)
+
"|"
+
Arrays
.
toString
(
cloneObj2
.
sistersAge
));
}
}
class
CloneObj
implements
Cloneable
{
public
String
name
;
public
int
age
;
public
int
[]
sistersAge
;
@Override
protected
Object
clone
()
throws
CloneNotSupportedException
{
return
super
.
clone
();
}
}
答：执行结果如下。
老王|磊哥
30
|
33
[
20
,
19
]|[
20
,
19
]深克隆如何实现？有几种实现方式？
答：一般实现方式有以下两种：
序列化可不可以实现深克隆？实现的原理是什么？
答：先将原对象序列化到内存的字节流中，再从字节流中反序列化出刚刚存储的对象，这个新对象和原对象就不存在任何地址上的共享，这样就实现了深克隆。
是否可以自定义序列化过程，覆盖 Java 中的默认序列化过程？
答：可以，在 Java 中默认序列化一个对象需要调用 ObjectOutputStream.writeObject(saveThisObject) 和 ObjectInputStream.readObject() 读取对象，你可以自定义这两个方法，从而实现自定义序列化的过程。需要注意的重要一点是，记得声明这些方法为私有方法，以避免被继承、重写或重载。
以上内容来自《Java面试全解析》
【End】
关注下方二维码，订阅更多精彩内容。
老王著
转发更佳
稀罕作者
标签：赋值 veth 访问 避免 属性 prot 隔离 区别 over
原文地址：https://blog.51cto.com/13904087/2515730
