Java对象传递与返回的细节问题详析

目录

1.传递引用2. 创建本地副本

2.1 值传递2.2 对象克隆2.3 浅拷贝问题2.4 深拷贝

2.4.1 引用类型逐个浅拷贝2.4.2 序列化方式进行深拷贝



总结

1.传递引用

在一个方法中将一个对象的引用传递给另外一个方法，引用指向的对象是同一个

1. public class Person {
2.         int age;
3.         String name;
4.         public Person(int age, String name) {
5.                 this.age = age;
6.                 this.name = name;
7.         }
9.         public static void main(String[] args) {
10.                 Person p=new Person(18, "tom");
11.                 System.out.println("main:  "+p);
12.                 f(p);
13.         }
14.         public static void f(Person p) {
15.                 System.out.println("f():  "+p);
16.         }
17. }

复制代码

引用别名

1. public static void main(String[] args) {
2.                 Person p=new Person(18, "tom");
3.                 Person p2=p;
4.                 p2.age++;
5.                 System.out.println(p.age);//19       
6.         }

复制代码

引用p和p2指向的是同一个对象，p2对对象的属性进行操作，当使用引用p访问对象的属性时当然也改变，同样的情况也发生在对象引用在方法之间的传递，如下面的代码：

1. public static void main(String[] args) {
2.                 Person p=new Person(18, "tom");
3.                 f(p);
4.                 System.out.println(p.age);//19       
5.         }
6.         public static void f(Person p) {
7.                 p.age++;
8.         }

复制代码

2. 创建本地副本

几个概念：

引用别名会在方法参数是对象类型时自动发生没有本地对象，只有本地引用（方法中创建的对象存在于堆中，只有引用变量存在于方法栈中）引用是有作用域的，而对象没有Java中的对象的生命周期并不是一个问题（垃圾回收机制）

2.1 值传递

Java中方法之间只有值传递
传递基本类型时，传递的是基本类型的值的拷贝

1. public static void main(String[] args) {
2.                 int a=100;
3.                 change(a);
4.                 System.out.println(a);//100 不受影响
5.         }
6.         public static void change(int a) {
7.                 a=99;
8.         }

复制代码

传递对象时，传递的是对象的引用拷贝

1. public static void main(String[] args) {
2.                 Person p=new Person(18, "tom");
3.                 f(p);
4.                 System.out.println(p.age);//还是18 f()中p指向了一个新的对象 不影响main函数
5.         }
6.         public static void f(Person p) {
7.                 p=new Person(20, "bob");
8.         }

复制代码

传递对象时如果在另外一个方法中对对象的属性进行操作会对main方法产生“副作用”， 但是如果只是简单的对引用进行操作是没有影响的

2.2 对象克隆

步骤：
类实现Cloneable空接口，默认情况下不希望所有的类都有克隆能力，当需要某个类有克隆能力时就需要实现该接口作为一种“可克隆”的标记，否则克隆时会报错CloneNotSupportedException

1. public interface Cloneable {
2. }

复制代码

重写clone方法，clone方法是Object类中的，它在Object类中的是一个protected的本地方法，需要重写，加上public修饰符，否则只能在当前类中使用clone方法

1. protected native Object clone() throws CloneNotSupportedException;

复制代码

1. public class Person implements Cloneable {
2.         int age;
3.         String name;
4.         public Person(int age, String name) {
5.                 this.age = age;
6.                 this.name = name;
7.         }
9.         public Person clone() throws CloneNotSupportedException  {
10.                         return (Person) super.clone();
11.         }
13.         public static void main(String[] args) throws CloneNotSupportedException {
14.                 Person p1=new Person(18, "tom");
15.                 Person p2=p1.clone();
16.                 System.out.println(p1+"   name: "+p1.name+"  age: "+p1.age);
17.                 System.out.println(p2+"   name: "+p2.name+"  age: "+p2.age);
18.         }
19. }

复制代码

