引用传递经典例子，内存分析

最新推荐文章于 2021-06-19 16:02:46 发布

费城之鹰

最新推荐文章于 2021-06-19 16:02:46 发布

阅读量608

点赞数 1

分类专栏： java问题文章标签：内存引用传递

本文链接：https://blog.csdn.net/jakezhang1990/article/details/58100162

版权

java问题专栏收录该内容

41 篇文章 0 订阅

订阅专栏

对于引用传递，有几个非常经典的例子，一个老师曾经做过分成详细的内存分析，这里总结下，拿出来，每当忘记或者不清楚的时候，一看就能明白了。,
1，

class Demo{
    int temp = 30 ;     // 此处为了方便，属性暂时不封装
};
public class RefDemo01{
    public static void main(String args[]){
        Demo d1 = new Demo() ;  // 实例化Demo对象，实例化之后里面的temp=30 
        d1.temp = 50 ;      // 修改temp属性的内容
        System.out.println("fun()方法调用之前：" + d1.temp) ;
        fun(d1) ;
        System.out.println("fun()方法调用之后：" + d1.temp) ;
    }
    public static void fun(Demo d2){        // 此处的方法由主方法直接调用
        d2.temp = 1000;                     // 修改temp值
    }
};

内存分析：
这里写图片描述

2，
Demo作为一个类，可以实现修改，那么String也是一个类，只是是一个特殊的类，使用String是不是也是一样的呢？

public class RefDemo02{
    public static void main(String args[]){
        String str1 = "hello" ;         // 实例化字符串对象
        System.out.println("fun()方法调用之前：" + str1) ;
        fun(str1) ;                     // 调用fun()方法
        System.out.println("fun()方法调用之后：" + str1) ;
    }
    public static void fun(String str2){        // 此处的方法由主方法直接调用
        str2 = "MLDN" ;                 // 修改字符串内容
    }
};

结果发现调用方法，结果比没有被修改。
内存分析：
这里写图片描述

3，
那如果，就是想通过方法，传参数，修改一个String呢？难道不能实现？肯定可以实现

class Demo{
    String temp = "hello" ;     // 此处为了方便，属性暂时不封装
};
public class RefDemo03{
    public static void main(String args[]){
        Demo d1 = new Demo() ;  // 实例化Demo对象，实例化之后里面的temp=30 
        d1.temp = "world" ;     // 修改temp属性的内容
        System.out.println("fun()方法调用之前：" + d1.temp) ;
        fun(d1) ;
        System.out.println("fun()方法调用之后：" + d1.temp) ;
    }
    public static void fun(Demo d2){        // 此处的方法由主方法直接调用
        d2.temp = "MLDN";                       // 修改temp值
    }
};

内存分析：
这里写图片描述

以上就实现了，修改String了，对于String是作为一个类的一个属性进行操作的，他在内存中的开辟方式和直接String作为一个类去开辟内存是不同的。

4，
传递本类对象，在一个类中，有一个方法，这个方法的参数就是这个类自己的对象，（这样的方式，其实没什么用，违反了封装的特性，封装的目的就是为了内部的属性不能直接被对象所访问，但是，传递内部对象的方式，似乎没有什么意义。。。。）

class Demo{                     // 定义Demo类
    private int temp  = 30 ;    // 声明temp属性并封装
    public void fun(Demo d2){   // 接收本类的引用
        d2.temp = 50 ;          // 直接通过对象调用本类的私有属性
    }
    public int getTemp(){       // getter
        return temp ;
    }
    public void setTemp(int t){ // setter
        temp = t ;
    }
};
public class RefDemo04{
    public static void main(String args[]){
        Demo d1 = new Demo() ;  // 实例化Demo对象
        d1.setTemp(50) ;        // 只能通过setter方法修改内容
        d1.fun(d1) ;            // 此处把Demo的对象传回到自己的类中
        System.out.println("temp = " + d1.getTemp()) ;
    }
};

但是这段代码，灵活的提现了引用传递。

还有两个例子，可以更加深入的体会引用传递：
5，
一个人有一本书，一本书属于一个人，这种所属关系，可以从人的对象开始找到书的所有信息，也可以通过一个人所归属的这本书的对象，找到人的所有信息：

