java中引用数据类型和基本数据类型的区别是什么？
java中引用数据类型和基本数据类型的区别是什么？
09-06-06 &
java的8种基本类型：byte,short, char, int, long,float,double,boolean.与此对应的，java提供了8种包装类型：Byte,Short,Character,Integer,Long,Float,Double,Boolean.它们之间的相互转换：例如：double a=1;//把double基本类型转换为Double包装类型Double b=new Double(a);//把Double包装类型转换为double基本类型a=b.doubleValue();所谓引用,就是指针了,就是说对象指向的不是数据本身,而是它所在的内存地址.数组就是引用类型!一般在传参的时候用的最多。
请登录后再发表评论!今天使用HashMap时，发现不能使用基本数据类型，例如，HashMap&String, int& som = new HashMap&String, int&();
发现提示错误：Syntax error on token "int", Dimensions expected after this token。
后来从网上找到了答案，HashMap不能使用基本数据类型。
没有理解引用类型和原始类型。
Java&提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型&&&封装类
boolean&&&&&&Boolean
char&&&&&&&&&&&Character
byte&&&&&&&&&&&Byte
short&&&&&&&&&&Short
int&&&&&&&&&&&&&&Integer
long&&&&&&&&&&&Long
float&&&&&&&&&&&Float
double&&&&&&Double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为&null，而原始类型实例变量的缺省值与它们的类型有关。
具体HashMap了解，相关链接：
阅读(...) 评论()
Copyright at 2012 yangwenlongjava实现基本类型进行引用传参的解决方案
java当然基本类型都是值传参的，对象是引用传参。但是基本类型的对象形式好像也是值传参的，这样就是很多人整郁闷了，下面是可以实现基本类型的对象形式的引用传参实现：
能改变 Integer 值的方法
import java.util.*;
import java.text.*;
import java.lang.reflect.*;
public class test
public static void main(String[] args) throws Exception{
String abc = "yourname";
System.out.println(abc);
upper(abc);
System.out.println(abc);
Integer&i = 3;
change(i);
System.out.println(i);
//当然如果对象作为参数要改变他内部状态的话，该对象必须是mutable的，如果是String那么是无法被改变的
//Integer同样是immutable的，不过可以通过反射来改变immutable的状态
public static void change(Integer x) throws Exception
Field f = abc.getClass().getDeclaredField("value");
f.setAccessible(true);&&&&&&&&&&
//需要改变内部状态成mutable.
f.setInt(x,x+1);
public static void upper(String str) throws Exception
Field f = str.getClass().getDeclaredField("value");
f.setAccessible(true);&&&&
//需要改变内部状态成mutable.
char[] ch = (char[])f.get(str);
for(int i=0;i &ch.i++)
if(ch[i]&='a' &&
ch[i] &='z')
ch[i] = (char)(ch[i] + ('A'-'a'));
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。java基本数据类型之间赋值与运算归纳 - 推酷
java基本数据类型之间赋值与运算归纳
java基本数据类型之间赋值与运算归纳
前言：面对“byte b1=3;byteb2=7;byte b=b1+b2;”报错，而“int i1=3;int i2=7;int i=i1+i2;”不报错，进行了深入探究，从而引申出java基本类型之间赋值与运算操作的规律。通过自己制作的图例分析，达到对不同基本数据类型之间的赋值与运算结果的正确判断。不会再出现事实而非的回答，知道运算底层。好了，言归正传。
先送给大家今天我看到的一句话，觉得很有意义
如果你自己都模棱两可的话，不要指望Java虚拟机会明白你的意思。
一、&&认识赋值运算符。
赋值使用操作符“=”。它的意思是“取右边的值（即右值），把它复制给左边（即左值）”。右值可以是任何
常数、变量或者表达式
（只要它能
一个值就行）。但左值必须是一个明确的，已命名的变量。也就是说，必须有一个物理空间可以存储等号右边的值。
分类 基本数据类型 与 类数据类型 的不同
1、&&&&&对基本数据类型的赋值是很简单的。基本数据存储了实际的数值，而并非指向一个对象的引用，所以在为其赋值的时候，是直接将一个地方的内容复制到了另一个地方。
2、&&&&&但是在为对象“赋值”的时候，情况却放生了变化。对一个对象进行操作，我们真正操作的是对对象的引用。----这种特殊的现象通常称作“别名现象”，是Java操作对象的一种基本方式。
----摘抄自《Thinking In Java》P39
二、&&Java中byte、short和char类型运算的细节。
Java中涉及byte、short和char类型的运算操作首先会把这些值转换为int类型，然后对int类型值进行运算，最后得到int类型的结果。因此，如果把两个byte类型值相加，最后会得到一个int类型的结果。如果需要得到byte类型结果，必须将这个int类型的结果显式转换为byte类型。
Java虚拟机中没有byte类型！！！
Java虚拟机对基本类型的操作基本都是在栈上完成的（这个是可信的，因为不是我说的）。我们知道，Java在处理一个语句的时候，首先它会先把用到的操作数压到栈中，然后再从栈中弹出进行计算，最后将结果再压回到栈中。任何对byte的操作也会如此。因此，Java对byte类型操作之前会将其压入到栈中。实际上，Java压入栈的不是byte类型，而是一个标准的int类型（32位，byte是8位），也就是说，Java虚拟机将我们短小可爱的byte类型压入栈之前，会先把它拉长成int类型再压栈。不过事实上在压栈之前也是int类型.这样一来，我们不管是在栈里还是从栈里弹出的byte类型实际上都是用int的长度存储的。这也就是我为什么说，Java虚拟机中没有byte类型。因为它们都被变成了int。
----摘抄自网络文章《int与byte的区别》
下面是我做的一些测试
三、&&测试一数字值赋值给变量。
格式例如 Xxx &x = 数值；//检验是否正确。
说明：例如byte b = 14；14是int类型，能成功，对应表格就打钩。
附带说明：
1、&&&&&检测数值是否超出变量范围。
2、&&&&&右值是常数
是可以确定，编译器可判断数值大小。
四、&&检测二变量赋值给变量。
格式例如 Xxx 变量B=变量A;& //检验是否正确。
变量B\变量A
说明：例如
int i = 14;
byte b =& //如果通过编译，就在对应的表格打钩。
附带说明：
1、&&&&&右值为变量
不确定数值大小，
只能简单判断空间的大小。
根据已知理论，结合两个图片做一些练习：
byte b = 4;
//编译通过，因为“3+7”在编译时直接变为int的“10”，根据表//一，可行。
byte b1 = 3;
byte b2 = 7;
byte b = b1+b2; //不能通过编译。因为根据原理二，“b1+b2”的//运算操作使其结果为int类型。
//根据表二，int类型的变量不能赋值给byte变量。
byte b1 = 3;
byte b2 = 7;
int i = b1+b2;& //能通过编译。因为根据原理二，“b1+b2”的运//算操作使其结果为int类型。
//根据表二，int类型的变量能赋值给int变量。
int i1 = Integer.MAX_VALUE;
int i2 = 2;
int I = i1+i2;& //能通过编译。因为根据原理二，“i1+i2”的运//算操作使其结果为int类型。
//根据表二，int类型的变量能赋值给int变量。
short s1=1;
s1 = s1+1;&& //不能通过编译。因为根据原理二，“s1+1”的运算//操作使其结果为int类型。
//根据表二，int类型的变量不能赋值给short变量。
short s1=1;
s1 = 1+1；& //能通过编译。因为根据原理二，“1+1”的运算操作//使其结果为int类型。
//根据表一，int类型的数值能赋值给short变量。
short s1=1;
s1 += 1; &
//能通过编译。这里与“+=”运算符有关系，这里使“1”先强转为//short类型，然后short类型“1”参与运算。（可能有点模糊，后//续笔者会重新诠释。）
通过例题，获取小结
1、&&&&&右边不能判断，就不能赋值、转化。
2、&&&&&判断是否可以赋值，查看右边是常数（3,3+7）还是变量（x,x+7,x+y）。
如有好的建议，可留言或发至笔者邮箱：fzb_
已发表评论数()
已收藏到推刊！
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
排版有问题
没有分页内容
视频无法显示
图片无法显示Java中的原生数据类型和引用类型的参数传递 - windywindy - ITeye技术网站
博客分类：
&&& 1 ：如果参数是基本数据类型（四类八种：byte，short，int，long，double，float，double，boolean，char），
public class PrimitiveType {
　　public void change(int a) {
　　a = 3;
　　public static void main(String[] args) {
　　int a = 1;
　　PrimitiveType test = new PrimitiveType();
　　test.change(a);
　　System.out.println(a); // 1 ,而不是3
change 方法在被调用的时候，在内存中也分配一个空间来存储，存的是传过来的值，即3 .
&&& 而当方法结束时，这块内存就等垃圾回收了，而在main 方法中，它打印的a 的值是在调用main
&&& 方法时分配的内存空间，他们俩之间没有任何关系，所以打印的还是1.
2 ： 如果参数是引用数据类型（类，数组，接口），那么传的是也是变量的值，
&&& 例如： Point param =new Point（）；
&&& 那么传过去的是point 这个变量的值 ，而不是说Point 这个对象！
&&& 而point 这个变量的值，其实就是Point 对象在内存中的地址（也叫引用）！
&&& 例子：
public class ReferenceType {
　　public void changePoint(Point point) {
　　point.x = 5;
　　point.y = 6;
　　public void changeReference(Point point) {
　　point =
　　public void testPassByStirng(String param) {
　　param = "newValue";
　　public static void main(String[] args) {
　　int a = 1;
　　Point point = new Point(1, 2);
　　ReferenceType test = new ReferenceType();
　　test.changePoint(point);
　　System.out.println(point.x); // 5 而不是 1
　　System.out.println(point.y); // 6 而不是 2
　　test.changeReference(point); // 调用这个后,下面是否会报空指针呢?
　　int x = point.x; // 不会
　　System.out.println("x 的值是 " + x );
　　String param = "value";
　　test.testPassByStirng(param);
　　System.out.println(param); // 是value ,而不是 newValue
　　class Point {
　　public Point(int x, int y) {
　　this.x =
　　this.y =
在java 中，访问对象是通过指向对象的引用来操作的，而一个对象可以被多个引用所指向，
&&& 无论其中哪个引用对这个对象的内容进行修改，它都会影响到另外一个引用，虽然引用有多个，但
&&& 对象却只有一个！
&&& changePoint 方法被调用时，你把main 方法中的Point 对象的引用point 传给了changePoint的参数
&&& point，此时，这个point 引用也指向了main 方法中的Point 对象（new 出来的），而你在这个方法中，
&&& 用point 这个引用对Point 对象（new 出来的）的内容进行了修改（point.x = 5；point.y = 6；），
&&& 因为它们指向的是同一个Point 对象（new 出来的），所以，当方法执行完后，这个修改会反映到这
&&& 个对象上，而此时，你再打印出Point 对象的x，y 的值，都是被改变后的值！ 即不再是1和2，而是5与6 .
&&& 小结：
&&& 在java 中，方法参数的传递永远都是传值，而这个值，对于基本数据类型，值 就是你赋给变量的那个值，而
&&& 对于引用数据类型，这个值是对象的引用，而不是这个对象本身。
二： 在java 中，通过方法的调用，只能改变对象的内容，而不能改变对象的引用。
&&& 如 上面的方法
public void changeReference(Point point) {
　　point =
　　}
&&& point = null ，这句话是把你在调用changeReference方法时，本来point 这个引用与你在main 方法中
&&& 的那个point 引用指向的是同一个对象，而当你调用point = null 时，它就不再指向原来的Point 对象
&&& 了，此时，它只是改变它自身的指向，并没有对main 方法中的point 引用进行修改，main 中的point 引用
&&& 还是指向main 中的Point 对象！所以，你在main 方法中调用 point.x； 是不会发生空指针异常的。
&&& 也就是说：在方法中，你把引用 所对应的对象的内容给改变了，它是会反应到对象上的
&&& ，这时，你再取对象的内容时，已经是你改变过了的！而无论你把传过去的引用如何
&&& 改（point = null），该引用永远指向它原来 的那个对象！
&&& 当String 做为参数传递的时候，是由于String对象本身
&&& 是不变对象所决定的！ 上面的testPassByStirng 方法。
&&& String 类型，它是不变对象，但它符合二：
&&& 当它作参数传过去时，如果对引用操作如： paramString = "改变原来的值"；
&&& 这个所做的是： "改变原来的值" 其实就是String类的一个匿名对象，所以，你这样是在
&&& 方法中，重新构造一个String 对象出来，然后这个对象的引用赋给paramString ，此时，
&&& 把paramString 这个引用 给改变了，但传过来的引用并没有被改变！
windywindy
浏览: 109061 次
来自: 广州
fatter 写道lz用的是什么数据库？我用的db2上报这样的 ...
lz用的是什么数据库？我用的db2上报这样的错误，前提是我没有 ...
最后一段“如果web.xml遇到了和这两个元素，那么它会忽略元 ...
非常感谢！