首页 > > 程序设计 > Java技术 >

值传递与对象拷贝

2020-02-17 16:04:52来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

值传递与对象拷贝

值传递与对象拷贝

值传递和引用传递

调用一个有参函数的时候，会把实际参数传递给形式参数。但是，在程序语言中，这个传递过程中传递的两种情况，即值传递和引用传递

两者区别

  1. 值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数
  2. 引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数

java中的值传递

  1. java中只存在值传递，不存在引用传递

  2. 对于基本数据类型

    public class ParamTest
{
 public static void main(String[] args) 
    {
       ParamTest pt = new ParamTest();
       int i = 10;
       pt.pass(i);
       System.out.println("print in main , i is " + i);
    }

    public void pass(int j) 
    {
       j = 20;
       System.out.println("print in pass , j is " + j);
    }
}
/*
 输出
 print in pass , j is 20
    print in main , i is 10
*/

    由此可见，对于基本数据类型，是在栈中重新建立一个引用 j，使其值等于传递的参数值 i，改变 j 并不影响 i

  3. 对于引用数据类型

    • 示例一

      public static void main(String[] args) 
{
ParamTest pt = new ParamTest();
   User hello = new User();
hello.setName("Hello");
   hello.setGender("Male");
pt.pass(hello);
   System.out.println("print in main , user is " + hello);
}
public void pass(User user) 
{
   user.setName("HelloChange");
   System.out.println("print in pass , user is " + user);
}
/*
   输出
   print in pass , user is User{name='HelloChange', gender='Male'}
   print in main , user is User{name='HelloChange', gender='Male'}
*/

    • 示例二

      public static void main(String[] args) 
{
   ParamTest pt = new ParamTest();
   User hello = new User();
   hello.setName("Hello");
   hello.setGender("Male");
   pt.pass(hello);
   System.out.println("print in main , user is " + hello);
}
public void pass(User user) 
{
   user = new User();
   user.setName("HelloChange");
   user.setGender("Male");
   System.out.println("print in pass , user is " + user);
}
/*
 输出
 print in pass , user is User{name='HelloChange', gender='Male'}
 print in main , user is User{name='Hello', gender='Male'}
*/

      示例一中，调用 User 类方法改变了内存地址上对象的属性，但这并不是对传入参数本身的改变，实际上传入 hello 之后，在栈中建立 user 引用，且指向地址与 hello 相同，即指向同一对象，对对象的改变并不是对 hello 这个引用的改变，其值一直在栈中指向对象空间地址

      示例二中，传入 hello 之后，在栈中建立 user 引用并于 hello 等值，但通过 new 对象，使 user 引用指向了新的对象，即 user 在栈中的值改变了，而 hello 的值一直指向原对象并不受影响

对象拷贝

含义

有时侯我们需要获得一个新对象，和已经存在的对象完全相同，但又必须相互独立，如果使用简单的赋值方式，实际上指向的还是同一内存地址上的对象，操作一个引用可能会影响另一个，这就需要对象拷贝来获取一个完全相同的新对象

5种方式

  1. setter/getter

    new 新对象后用 set/get 方法设置属性

  2. 浅克隆

    • 被复制的类需要实现Clonenable接口（不实现的话在调用 clone 方法会抛出 CloneNotSupportedException 异常）， 该接口为标记接口(不含任何方法)
    • 覆盖clone( ) 方法，访问修饰符设为 public。方法中调用 super.clone( ) 方法得到需要的复制对象
    class Address
{
    private String address;

    public String getAddress()
    {
        return address;
    }
    public void setAddress(String address)
    {
        this.address = address;
    }
}
class Student implements Cloneable
{
    private int number;

    private Address addr;

    public Address getAddr()
    {
        return addr;
    }

    public void setAddr(Address addr)
    {
        this.addr = addr;
    }

    public int getNumber()
    {
        return number;
    }

    public void setNumber(int number)
    {
        this.number = number;
    }