重写clone方法时实际是就是调用Object类中的本地clone方法，Object类中的clone方法做了哪些工作？

Object类中clone方法负责创建正确大小的存储空间，并执行了从原始对象中所有二进制位到新对象内存中的按位复制。

2.3 浅拷贝问题

场景：Person类中增加一个引用类型的属性Country, 表示这个人所属的国家，然后进行克隆

1. package test;
3. class Country{
4.         String nation;
6.         public Country(String nation) {
7.                 super();
8.                 this.nation = nation;
9.         }
11. }
12. public class Person implements Cloneable {
13.         int age;
14.         String name;
15.         Country country;
16.         public Person(int age, String name,Country country) {
17.                 this.age = age;
18.                 this.name = name;
19.                 this.country=country;
20.         }
22.         public Person clone() throws CloneNotSupportedException  {
23.                         return (Person) super.clone();
24.         }
26.         public static void main(String[] args) throws CloneNotSupportedException {
27.                 Country country=new Country("China");
28.                 Person p1=new Person(18, "tom",country);
29.                 Person p2=p1.clone();
30.                 System.out.println(p1+"   name: "+p1.name+"  age: "+p1.age+"  country: "+p1.country);
31.                 System.out.println(p2+"   name: "+p2.name+"  age: "+p2.age+"  country: "+p2.country);
32.                 p1.name="bob";
33.                 p1.country.nation="America";
34.                 System.out.println(p1+"   name: "+p1.name+"  age: "+p1.age+"  country: "+p1.country.nation);
35.                 System.out.println(p2+"   name: "+p2.name+"  age: "+p2.age+"  country: "+p2.country.nation);
36.         }
37. }

复制代码

问题描述： 当Person类中有一个引用类型属性时，对于基本类型数据和String类型是对值进行拷贝的，因此改变p1的name不影响p2的name, 但是对于Country这种引用类型，在clone时仅仅是拷贝了一份对象的引用，拷贝的引用和原来的引用指向的是同一个对象，因此p1改变country的属性时，p2的country的属性也发生了改变

2.4 深拷贝

解决浅拷贝问题的关键点在于不仅仅是拷贝引用，而且要拷贝一份引用指向的对象，深拷贝有两种方式：

逐个对引用指向的对象进行浅拷贝使用序列化方式进行深拷贝

2.4.1 引用类型逐个浅拷贝

如果一个类A中有多个引用类型，那么这些引用类型的类需要实现 Cloneable接口，在对A的对象进行克隆时，逐个浅拷贝其中的引用类型
eg: Person类中有Country引用类型，在进行clone时，单独对country进行浅拷贝

1. package test;
3. class Country implements Cloneable{
4.         String nation;
6.         public Country(String nation) {
7.                 super();
8.                 this.nation = nation;
9.         }
10.         public Country clone() throws CloneNotSupportedException  {
11.                 return (Country) super.clone();
12. }
14. }
15. public class Person implements Cloneable {
16.         int age;
17.         String name;
18.         Country country;
19.         public Person(int age, String name,Country country) {
20.                 this.age = age;
21.                 this.name = name;
22.                 this.country=country;
23.         }
25.         public Person clone() throws CloneNotSupportedException  {
27.                         Person p=null;
28.                         p=(Person) super.clone();
29.                         p.country=p.country.clone();//对country进行浅拷贝
30.                         return p;
31.         }
33.         public static void main(String[] args) throws CloneNotSupportedException {
34.                 Country country=new Country("China");
35.                 Person p1=new Person(18, "tom",country);
36.                 Person p2=p1.clone();
37.                 System.out.println(p1+"   name: "+p1.name+"  age: "+p1.age+"  country: "+p1.country);
38.                 System.out.println(p2+"   name: "+p2.name+"  age: "+p2.age+"  country: "+p2.country);
39.                 p1.name="bob";
40.                 p1.country.nation="America";
41.                 System.out.println(p1+"   name: "+p1.name+"  age: "+p1.age+"  country: "+p1.country.nation);
42.                 System.out.println(p2+"   name: "+p2.name+"  age: "+p2.age+"  country: "+p2.country.nation);
44.         }
45. }

