java引用与指针的区别

‘壹’ java没有指针更安全,谁能举个简单的例子啊。 1，c有指针，java用引用实现了2，java没指针，c用指针出错了

java事实上是封装了指针（即用引用实现了指针），不知道你对java了解程度如何，所以就打个比方来说明两者的关系和区别。家里有遥控器吧，假设你家电视能够收到1-40个频道，你想看25频道的话，直接按数字键2、5就能转入到该频道，但是有一个问题，如果你输入了4、1怎么办，电视上分明没有41频道！（这就出现了指针不安全的问题！）为了避免这个问题，又能实现换台功能，现在遥控器只允许你使用上下键换台，这样就避免你直接操作指针了。这就相当于java中的引用

‘贰’ Java引用和C++引用的区别

c++ 与java引用具体比较：

c++中一个引用指向的地址不会改变，改变的是指向地址的内容，然而java中引用指向的地址在变！！
如果非要对比着看，那么Java中的“引用”倒是和C/C++的指针更像一些，和C++的“引用”很不一样。

java去除指针概念，就用引用罗...
你看 java:
A a = new A(1);
A b = new A(2);
b = a;
没有问题，a 和 b引用同一个对象A(2)，原来的A(1)成为没有被引用的对象。 垃圾回收机制会在之后的某个时刻把A(1)干掉。

而C++则不然。C++的引用就语义上说是“别名”【本质是个const指针，又叫指针常量】，而并不是指针的另一种用法：
A a = A(1);
A b = A(2);
A& c = b; //c 是 b的别名
c = a; //并不是 c 引用 a，而是拷贝操作 c.operator= ( a )

就语言机制来说，java的引用是用来管理和命名对象；
而，C++的引用机制是很纯粹的，就是别名而已。

每种语言的特性都是整体的有机部分。

我们知道， java的引用机制是一个很复杂的机制。他必须区分“基本对象”和“复合对象”，你可以想象一下，如果其中没有基本对象，那么我们如何完成对象的复制？ 唯一的解决方案是提供两个等于号，或者一律用构造函数.... 但是综合来看，他和垃圾回收形成了相当完美的组合方案。

而C++ 的引用机制为运算符重载提供了大幅度的支持。C++ 的引用是用类“模拟”基本对象的根本要求。 如果C++使用java那种引用，那么原本漂亮的 operator[]、 proxy class 等就很难实现了。 更进一步， C++ 的运算符重载对 C++ 的模版机制提供了强力的支持

在c＋＋中，引用只是对于一个变量起的别名，一旦定义就无法修改，即无法再指向其他变量，如程序中，对于a的引用的任何操作都等同于对于a的操作。

java定义的引用并不是这样。在java中，引用相当与指针，它与c中的指针主要有两个区别：一是引用不能进行地址操作，如数组的加一 操作，相当于引用只是只是指向数据的一个副本，而不是数据本身，这样就避免了由于对于地址的误操作而改变其他变量的值，甚至危害到系统的安全。二是 java中的引用只能指向对象，他的引用是在实例化对象时系统直接生成的，因此对于普通数据类型是不能进行引用定义的，如果要对普通数据类型进行函数调用 时的地址传递（即java中的引用传递），必须把数据封装到类中。
java的这种特性使得在java的函数或类的参数传递时可以实现与c中指针相同的功能。

具体应用：

指针和引用在C++中很常用，但是对于它们之间的区别很多初学者都不是太熟悉，下面来谈谈他们2者之间的区别和用法。

1.指针和引用的定义和性质区别：

(1)指针：指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。如：

int a=1;int *p=&a;

int a=1;int &b=a;

上面定义了一个整形变量和一个指针变量p，该指针变量指向a的存储单元，即p的值是a存储单元的地址。

而下面2句定义了一个整形变量a和这个整形a的引用b，事实上a和b是同一个东西，在内存占有同一个存储单元。

(2)可以有const指针，但是没有const引用；

(3)指针可以有多级，但是引用只能是一级（int **p；合法 而 int &&a是不合法的）

(4)指针的值可以为空，但是引用的值不能为NULL，并且引用在定义的时候必须初始化；

(5)指针的值在初始化后可以改变，即指向其它的存储单元，而引用在进行初始化后就不会再改变了。

(6)"sizeof引用"得到的是所指向的变量(对象)的大小，而"sizeof指针"得到的是指针本身的大小；

(7)指针和引用的自增(++)运算意义不一样；

2.指针和引用作为函数参数进行传递时的区别。

(1)指针作为参数进行传递：

‘叁’ java的引用就是C或者C++里说的指针吗

个人感觉java引用使用上和c++的指针差不多。java引用可以为null，指针也可以。java引用和c++的指针一般都要new一个对象才能用。
不过语法上又像c++的引用，可以直接用成员访问符，仅此而已。
其实c++的指针和引用本身区别也没有多少，引用这个概念就是从c语言，指针扩展来的。

‘肆’ 关于java中的引用型变量和c中的指针的差别问题。比如我在c中写一句 int a=1; 那就在