    @Override
    public Object clone()
    {
        Student stu = null;
        try
        {
            stu = (Student) super.clone();   //浅复制
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
        return stu;
    }
}
public class Test
{

    public static void main(String args[])
    {

        Address addr = new Address();
        addr.setAddress("杭州市");
        Student stu1 = new Student();
        stu1.setNumber(123);
        stu1.setAddr(addr);

        Student stu2 = (Student) stu1.clone();

        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAddress());
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAddress());

        stu2.setNumber(124);
        addr.setAddress("西湖区");

        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAddress());
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAddress());
    }
}

/*
 输出
 学生1:123,地址:杭州市
 学生2:123,地址:杭州市
 学生1:123,地址:西湖区
 学生2:124,地址:西湖区
*/

    通过浅克隆获得新对象，其基本数据类型成员变量得到了复制，修改后不影响原对象

    若变量为引用数据类型，则只复制地址引用，还是指向相同地址，修改时会相互影响

    若变量为 String 类型，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原有字符串对象保持不变

  3. 深克隆

    • 浅复制只是复制了addr 变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象
    • 为了达到真正的复制对象，而不是纯粹引用复制。我们需要将 Address 类可复制化，并且修改 clone 方法，代码如下：
    class Address implements Cloneable
{
    private String address;

    public String getAddress()
    {
        return address;
    }

    public void setAddress(String address)
    {
        this.address = address;
    }

    @Override
    public Object clone()//Address 类可复制化
    {
        Address addr = null;
        try
        {
            addr = (Address) super.clone();
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
        return addr;
    }
}
class Student implements Cloneable
{
    private int number;

    private Address addr;

    public Address getAddr()
    {
        return addr;
    }
    public void setAddr(Address addr)
    {
        this.addr = addr;
    }
    public int getNumber()
    {
        return number;
    }
    public void setNumber(int number)
    {
        this.number = number;
    }
    @Override
    public Object clone()
    {
        Student stu = null;
        try
        {
            stu = (Student) super.clone();   //浅复制
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
        stu.addr = (Address) addr.clone();   //引用数据类型变量深复制
        return stu;
    }
}
public class Test
{

    public static void main(String args[])
    {

        Address addr = new Address();
        addr.setAddress("杭州市");
        Student stu1 = new Student();
        stu1.setNumber(123);
        stu1.setAddr(addr);

        Student stu2 = (Student) stu1.clone();

        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAddress());
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAddress());

        stu2.setNumber(124);
        addr.setAddress("西湖区");

        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAddress());
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAddress());
    }
}
/*
 输出
 学生1:123,地址:杭州市
 学生2:123,地址:杭州市
 学生1:123,地址:西湖区
 学生2:124,地址:杭州市
*/

  4. 工具类

    org.apache.commons 组件 BeanUtils 和 PropertyUtils，静态方法 copyProperties(Object o1,Object o2)

  5. 序列化

    序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作

    class Professor implements Serializable
{
    String name;
    int age;
    Professor(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
}
class Student implements Serializable
{
    String name;//常量对象
    int age;
    Professor p;//引用数据类型
    Student(String name, int age, Professor p)
    {
        this.name = name;
        this.age = age;
        this.p = p;
    }
    //深克隆
    public Object deepClone() throws IOException, ClassNotFoundException
    {
        //将对象写到流里
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);
        //从流里读出来
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return (oi.readObject());
    }
}
public class Test
{
    public static void main(String[] args) throws IOException, ClassNotFoundException
    {
        Professor p = new Professor("wangwu", 50);
        Student s1 = new Student("zhangsan", 18, p);
        Student s2 = (Student) s1.deepClone();
        s2.p.name = "lisi";
        s2.p.age = 30;
        System.out.println("name=" + s1.p.name + "," + "age=" + s1.p.age); 
        //学生1的教授不改变
    }
}

原文链接:https://www.cnblogs.com/pgjett/p/12323336.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：SpringBoot整合WEB开发--（五）自定义错误页

下一篇：idea 配置 tomcat 教程

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签