对象引用和指针

当调用代码
Person p=new Person();这行代码实际上产生了两个东西:一个是p变量(引用变量);一个是Person对象.这行代码的含义是:创建Person实例,并把这个Person实例赋值给一个引用变量p.
当我们创建了一个Person对象时,系统会自动为这个Person对象开辟一块堆内存用来存储这个Person对象,

Person对象的存储示意图

程序中定义的Person类型的变量Person p实际上是一个引用,它被存放在栈内存里,指向实际的Person对象;而真正的Person对象则存放在堆内存中.

下图显示了将Person对象赋给一个引用变量的示意图

引用变量指向实际对象示意图

堆内存中的对象可以有多个引用,即多个引用变量指向同一个对象.

方法的参数传递机制

java中方法的参数传递的方式只有一种:值传递.所谓值传递:就是将实际参数的副本(复制品)传入方法内,而参数的本身不会受到任何的影响.

基本类型的参数传递

public class PrimitiveTransferTest
{
    public static void swap(int a , int b)
    {
        // 下面三行代码实现a、b变量的值交换。
        // 定义一个临时变量来保存a变量的值
        int tmp = a;
        // 把b的值赋给a
        a = b;
        // 把临时变量tmp的值赋给a
        b = tmp;
        System.out.println("swap方法里，a的值是"
            + a + "；b的值是" + b);
    }
    public static void main(String[] args)
    {
        int a = 6;
        int b = 9;
        swap(a , b);
        System.out.println("交换结束后，变量a的值是"
            + a + "；变量b的值是" + b);
    }
}

结果如下:

swap方法里，a的值是9；b的值是6
交换结束后，变量a的值是6；变量b的值是9

swap()方法里的a和b只是main()方法里变量a和b的复制品.java程序总是先从main()方法开始执行,main()方法里开始定义了a,b两个局部变量,两个变量在内存中的存储示意图如下所示

main()方法中定义的a,b变量存储示意图

main()方法中变量作为参数传入swap()方法存储示意图

image.png

引用类型的参数传递

Java对引用类型的参数传递一样采取值传递的方式

class DataWrap
{
    int a;
    int b;
}
public class ReferenceTransferTest
{
    public static void swap(DataWrap dw)
    {
        // 下面三行代码实现dw的a、b两个成员变量的值交换。
        // 定义一个临时变量来保存dw对象的a成员变量的值
        int tmp = dw.a;
        // 把dw对象的b成员变量值赋给a成员变量
        dw.a = dw.b;
        // 把临时变量tmp的值赋给dw对象的b成员变量
        dw.b = tmp;
        System.out.println("swap方法里，a成员变量的值是"
            + dw.a + "；b成员变量的值是" + dw.b);
        // 把dw直接赋为null，让它不再指向任何有效地址。
        dw = null;
    }
    public static void main(String[] args)
    {
        DataWrap dw = new DataWrap();
        dw.a = 6;
        dw.b = 9;
        swap(dw);
        System.out.println("交换结束后，a成员变量的值是"
            + dw.a + "；b成员变量的值是" + dw.b);
    }
}

结果如下:

swap方法里，a成员变量的值是9；b成员变量的值是6
交换结束后，a成员变量的值是9；b成员变量的值是6

很容易引起一个幻觉:调用swap()方法时,传入的是dw对象的本身而不是它的复制品,但这只是一种幻觉.
首先程序从main()方法开始执行,main()方法中开始创建了一个DataWrap对象,并定义了一个dw引用变量指向DataWrap对象.创建一个对象时,系统内存中有两个东西:一个是堆内存中存储了对象本身,栈内存中保存了引用该对象的引用变量.接下来程序通过引用来操作DataWrap对象,把该对象的a,b两个成员变量分别赋值为6和9.此时的存储示意图如下:

image.png

image.png

成员变量的初始化和内存中的运行机制

class Person
{
    // 定义一个实例变量
    public String name;
    // 定义一个类变量
    public static int eyeNum;
}
public class PersonTest
{
    public static void main(String[] args)
    {
        // 第一次主动使用Person类，该类自动初始化，则eyeNum变量开始起作用，输出0
        System.out.println("Person的eyeNum类变量值:"
            + Person.eyeNum);
        // 创建Person对象
        Person p = new Person();
        // 通过Person对象的引用p来访问Person对象name实例变量
        // 并通过实例访问eyeNum类变量
        System.out.println("p变量的name变量值是：" + p.name
            + " p对象的eyeNum变量值是：" + p.eyeNum);
        // 直接为name实例变量赋值
        p.name = "孙悟空";
        // 通过p访问eyeNum类变量，依然是访问Person的eyeNum类变量
        p.eyeNum = 2;
        // 再次通过Person对象来访问name实例变量和eyeNum类变量
        System.out.println("p变量的name变量值是：" + p.name
            + " p对象的eyeNum变量值是：" + p.eyeNum);
        // 前面通过p修改了Person的eyeNum，此处的Person.eyeNum将输出2
        System.out.println("Person的eyeNum类变量值:" + Person.eyeNum);
        Person p2 = new Person();
        // p2访问的eyeNum类变量依然引用Person类的，因此依然输出2
        System.out.println("p2对象的eyeNum类变量值:" + p2.eyeNum);
    }
}

//创建第一个Person对象
Person p1=new Person();
//创建第二个Person对象
Person p2=new Person();
//分别为两个Person对象的name实例变量赋值
p1.name="张三";
p2.name="孙悟空";
//分别为两个Person对象的eyeNum类变量赋值
p1.eyeNum=2;
p2.eyeNum=3;

当程序执行第一行代码Person p1=new Person();时,如果这行代码是第一次使用Person类,则系统通常会在第一次使用Person类时加载这个类,并初始化这个类.在该类的准备阶段,系统会为该类的类变量分配内存空间,并指定默认初始值.当Person类初始化完成后,系统内存中的存储示意图如下所示:

image.png

image.png

image.png

image.png

注意:当程序需要访问类变量时,尽量使用类作为主调,而不要使用对象作为主调,这样可以避免程序产生歧义,提高程序的可读性.