应该说最大差别在GC.java的垃圾处理机制.
c的话你需要自己释放不在使用的内存,java不需要.
当前缓存中数据过多也会 内存溢出.

你的理解是对的.
int a=1;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有1这个值,如果没找到,就将1存放进来,然后将a指向1.

然后p = a了.就会先去栈中创建p,然后找a然后找a对应的1.始终找的都是那个1的内存.
你可以判断下.a==p.判断的是内存地址.
比较的始终是他们共同指向的那个1的内存地址.
所以a跟c里的指针不一样,是单独的两个对象,只不过他们最终指向的内存地址一样.

‘伍’ JAVA中值调用和引用调用的区别

值传递的值是存放在栈里面的，可以直接访问传递
应用传递的值是存放在推里面的，他要通过栈里面的一个“路标”（即存放在推里面的值的一个地址）去访问，故有”指针“一说，但在JAVA中不能说是指针，不专业

‘陆’ Java引用和C++指针的区别

1.类型：引用其值为地址的数据元素，java封装了的地址，可以转成字符串查看，长度可以不必关心。C++指针是一个装地址的变量,长度一般是计算机字长，可以认为是个int。

2.所占内存： 引用声明时没有实体，不占空间。C++指针如果声明后会用到才会赋值，如果用不到不会分配内存。

3.类型转换：引用的类型转换，也可能不成功，抛异，或者IDE就不能通过。C++指针只是个内存地址，指向那里，对程序来说还都是一个地址，但可能所指的地址不是程序想要的！

4.初始值：引用初始值为java关键字null。C++指针是INT，如不初始化指针，那他的值就不是固定的了。

5.计算：引用是不可以计算的。C++指针是INT，所以他可以计算，所以经常用指针来代替数组下标。

6.控制：引用不可以计算，所以他只能在自己程序里，可以被控制。C++指针是内存地址，也可以计算，所以他有可能指向了一个不归自己程序使用的内存地址，对于其他程序来说是很危险的，对自己程序来说也是不容易被控制的。

7.内存泄露：JAVA引用不会产生内存泄露。C++指针是容易产生内存泄露的，所以程序员要小心使用，及时回收。

8.作为参数：JAVA的方法参数只是传值，引用做为参数使用时候，回给函数内引用的值的COPY，所以在函数内交换两个引用参数是没意义的，因为
函数只交换的参数的COPY值，但在函数内改变一个引用参数的属性是有意义的，因为引用参数的COPY所引用的对象是和引用参数是同一个对象。
C++指针做为参数给函数使用，实际上就是他所指的地址在被函数操作，所以函数内用指针参数的操作都将直接作用到指针所指向的地址（变量，对象，函数，等
等）。

9.操作符和声明：java里用"."。C++指针用"->" 用"*"声明指针。（似乎这条没什么用！）

10.本质：java中的引用和C++中的指针本质上都是想通过一个叫做引用或者指针的东西，找到要操作的目标（变量 对象等），方便在程序里操作。所不同的是JAVA的办法更安全，方便些，但没有了C++的灵活，高效。

java中的引用和C++中的指针，他们最好不要混在一起，也不要认为是一回事，只不过他们的作用有些相似，总叫人不自觉的对比。但在我们写
JAVA程序的时候最好忘记C++的指针，写C++程序的时候，也不要老惦记着JAVA的引用。只要记得
引用无大小，安全，不可计算，强转时要小心就好了。

参考
http://blog.csdn.net/b271737818/article/details/3931913

‘柒’ java中的引用数据类型是什么意思

1. 引用数据类型为java两大数据类型之一

2. 引用数据型在被床架时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。

3. 引用数据类型包括：类、接口类型、数组类型、枚举类型、注解类型，字符串型；

• java另一大数据类型为基本数据类型，其包括包括数值型，字符型和布尔型。

• 基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上；
  

‘捌’ 在JAVA中原始数据类型，与引用数据类型有什么区别

原始数据类型包括byte、int、char、long、float、double、boolean和short，对应的封装类booleanBoolean
charCharacter
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
。引用类型和原始类型的行为完全不同，并且它们具有不同的语义。原始数据类型保存在栈中，保存的是实际值；引用类型也保存在栈中，保存的是一个实际对象的地址。它们占用空间大小和存取速度不同；当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为
null，而原始类型实例变量的缺省值与它们的类型有关

‘玖’ Java中this的用法跟C++的this指针一样吗

Java的this是改对象的引用，通过“.”号调用对象。C++的this是指向该对象的指针，用“->”调用对象。Java 的this引用和C++this指针虽然在用法上很相似，但是有本质的区别，引用相当于与对象的索引号，它的值对于程序员没有任何意义，而指针的值是对象的地址对程序员很有用处。

‘拾’ java中指针怎么理解

实际上，java力图使程序员忘记指针，这包括2个方面：
第一，java限制指针，去除了指针运算。
第二，java从语法上努力隐藏指针，让指向某对象的指针看起来更像那个对象本身！

