黑马程序员技术交流社区

标题: 一个程序的疑问 [打印本页]

作者: 记得上线    时间: 2012-7-13 04:55
标题: 一个程序的疑问
本帖最后由 记得上线 于 2012-7-18 07:44 编辑

/*
使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈:先进后出  如同一个杯子。
队列:先进先出 First in First out  FIFO 如同一个水管。



*/

import java.util.*;
class DuiLie
{
        private LinkedList link;//从这里看出link是一个变量

        DuiLie()
        {
                link = new LinkedList();//从等号的右边看link是一个对象,但左边去没用类来修饰他,
        }
        
        public void myAdd(Object obj)
        {
                link.addFirst(obj);
        }
        public Object myGet()
        {
                return link.removeFirst();
        }
        public boolean isNull()
        {
                return link.isEmpty();
        }

}



class  LinkedListTest
{
        public static void main(String[] args)
        {
                DuiLie dl = new DuiLie();
                dl.myAdd("java01");
                dl.myAdd("java02");
                dl.myAdd("java03");
                dl.myAdd("java04");

                while(!dl.isNull())
                {
                        System.out.println(dl.myGet());
                }
        }
}
//我的问题是哪个link是变量还是对象。
作者: 李思静    时间: 2012-7-13 07:08
楼主你定义了一个全部变量link,link在栈内存中,然后用这个link指向了LinkedList生成的一个对象,这个对象在堆内存中。由于楼主的最后一句话问的不是很好,我猜楼主的意思是link=new LinkedList();这儿为什么不是  List link=new LinkedList(); 这样在java中是不行的,在C++中是可以的。如果去掉刚开始的link变量的声明,也是不可以的,因为这样生成的变量是局部的变量。所谓的变量我的理解就是一个容器,这个容器可以存储特定的数据类型。变量又分为引用类型和值类型。上面的就是引用类型。变量存储一个指向堆内存对象的指针。
作者: 陆强强    时间: 2012-7-13 07:20
private int i;//这里的i没有具体值
        DuiLie()
        {
                i = 3;//这里给I赋值,同样link是给它实例化一个对象。
        }
我把linkList改成int楼主应该看的很清楚了。
同样的情况还有
FileReader fr=null;
public void copy(File f){
   fr=new FileReader(file);
//下面的代码我省略了
}


作者: 程潇    时间: 2012-7-13 07:40
private LinkedList link;//这里的link是DuiLie类的成员变量,是变量

link = new LinkedList();//这句话存在于构造函数中,是为link做初始化,这里的link依然是成员变量,只是为它创建了一个LinkedList对象,并把对象的引用赋给了它,还是变量
作者: 李志群    时间: 2012-7-13 10:20
楼主 你的程序link是变量啊
new一个对象的格式 例子: a1 a= new a1();对象    的
成员变量和局部变量的区别?
               
                1,定义的位置不同,
                                成员变量定义在类中,作用于整个类
                                局部变量定义函数中,作用于整个函数,或者定义在语句中,作用于语句内
                                名称不一样。
                                2,他们在内存中出现的时间和位置也不一样。
                                成员变量:当对象创建时,出现在堆内存的对象当中。
                                局部变量:所属区间被运算时,出现在栈内存中。
                                3,生命周期不同。
                                成员变量:随着对象的出现而出现,随着对象的消失而消失。
                                局部变量:随着所属区间运算结束,立刻被释放
                               
                                4,初始化值
                                成员变量:因为在堆内存中,都有默认初始化值。
                                局部变量:没有初始化值。
                                凡不是局部变量的都是成员变量。

java的内存划分:
                1,寄存器。cpu涉及的区域。
                2,本地方法区,是和系统相关的代码存储区域。(与系统相关的东西)
                3,栈内存:存储的都是局部变量,变量运算区域一结束,就释放。
                        局部变量:在方法上的参数,方法内的变量,语句中的变量。

                4,堆内存:
                        存储的是数组和对象,简单说,对内存中存储的都是实体,实体:能存很多东西的地方。
                        实体就是可以存储多个数据的地方,记住,只要是用new建立都存储在堆内存中,
                       
                5,方法区:存储函数(共享数据)的地方。       
new第一件事情就是内存中开辟一片空间,首地址值是一段2进制的值

堆的特点:1,任何实体都有内存地址值,
       
        2,堆内存中的变量都有默认初始化值
        3,引用数据类型(垃圾回收机制),int[] arr = new [3]  arr引用0角标的地址值。
                        arr[0]=89;//89是赋值的不是引用了。
                        arr=null//好处,可以让引用数据类型指向取消。不在有任何指向。
                        没有任何指向的数组,在内存总称为垃圾,堆里面的释放方式特殊(垃圾回收机制),
                        靠垃圾回收器在不定时的时间内,将对内存中的垃圾清楚来释放空间。
                        垃圾回收机制是java特有的机制。这个机制 自动在堆内存中清理。和C++是有区别的。






        1,任何实体都有内存地址值,
       
        2,堆内存中的变量都有默认初始化值
        3,引用数据类型(垃圾回收机制),int[] arr = new [3]  arr引用0角标的地址值。
                        arr[0]=89;//89是赋值的不是引用了。
                        arr=null//好处,可以让引用数据类型指向取消。不在有任何指向。
                        没有任何指向的数组,在内存总称为垃圾,堆里面的释放方式特殊(垃圾回收机制),
                        靠垃圾回收器在不定时的时间内,将对内存中的垃圾清楚来释放空间。
                        垃圾回收机制是java特有的机制。这个机制 自动在堆内存中清理。和C++是有区别的。

作者: 李志群    时间: 2012-7-13 10:21
希望采纳 {:soso_e100:}
作者: 黑马刘涛    时间: 2012-7-13 13:39
本帖最后由 黑马刘涛 于 2012-7-13 13:43 编辑
  1. import java.util.*;
  2. class DuiLie
  3. {
  4.         private LinkedList link;//类私有成员变量

  5.         DuiLie()
  6.         {
  7.                 link = new LinkedList();//new一个对象,link是对象的引用,其实就是this.link = new LiinkList();很明显就是LinkedList类型变量。
  8.        }
  9.         
  10.         public void myAdd(Object obj)
  11.         {
  12.                 link.addFirst(obj);
  13.         }
  14.         public Object myGet()
  15.         {
  16.                 return link.removeFirst();
  17.         }
  18.         public boolean isNull()
  19.         {
  20.                 return link.isEmpty();
  21.         }

  22. }



  23. class  LinkedListTest
  24. {
  25.         public static void main(String[] args)
  26.         {
  27.                 DuiLie dl = new DuiLie();
  28.                 dl.myAdd("java01");
  29.                 dl.myAdd("java02");
  30.                 dl.myAdd("java03");
  31.                 dl.myAdd("java04");

  32.                 while(!dl.isNull())
  33.                 {
  34.                         System.out.println(dl.myGet());
  35.                 }
  36.         }
  37. }
复制代码
你说的没用类修饰我想你是误解了,类的成员方法要访问成员变量可以直接用this.成员变量,有些情况this可以省略,比如当前情况;而你说的类修饰我想你可能是说的静态方法的调用 。比如Collections.valueOf()




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2