在学习java的时候，一般都说java没有指针，说是和c语言的区别。的确，java是对java的极大改进（这也是我学习java的原因之一，简单啊！）。那么，Java有没有指针呢？说没有，是正确的；说有，也是正确的。为什么这么说呢？当然是有原因的。请听我细细道来：

一、概述：

在java中说“指针”，实际上就是说的引用。

1、指针简单化：

       其实，java中并不是没有指针，而且指针到处都是，其实，java中对指针进行了伪装：使用上泛化、强化和简单化，概念上淡化和弱化。

举个例子来说：有个Person类，我们来创建个对象：Person x = new Person();。这里就含有一个变量x，没错，这个引用型变量，实质上就是指针。

2、区别：

        在c++中是这么创建对象指针类型的：Person *x = new Person();，x就是个指针变量；而在java中是没有这个“ *” 的，从一定意义上说，java舍弃了指针，就不会对变量本身修改了（修改的是对象的值），所以也就是随之舍弃了这个“ * ”。因此所有这些引用型变量，其实都是在使用指针，你不用这个引用型变量（指针）都不行，这就是对指针泛化和强化了。在java中不叫指针了，那么就是在概念上的淡化和弱化了。我看过一种说法，就是说创建了对象变量，称为对象指针变量，就是这个意思。其实在java中一切对引用的操作，实质上是对数据的操作，是修改的地址、内存数据等等。

java舍弃了指针的运算操作，就是对指针的一种简单化。

二、java中指针的应用：

可能这么说，有些牵强，但是确实可以看到指针的影子。所以只是想不到好的标题罢了。可以自己感悟一下，在java中最常见的操作：赋值；以及java的类中最熟悉的关系：继承。都可以看到指针的影子。下面我说说我的浅显理解，不一定是正确的，希望大家多多指正批评，在此谢过。

我先强调一下关于“指针变量”的几点：

第一：指针变量是在栈内存中，它也是有值的，这个值存储的就是地址单元，这个地址就是来自于赋值操作。

第二：指针变量有类型，这个类型（如Person）的含义是指针指向的变量在栈内存（不是很确定）中的范围（大小），我理解为是占用的堆内存空间。

第三：声明一个对象时，是对“指针变量”的定义。

第四：用new关键字在堆内存创建了对象，在赋值时，是把这个对象的首地址传给了这个“指针变量”（即引用型变量）。

一）、值传递和引用传递

先看下面一段代码：

1. class A
   
2. {
   
3.         String str;
   
4. }
   
5. class B
   
6. {
   
7.         static void change(int x,A a)
   
8.         {
   
9.                 x = 20;
   
10.                 a.str = "h";
    
11.         }
    
12.         public static void main(String [] args)
    
13.         {
    
14.                 A n = new A();
    
15.                 n.str = "q";
    
16.                 int x = 10;
    
17.                 System.out.println("对象的引用改变前：" + n.str + " ,int型引用改变前" + x);
    
18.                 change(x,n);
    
19.                 System.out.println("对象的引用改变后：" + n.str + " ,int型引用改变后" + x);
    
20.         }
    
21. }

复制代码

打印的结果为：

对象的引用改变前：q ,int型引用改变前：10
对象的引用改变后：h ,int型引用改变前：10

为什么会出现这种结果呢？由于Java对对象和基本的数据类型的处理是不一样的。和C语言一样，当把Java的基本数据类型（如int，char，double等）作为入口参数传给函数体的时候，传入的参数在函数体内部变成了局部变量，这个局部变量是输入参数的一个拷贝，所有的函数体内部的操作都是针对这个拷贝的操作，函数执行结束后，这个局部变量也就完成了它的使命，它影响不到作为输入参数的变量。这种方式的参数传递被称为"值传递"。而在Java中用对象的作为入口参数的传递则缺省为"引用传递"，也就是说仅仅传递了对象的一个"引用"，这个"引用"的概念同C语言中的指针引用是一样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操作。图示如下：

可以看出，在栈内存中的操作结束后，x的值是不会改变的；而对对内存中进行的操作，就会改变，因为地址没变，所以引用是随着地址的改变而改变的，而不是随着值的改变而改变。

但是，比较特殊的一种情况是java池，这是java中为了优化数据而开辟的一块内存，是共享基本类型和字符串等数据的。如Integer等包装类和String类。

具体请看关于字符串String的总结：http://blog.csdn.net/shengfeixiang/article/details/8577842

二）、父类和子类

先看下面一段代码：

1. class Father
   
2. {
   
3. void driveBcl()
   
4. {
   
5. System.out.println("骑自行车");
   
6. }
   
7. }
   
8. 
   
9. class Son extends Father
   
10. {
    
11. void driveCar()
    
12. {
    
13. System.out.println("开车");
    
14. }
    
15. void QQ()
    
16. {
    
17. System.out.println("聊QQ");
    
18. }
    
19. }
    
20. 
    
21. class DeZhi
    
22. {
    
23. public static void main(String [] args)
    
24. {
    
25. Son s = new Son();
    
26. s.driveBcl();
    
27. s.driveCar();
    
28. s.QQ();
    
29. }
    
30. }

复制代码

打印结果为：

骑自行车
开车
聊QQ

图示如下：

也就是说Son的引用指向了父类的方法。从而获得了父类的功能。

到此为止，关于指针的相关内容，说的差不多了，当然，我只是简单的从两方面说明了一下关于指针的问题，可能说的不太正确。

不过，无论怎么样，只需要理解java中引用就可以了，在这里说指针，一方面，比较感兴趣，一方面是和c语言对比一下，还有一方面，就是深刻理解java中的引用。

最后强调一下，不管指针是什么，只要记住这几点就行了：

1、对于创建对象的语句：Person x = new Person();，x是引用型变量，是一个变量，new是在堆内存开辟了一个块空间，里面存放的数据是Person封装的内容（如姓名，年龄等等），这块空间有一个地址（是用十六进制表示的），=作为赋值操作，是将这个地址传给这个变量，因此这个变量就有一个值，即地址。那么这个变量就指向了这块空间，就可以引用里面的数据。

2、局部变量在栈内存中操作完后，就随之消亡了；而对全局变量或者对象的操作，修改后，当前变量的指向的地址值没变，但是里面的数据改变了，所以，可以认为变量改变了（实际，变量还是这个变量）。

如有补充，以后继续······

标记标记