class Person{           // 定义Person类
    private String name ;   // 姓名
    private int age ;       // 年龄
    private Book book ;     // 一个人有一本书
    public Person(String name,int age){
        this.setName(name) ;
        this.setAge(age) ;
    }
    public void setName(String n){
        name = n ;
    }
    public void setAge(int a){
        age = a ;
    }
    public String getName(){
        return name ;
    }
    public int getAge(){
        return age ;
    }
    public void setBook(Book b){
        book = b ;
    }
    public Book getBook(){
        return book ;
    }
};
class Book{             // 定义Book类
    private String title ;  // 标题
    private float price ;   // 价格
    private Person person ; // 一本书属于一个人
    public Book(String title,float price){
        this.setTitle(title) ;
        this.setPrice(price) ;
    }
    public void setTitle(String t){
        title = t ;
    }
    public void setPrice(float p){
        price = p ;
    }
    public String getTitle(){
        return title ;
    }
    public float getPrice(){
        return price ;
    }
    public void setPerson(Person p){
        person = p ;
    }
    public Person getPerson(){
        return person ;
    }
};
public class RefDemo05{
    public static void main(String arg[]){
        Person per = new Person("张三",30) ;
        Book bk = new Book("JAVA SE核心开发",90.0f) ;
        per.setBook(bk) ;       // 设置两个对象间的关系，一个人有一本书
        bk.setPerson(per) ;     // 设置两个对象间的关系，一本书属于一个人
        System.out.println("从人找到书 --> 姓名：" + per.getName()+"；年龄：" 
            + per.getAge() +"；书名：" + per.getBook().getTitle() + "；价格：" 
            + per.getBook().getPrice()) ;   // 可以通过人找到书
        System.out.println("从书找到人 --> 书名：" + bk.getTitle() + "；价格："
            + bk.getPrice() + "；姓名：" + bk.getPerson().getName() + "；年龄："
            + bk.getPerson().getAge()) ;    // 也可以通过书找到其所有人
    }
};

6，进一步，一个人有一本书，一本书属于一个人，一个人有一个孩子，一个孩子有一本书，使用应用传递，通过人找到孩子信息，找到孩子的书的信息，通过孩子的书找到人，找到人的信息：

class Person{           // 定义Person类
    private String name ;   // 姓名
    private int age ;       // 年龄
    private Book book ;     // 一个人有一本书
    private Person child ;  // 一个人有一个孩子
    public Person(String name,int age){
        this.setName(name) ;
        this.setAge(age) ;
    }
    public void setName(String n){
        name = n ;
    }
    public void setAge(int a){
        age = a ;
    }
    public String getName(){
        return name ;
    }
    public int getAge(){
        return age ;
    }
    public void setBook(Book b){
        book = b ;
    }
    public Book getBook(){
        return book ;
    }
    public void setChild(Person c){
        child = c ;
    }
    public Person getChild(){
        return child ;
    }
};
class Book{             // 定义Book类
    private String title ;  // 标题
    private float price ;   // 价格
    private Person person ; // 一本书属于一个人
    public Book(String title,float price){
        this.setTitle(title) ;
        this.setPrice(price) ;
    }
    public void setTitle(String t){
        title = t ;
    }
    public void setPrice(float p){
        price = p ;
    }
    public String getTitle(){
        return title ;
    }
    public float getPrice(){
        return price ;
    }
    public void setPerson(Person p){
        person = p ;
    }
    public Person getPerson(){
        return person ;
    }
};
public class RefDemo06{
    public static void main(String arg[]){
        Person per = new Person("张三",30) ;
        Person cld = new Person("张草",10) ;  // 定义一个孩子
        Book bk = new Book("JAVA SE核心开发",90.0f) ;
        Book b = new Book("一千零一夜",30.3f) ;
        per.setBook(bk) ;       // 设置两个对象间的关系，一个人有一本书
        bk.setPerson(per) ;     // 设置两个对象间的关系，一本书属于一个人
        cld.setBook(b) ;        // 设置对象间的关系，一个孩子有一本书
        b.setPerson(cld) ;      // 设置对象间的关系，一本书属于一个孩子
        per.setChild(cld) ;     // 设置对象间的关系，一个人有一个孩子
        System.out.println("从人找到书 --> 姓名：" + per.getName()+"；年龄：" 
            + per.getAge() +"；书名：" + per.getBook().getTitle() + "；价格：" 
            + per.getBook().getPrice()) ;   // 可以通过人找到书
        System.out.println("从书找到人 --> 书名：" + bk.getTitle() + "；价格："
            + bk.getPrice() + "；姓名：" + bk.getPerson().getName() + "；年龄："
            + bk.getPerson().getAge()) ;    // 也可以通过书找到其所有人
        // 通过人找到孩子，并找到孩子所拥有的书
        System.out.println(per.getName() + "的孩子 --> 姓名："
            + per.getChild().getName() + "；年龄：" + per.getChild().getAge()
            + "；书名：" + per.getChild().getBook().getTitle() + "；价格："
            + per.getChild().getBook().getPrice()) ;
    }
};

这几代代码，引用传递得到了非常好的提现。
以上代码和图片，来自他人，这里拿来总结学习，尊重知识产权。

费城之鹰

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
引用传递经典例子，内存分析

对于引用传递，有几个非常经典的例子，一个老师曾经做过分成详细的内存分析，这里总结下，拿出来，每当忘记或者不清楚的时候，一看就能明白了。, 1，class Demo{ int temp = 30 ; // 此处为了方便，属性暂时不封装};public class RefDemo01{ public static void main(String args[]){
复制链接

扫一扫

专栏目录