/*
使用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是变量还是对象。

1. import java.util.*;
   
2. class DuiLie
   
3. {
   
4.         private LinkedList link;//类私有成员变量
   
5. 
   
6.         DuiLie()
   
7.         {
   
8.                 link = new LinkedList();//new一个对象，link是对象的引用，其实就是this.link = new LiinkList();很明显就是LinkedList类型变量。
   
9.        }
   
10.         
    
11.         public void myAdd(Object obj)
    
12.         {
    
13.                 link.addFirst(obj);
    
14.         }
    
15.         public Object myGet()
    
16.         {
    
17.                 return link.removeFirst();
    
18.         }
    
19.         public boolean isNull()
    
20.         {
    
21.                 return link.isEmpty();
    
22.         }
    
23. 
    
24. }
    
25. 
    
26. 
    
27. 
    
28. class  LinkedListTest
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32.                 DuiLie dl = new DuiLie();
    
33.                 dl.myAdd("java01");
    
34.                 dl.myAdd("java02");
    
35.                 dl.myAdd("java03");
    
36.                 dl.myAdd("java04");
    
37. 
    
38.                 while(!dl.isNull())
    
39.                 {
    
40.                         System.out.println(dl.myGet());
    
41.                 }
    
42.         }
    
43. }
    

复制代码

你说的没用类修饰我想你是误解了，类的成员方法要访问成员变量可以直接用this.成员变量，有些情况this可以省略，比如当前情况；而你说的类修饰我想你可能是说的静态方法的调用 。比如Collections.valueOf()

希望采纳 {:soso_e100:}

楼主 你的程序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++是有区别的。

private LinkedList link;//这里的link是DuiLie类的成员变量，是变量

link = new LinkedList();//这句话存在于构造函数中，是为link做初始化，这里的link依然是成员变量，只是为它创建了一个LinkedList对象，并把对象的引用赋给了它，还是变量

private int i;//这里的i没有具体值
        DuiLie()
        {
                i = 3;//这里给I赋值，同样link是给它实例化一个对象。
        }
我把linkList改成int楼主应该看的很清楚了。
同样的情况还有
FileReader fr=null;
public void copy(File f){
   fr=new FileReader(file);
//下面的代码我省略了
}

楼主你定义了一个全部变量link，link在栈内存中，然后用这个link指向了LinkedList生成的一个对象，这个对象在堆内存中。由于楼主的最后一句话问的不是很好，我猜楼主的意思是link=new LinkedList();这儿为什么不是  List link=new LinkedList(); 这样在java中是不行的，在C++中是可以的。如果去掉刚开始的link变量的声明，也是不可以的，因为这样生成的变量是局部的变量。所谓的变量我的理解就是一个容器，这个容器可以存储特定的数据类型。变量又分为引用类型和值类型。上面的就是引用类型。变量存储一个指向堆内存对象的指针。