是的，所有的java书籍都让人忘记了指针这回事，我们仿佛只跟对象打交道。偶尔，会被迫分清引用和
对象的关系。这就是目前的情形。多么好的想法！对象可比那些个不知所以的指针亲和多了！这是一种伟大的抽象！

这里，我们也更愿意把引用和对象混淆。是的，为什么不呢？那样，整个世界都是对象，太好理解了！

可事实上，为了节省内存，java不能把引用（指针）完全废除。要知道，复制一个引用（指针）要比
复制整个对象有效得多！所以我们不得不面对引用和对象共存的事实。

下面我就好好分析分析：

指针已经被抽象成了引用，现在指针不能够随心所欲的运算，并且看起来就像个对象，完全没有了指针
的模样。但它毕竟和对象还是不同的，还要经过一层“转换”（从指向的那个对象里取数据）。如果我们
在引用满天飞的时候总想着这样一层转换，真的是很不舒服。比如：
String key="name";
String value="hyq";
HashMap map=new HashMap();
map.put(key,value);

你得想着：key只是个引用，value也是个引用，map还是个引用，我们刚刚做的是把key和value
这2个引用放进了map（也是个HashMap对象的引用）中，到时候我就可以通过map这个引用取得
里面的对应于key引用的value引用！

你不晕我就服了。
一旦你这样想，你每时每刻都要面对这样的绕口令。因为我们对对象的操作全部要通过引用！java没有提供语法让你直接得到对象！（指的是直接寻址）这一点通过比较原始类型很好理解，int i=8，那么
i就是8，不是什么指针，要先找到放着8那块内存的地址再把8拿出来。这样多直接，多方便啊！

所以，我们对引用最好也这么来理解，就轻松多了。
还是上面的例子，key就是个String，value也是个String，map是个HashMap，我们把key和value
放进map里，将来可以按key取出value。——多简单！

其实，这样的理解是很符合人的思维习惯的，我相信大多数人刚学java时都会自然而然的这么理解，
但是我们一定要注意在什么时候不能这么理解。只要记住什么时候不能这么理解，我们就不会因为
这种“近似”的理解方式而犯错，而同时从这种理解方式里得到了方便和好处。

把引用直接当作对象本身的好处是简单直接，容易理解，而“误差”的地方就在于，假设只有这个引用
可以修改此对象。换句话说，当别的引用修改了对象的时候，我们毫不知情并很感费解。比如：

String name=null;
HashMap map=new HashMap();
map.put("name",name);

//do a lot of things
name="hyq";

当我们再从map里取出name的时候，发现它已经被赋值为hyq了！放进去的时候明明是啥都没有啊！
咋就变了讷？
引用到name那个对象的不只你map一个阿！

在同一个函数里出现这种情况还不是很常见，我们一般也不必这么写，更多的是出现在函数调用、传参的时候，这样更加隐蔽，不易发现，也让代码可读性下降。比如：
String name=null;
HashMap map=new HashMap();
map.put("name",name);

alterName(name);

在alterName函数里我们修改了name对象，这会直接影响到函数外的map。

所以，当我们把引用和对象故意混淆时，一定要记住什么时候应该分清楚。

对象的使用不外乎以下几种情况：

1
String name=new String("hyq");
然后使用name，引用生命周期一结束，对象失效（无法被取用）了事。这里只有name一个引用指向此对象，随便怎么弄都不会出事。

2
String name=new String("hyq");
String anotherName=name;

这里假设只有name会修改对象，并且在anotherName引用此对象前做完所有修改，anotherName只是取用这个对象调用方法。在这种情况下，也不会出事。这也是我们经常遇到的情况，并且一般都是在函数调用传参时出现。注意传参实际上就是String anotherName=name;
这里尤其要注意的是2个引用的生命周期：name修改对象的时候另一个引用还没出世，而等它出世后
发现它又不会修改对象，怎一个爽字了得！

3
String name=new String("hyq");
String anotherName=name;
代码和上面一样，但是这里要么2个引用都会修改对象，要么只有一个修改但会影响到另一个。这个时候无论如何你不能再把引用当对象了，你必须分清楚它们。你必须小心仔细，不能有丝毫疏忽。

当然，这种写法和风格无论如何是不值得提倡的，若非必要（没办法）请勿模仿！因为必然有一个引用
在不知情的情况下被人修改了对象，等它用的时候会大吃一惊，而这个对象是在什么时候被什么人修改的，极难排查。
（上面例子举得不好，String类是不变类，汗！）
StringBuffer name=new StringBuffer("hyq");
StringBuffer anotherName=name;
//do a lot of things
anotherName.append("is my gf");

你可能写得爽，一时痛快就这么写了，你也知道是什么人在什么时候修改了对象，但是别人呢？
要知道，这里可能不是相隔几行代码这么简单，可能是嵌套了好几层函数调用！你把那个anotherName传到第5层函数里面，然后丧心病狂的修改了那个对象，除了天知地知你知，鬼
都看不出来！