简述JAVA对象的产生与使用

类别:Java 点击:0 评论:0 推荐:

我们都知道创建新对象需要使用 new 关键字和想要创建对象的类名,如:
      Person  p1 = new  Person();  // “=”左边以类名Person作为变量类型定义了一个变量p1,来指向“=”右边通过new关键字创建的一个Person类的实例对象,变量p1就是对象的引用句柄,对象的引用句柄是在栈中分配的一个变量,对象本身是在堆中分配的;在new语句的类名后一定要跟着一对括号(),该语句执行完成后的内存状态如图1。
                                 栈内存                                   堆内存
                  某    |--- |_______|                              |________|
                  个    |     |_______|              -> 0x3000|____0___|age   //“0”是new Person()产生的对象      
                  函__|     |_______|        -                     |    .  .......  |      
                  数    |     |_______|   -                          |    .  ........ |      
                  的    | P1|0x3000  |-                             |    . .......   |      
                  栈    |--- |              |                              |                |
                  空
                  间                 图 1

 

       变量在被初始化之前是不能使用的,在一个方法内部的变量必须进行初始化赋值,否则编译无法通过。当一个对象被创建时,会对其中各种类型的成员变量按表1自动进行初始化赋值,除了基本数据类型之外的变量类型都是引用类型,如上面的Person和前面讲数组。

表 1
         成员变量类型                                     初 始 值
--------------------------------------------------------------------------------------
         byte                                                   0
         short                                                  0
         int                                                      0
         long                                                    0L      
         float                                                   0.0F
         double                                               0.0D
         Char                                                  ' \u0000 '(表示为空)
         boolean                                              False
         ALL reference type                           Null
---------------------------------------------------------------------------------------
       由此我们所能够看到对象内存状态图中的age成员变量的初始值为0。

       创建新的对象之后,就可以使用“对象名.对象成员”的格式,来访问对象的成员(包括属性和方法),下面演示了Person类对象的产生和使用方式:
   class Person
     {
        int age;
        void shout()
         {
            System.out.println(age);
         }
      }
   class TestPerson
     {
            public static void main(String [] args)
            {
                  Person p1 = new Person();
                  Person p2 = new Person();
                  p1.age = -30;
                  p1.shout();
                  p2.shout();
              }
      }
程序运行结果:
                                        -30
                                         0
分析:  在TestPerson.main方法中创建了两个Person类的对象,并定义了Person类的对象引用句柄p1、p2,分别指向这两个对象。接着,程序调用了p1和p2的方法和属性,p1、p2是两个完全独立的对象,类中定义的成员变量,在每个对象都被单独实例化,不会被所有的对象共享,改变了p1的age属性,不会影响p2的age属性。调用某个对象的方法时,该方法内部所访问的成员变量,是这个对象自身的成员变量,上面程序运行的内存布局如图2。

                                           栈内存                                               堆内存

                                  |        .        ................     |                           |________|
                                  |        .                             |              ----->    |__-30 ___|age //p1标识的对象  
                                  |___________________|       -                 
               p1.shout(){|_其中对age 的访问 __|----                     
               p2.shout(){|_其中对age 的访问 __|---- 
                                  |                                      |       -                
                                  |                                      |          -               |________|      
                                                                                        ----->   |___0____|age  //p2标识的对象


                                                  图 2


        每个创建的对象都是有自己的生命周期的,对象只能在其有效的生命周期内被使用,当没有引用变量指向某个对象时,这个对象就会变成垃圾,不能再被使用。以下是具体的垃圾代码和分析:
      
        1、 第一种情况:
            {                                           -----|
            Person  p1 = new Person();       |——> Person对象被引用;离开作用域p1失效,Person对象成为垃圾。
                               ........                        |
            }                                          -----|

        2、第二种情况:
            {                       
            Person p1 = new Person(); ---->|  p1  | ----->    Person对象
            p1 = null;                            ---->|  p1  |—>null  Person对象成为垃圾
            .........                                                        
            }
         分析:在执行完p1=null;后,即使句柄p1还没有超出其作用域,仍然有效,但它已经被赋值为空,p1不再指向任何对象,这个
               Person对象成了孤儿,不再被任何句柄引用,变成了垃圾。

        3、第三种情况:
           {
           Person p1 = new Person();--->  p1 ----> Person对象
           ...........                               |----> p1 -----> Person对象
           Person p2 = p1;          --->|----> p2 -----> Person对象
           ...........
           p1 = null;               --->  p1 ----> null
           ...........                    --->  p2 ----> Person对象
           }
          分析:执行完p1=null;后,产生的Person对象不会变成垃圾,因为这个对象仍然被p2所引用,直到p2超出其作用域而无效,产生
                的Person对象才会变成垃圾。

本文地址:http://com.8s8s.com/it/it12013.htm