复制代码

2.4.2 序列化方式进行深拷贝

1. package test;
3. import java.io.ByteArrayInputStream;
4. import java.io.ByteArrayOutputStream;
5. import java.io.IOException;
6. import java.io.ObjectInputStream;
7. import java.io.ObjectOutputStream;
8. import java.io.Serializable;
10. class Country implements Serializable{
12.         private static final long serialVersionUID = 1L;
13.         String nation;
15.         public Country(String nation) {
16.                 super();
17.                 this.nation = nation;
18.         }
20. }
22. public class Person implements Cloneable,Serializable {
23.         private static final long serialVersionUID = 1L;
24.         int age;
25.         String name;
26.         Country country;
27.         public Person(int age, String name,Country country) {
28.                 this.age = age;
29.                 this.name = name;
30.                 this.country=country;
31.         }
33.         public Person clone() throws CloneNotSupportedException  {
35.                         Person p=null;
36.                         ObjectInputStream ois=null;
37.                         ObjectOutputStream oos=null;
38.                         ByteArrayInputStream bais=null;
39.                         ByteArrayOutputStream baos=null;
41.                         try {
42.                                 baos=new ByteArrayOutputStream();
43.                                 oos=new ObjectOutputStream(baos);
44.                                 oos.writeObject(this);//Person对象序列化 序列化写入到baos流中
46.                                 bais=new ByteArrayInputStream(baos.toByteArray());
47.                                 ois=new ObjectInputStream(bais);//从baos流中读取数据到ois
48.                                 p=(Person) ois.readObject();//ois读取对象数据
49.                         } catch (Exception e) {
50.                                 e.printStackTrace();
51.                         }finally {
52.                                 if(bais!=null)
53.                                         try {
54.                                                 bais.close();
55.                                         } catch (IOException e) {
56.                                                 e.printStackTrace();
57.                                         }
58.                                 if(baos!=null)
59.                                         try {
60.                                                 baos.close();
61.                                         } catch (IOException e) {
62.                                                 e.printStackTrace();
63.                                         }
64.                                 if(oos!=null)
65.                                         try {
66.                                                 oos.close();
67.                                         } catch (IOException e) {
68.                                                 e.printStackTrace();
69.                                         }
70.                                 if(ois!=null)
71.                                         try {
72.                                                 ois.close();
73.                                         } catch (IOException e) {
74.                                                 e.printStackTrace();
75.                                         }
76.                         }
78.                         return p;
79.         }
81.         public static void main(String[] args) throws CloneNotSupportedException {
82.                 Country country=new Country("China");
83.                 Person p1=new Person(18, "tom",country);
84.                 Person p2=p1.clone();
85.                 System.out.println(p1+"   name: "+p1.name+"  age: "+p1.age+"  country: "+p1.country);
86.                 System.out.println(p2+"   name: "+p2.name+"  age: "+p2.age+"  country: "+p2.country);
87.                 p1.name="bob";
88.                 p1.country.nation="America";
89.                 System.out.println(p1+"   name: "+p1.name+"  age: "+p1.age+"  country: "+p1.country.nation);
90.                 System.out.println(p2+"   name: "+p2.name+"  age: "+p2.age+"  country: "+p2.country.nation);
92.         }
93. }

复制代码

总结： 实现一个可克隆的类的步骤

实现Cloneable接口重写clone方法在重写的clone方法中调用super.clone()方法在重写的clone方法中捕获异常

总结

到此这篇关于Java对象传递与返回细节问题的文章就介绍到这了,更多相关Java对象传递与返回内容请搜索中国红客联盟以前的文章或继续浏览下面的相关文章希望大家以后多多支持中国红客联盟！