前言：面对“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
 
short
 
int
 
long
 
float
 
double
 
byte
 
√
 
X
 
X
 
X
 
short
 
√
 
X
 
X
 
X
 
int
 
√
 
X
 
X
 
X
 
long
 
√
 
√
 
X
 
X
 
float
 
√
 
√
 
√
 
X
 
double
 
√
 
√
 
√
 
√
 
说明：例如byte b = 14；14是int类型，能成功，对应表格就打钩。
 
附带说明：
 
1、     检测数值是否超出变量范围。
 
2、     右值是常数
 
是可以确定，编译器可判断数值大小。
 
四、  检测二变量赋值给变量。
 
格式例如 Xxx 变量B=变量A;  //检验是否正确。
 
变量B\变量A
 
byte
 
short
 
int
 
long
 
float
 
double
 
byte
 
√
 
X
 
X
 
X
 
X
 
X
 
short
 
√
 
√
 
X
 
X
 
X
 
X
 
int
 
√
 
√
 
√
 
X
 
X
 
X
 
long
 
√
 
√
 
√
 
√
 
X
 
X
 
float
 
√
 
√
 
√
 
√
 
√
 
X
 
double
 
√
 
√
 
√
 
√
 
√
 
√
 
说明：例如
 
int i = 14;
 
byte b = i;  //如果通过编译，就在对应的表格打钩。
 
附带说明：
 
1、     右值为变量
 
不确定数值大小，
 
只能简单判断空间的大小。
 
根据已知理论，结合两个图片做一些练习：
 
例1：
 
byte b = 4;
 
b = 3+7;
 
//编译通过，因为“3+7”在编译时直接变为int的“10”，根据表//一，可行。
 
例2：
 
byte b1 = 3;
 
byte b2 = 7;
 
byte b = b1+b2; //不能通过编译。因为根据原理二，“b1+b2”的//运算操作使其结果为int类型。
 
//根据表二，int类型的变量不能赋值给byte变量。
 
例3：
 
byte b1 = 3;
 
byte b2 = 7;
 
int i = b1+b2;  //能通过编译。因为根据原理二，“b1+b2”的运//算操作使其结果为int类型。
 
//根据表二，int类型的变量能赋值给int变量。
 
例4:
 
int i1 = Integer.MAX_VALUE;
 
int i2 = 2;
 
int I = i1+i2;  //能通过编译。因为根据原理二，“i1+i2”的运//算操作使其结果为int类型。
 
//根据表二，int类型的变量能赋值给int变量。
 
例5：
 
short s1=1;
 
s1 = s1+1;   //不能通过编译。因为根据原理二，“s1+1”的运算//操作使其结果为int类型。
 
//根据表二，int类型的变量不能赋值给short变量。
 
例6：
 
short s1=1;
 
s1 = 1+1；  //能通过编译。因为根据原理二，“1+1”的运算操作//使其结果为int类型。
 
//根据表一，int类型的数值能赋值给short变量。
 
例7：
 
short s1=1;
 
s1 += 1;
 
/*
 
能通过编译。这里“+=”运算符与“+”运算符原理一样，先检查右边，右边不符合对其强转。“s1=1”为一次运算；“s1+=1”为一次运算；“s1=s1+1”为两次运算。所以例题中是将“1”强转为“short”类型参与运算的。
 
*/
 
通过例题，获取小结
 
1、     右边不能判断，就不能赋值、转化。
 
2、     判断是否可以赋值，查看右边是常数(3,3+7)还是变量(x,x+7,x+y)。

 

 
我们都知道在Java里面new出来的对象都是在堆上分配空间存储的，但是针对基本类型却有所区别，基本类型可以分配在栈上，也可以分配在堆上，这是为什么？
 
在这之前，我们先看下Java的基本类型8种分别是：
 
byte =>8bit
 
short => 16bit
 
int => 32bit
 
long =>64bit
 
folat => 单精度32位
 
double => 双精度64位
 
boolean => 注意oracle官网文档介绍，boolean代表1bit的信息，但它本身的size却不是精确的，依赖于jvm和os的实现，比较常见的说法是，boolean单独使用的时候，在编译时是使用int代替的，如果是boobean数组，则是使用1byte代替
 
char => 16bit
 
注意字符串内部是用char数组实现的，所以属于引用类型。
 
基本类型在成员变量和局部(local)变量的时候其内存分配机制是不一样的。
 
如果是成员变量，那么不分基本类型和引用类型都是在java的堆内存里面分配空间，而局部变量的基本类型是在栈上分配的。栈属于线程私有的空间，局部变量的生命周期和作用域一般都很短，为了提高gc效率，所以没必要放在堆里面。
 
如下代码：
 
public class DemoTest {
 
int y;// 分布在堆上 public static void main(String[] args) {
 
int x=1; //分配在栈上 String name=new String("cat");//数据在堆上，name变量的指针在栈上 String address="北京";//数据在常量池，属于堆空间，指针在栈 Integer price=4;//包装类型同样是引用类型，编译时会自动装拆相，所以数据在堆上，指针在栈 }
 
}
 
在java里面通过new出来的对象都在堆上分配，这里有两种特殊情况，
 
(1)字符串的字面量
 
字符串的字面量，没有new关键字，但却是在堆上分配内存的，严格的说是在堆里面的字符串常量池里面。
 
(2)基本类型的包装类
 
同样的道理，针对各个基本类型的包装类型，如：Integer，Double，Long等，这些属于引用类型，我们直接在局部方法里面使用包装类型赋值，那么数据真正的内存分配还是在堆内存里面，这里有个隐式的拆装箱来自动完成转换，数据的指针是在栈上，包装类型的出现主要是为了基本类型能够用在泛型的设计上和使用null值，而基本类型则拥有更好的计算性能，这一点我们也需要注意。原作者：攻城狮在路上
 
原文链接：Java基本类型的内存分配在栈还是堆
 
原出处：公众号

 
一、基本数据类型：
 
byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0
 
short：短整型，在内存中占16位，即2个字节，取值范围-32768~32717，默认值0
 
int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0
 
long：长整型，在内存中占64位，即8个字节-2^63~2^63-1，默认值0L
 
float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字(与double的区别在于float类型有效小数点只有6~7位)，默认值0
 
double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0
 
char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空
 
boolean：布尔类型，占1个字节，用于判断真或假(仅有两个值，即true、false)，默认值false
 
二、Java数据类型基本概念：
 
数据类型在计算机语言里面，是对内存位置的一个抽象表达方式，可以理解为针对内存的一种抽象的表达方式。接触每种语言的时候，都会存在数据类型的认识，有复杂的、简单的，各种数据类型都需要在学习初期去了解，Java是强类型语言，所以Java对于数据类型的规范会相对严格。数据类型是语言的抽象原子概念，可以说是语言中最基本的单元定义，在Java里面，本质上讲将数据类型分为两种：基本类型和引用数据类型。
 
基本类型：简单数据类型是不能简化的、内置的数据类型、由编程语言本身定义，它表示了真实的数字、字符和整数。
 
引用数据类型：Java语言本身不支持C++中的结构(struct)或联合(union)数据类型，它的复合数据类型一般都是通过类或接口进行构造，类提供了捆绑数据和方法的方式，同时可以针对程序外部进行信息隐藏。
 
三、Java中的数据类型与内存的关系
 
在Java中，每个存放数据的变量都是有类型的，如：
 
char ch； float x； int a,b,c；
 
ch是字符型的，就会分配到2个字节内存。不同类型的变量在内存中分配的字节数不同，同时存储方式也是不同的。
 
所以给变量赋值前需要先确定变量的类型，确定了变量的类型，即确定了数据需分配内存空间的大小，数据在内存的存储方式。
 
四、Java数据类型在内存中的存储：
 
1)基本数据类型的存储原理：所有的简单数据类型不存在“引用”的概念，基本数据类型都是直接存储在内存中的内存栈上的，数据本身的值就是存储在栈空间里面，而Java语言里面八种数据类型是这种存储模型；
 
2)引用类型的存储原理:引用类型继承于Object类(也是引用类型)都是按照Java里面存储对象的内存模型来进行数据存储的，使用Java内存堆和内存栈来进行这种类型的数据存储，简单地讲，“引用”是存储在有序的内存栈上的，而对象本身的值存储在内存堆上的；
 
区别:基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的(需要java中的栈、堆概念)，
 
基本类型和引用类型的内存模型本质上是不一样的。
 
例1：我们分析一下”==“和equals()的区别。
 
首先，我定以两个String对象
 
Stringa="abc";
 
Stringb="abc";
 
然后
 
if(a==b){
 
System.out.println("a==b");
 
}else{
 
System.out.println("a!=b");}
 
程序输出a!=b
 
原因:a和b的地址是不相同的，a==b比较的是两个变量的地址
 
例2：定义两个基本类型
 
int a=4;
 
int b=4;
 
if(a==b){System.out.println("a==b");}
 
else
 
{System.out.println("a!=b");}
 
输出：a==b
 
原因：==比较的是两个变量的内容
 
猜想：不论是基本数据类型还是引用类型，他们都会先在栈中分配一块内存，对于基本类型来说，这块区域包含的是基本类型的内容；而对于对象类型来说，这块区域包含的是指向真正内容的指针，真正的内容被手动的分配在堆上。
 
五、Java基本类型取值范围计算
 
从计算机组成原理的角度可以解释：
 
byte在计算机中是占8个字节的，而且byte 是有符号整形，用二进制表示时候最高位为符号位 0代表正数 1代表负数。
 
最大值：127      即2的7次方减去1；最小值：即2的7次前面加个负符号：-128 。(包含开始，不包含结尾)；
 
正数在计算机中是以原码形式存在的；
 
负数在计算机中是以其补码形式存在的，就是负数的绝对值的原码转为二进制再按位取反后加1。
 
下边这个10和-10为例来介绍的 ：10原码：00001010   它在计算机中的存储就是 0000 1010，-10 按照前面说的算除其绝对值为10，转为二进制 0000 1010 按位取反 1111 0101 再加1后：1111 0110，此为-10补码，好的，计算机中的1111 0110就是代表-10了。
 
我们来看 -128  绝对值128的二进制表示：1000 0000 按位取反 0111 1111 加1后：1000 0000，也就是说 -128在计算机中的表示就是 1000 0000 了，再来看一下-129 在计算机中的表示，绝对值129的范围已经超出了了byte的位数。所以要注意这类问题；
 
六、java类型介绍
 
1、概述：
 
Java中的数据类型分为引用数据类型和基本数据类型。
 
引用数据类型分3种：类，接口，数组；
 
基本数据类型又分布尔类型和数值类型；
 
布尔类型：boolean(逻辑型) trure or false默认是false；
 
数值类型分定点类型和浮点类型；
 
定点类型分整数类型和字符型；
 
2、JAVA变量的默认初始化
 
类型
 
默认初始化值
 
boolean
 
false
 
int
 
0
 
short
 
0
 
float
 
0.0
 
double
 
0.0
 
char
 
\
 
long
 
0
 
byte
 
0
 
object
 
null
 
3、类型详细讲解:
 
1)整数类型：byte、short、int、long都是表示整数的，只不过他们的取值范围不一样。
 
byte(字节类型) 一个byte 8位，取值范围为-128~127，占用1个字节(-2的7次方到2的7次方-1)默认是0
 
short(短整型) 一个short 16位，取值范围为-32768~32767，占用2个字节(-2的15次方到2的15次方-1)默认是0
 
int(整型)       一个int 32位，取值范围为(-2147483648~2147483647)，占用4个字节(-2的31次方到2的31次方-1)默认是0
 
long(长整型)  一个long 64位,取值范围为(-9223372036854774808~9223372036854774807),占用8个字节(-2的63次方到2的63次方-1)默认是0L或0l推荐用大写；
 
可以看到byte和short的取值范围比较小，而long的取值范围太大，占用的空间多，基本上int可以满足我们的日常的计算了，而且int也是使用的最多的整型类型了。在通常情况下，如果JAVA中出现了一个整数数字比如35，那么这个数字就是int型的，如果我们希望它是byte型的，可以在数据后加上大写的 B：35B，表示它是byte型的，同样的35S表示short型，35L表示long型的，表示int我们可以什么都不用加，但是如果要表示long型的，就一定要在数据后面加“L”。
 
1.1)定点常量
 
定点常量是整型常数，它可用十进制、八进制、十六种进制三种方式来表示。
 
十进制定点常量：如123、-456、0。
 
八进制定点常量：以0前导，形式为0dd...d。如0123表示十进制数83，-011表示十进制数-9。
 
十六进制定点常量：以0x或0X开头，如0x123表示十进制数291，-0X12表示十进制数-18。
 
1.2)定点变量
 
定点变量即整型变量，可细分成字节型变量、整型变量、短整型变量和长整型变量四种。
 
对各种定点变量的开销内存字节数和数值范围作简要说明。
 
需要注意的是，如果要将一定点常量赋值给一个定点变量，需要查验常量是否在该变量的表达范围内，如超出范围程序会编译出错。
 
2)char型(字符型)
 
Java中一个字符(char)表示Unicode字符集中的一个元素。
 
Unicode字符由16位组成，因此，有(65535)个不同的字符可用，
 
Unicode字符集包含所有不同语言的字符，以及数学、科学、文字中的常用符号，所以给了我们很大的灵活性。
 
字符由单引号括起来的单个字符表达，通常用16进制表示，
 
范围从’’到’?’(u告诉编译器你在用两个字节［16位］字符信息表示一个Unicode字符)。
 
用于存放字符的数据类型，占用2个字节，采用unicode编码，它的前128字节编码与ASCII兼容，
 
字符的存储范围在\~\?，在定义字符型的数据时候要注意加' '，比如 '1'表示字符'1'而不是数值1。
 
2.1)字符常量
 
字符常量指用单引号括起来的单个字符，如‘a’，‘A’，请特别注意，字符的定界符是单引号，而非双引号。
 
除了以上所述形式的字符常量值之外，Java还允许使用一种特殊形式的字符常量值，
 
这通常用于表示难以用一般字符来表示的字符，这种特殊形式的字符是以一个“\”开头的字符序列，称为转义字符。
 
Java中的常用转义字符见表
 
2.2)字符变量
 
以char定义的变量，如char c='a';
 
要特别加以说明的是，Java的文本编码采用Unicode集，Java字符16位无符号型数据，一个字符变量在内存中占2个字节。
 
注：char c = ' 1 '，我们试着输出c看看，System.out.println(c);结果就是1，而如果我们这样输出呢System.out.println(c+0)；结果却变成了49,这是因为0是int型,进行了向上类型转换，结果是个int型。
 
如果我们这样定义c看看，char c = ' \1 ';输出的结果仍然是1，这是因为字符'1'对应着unicode编码就是\1。
 
3)浮点类型：分float和double是表示浮点型的数据类型，他们之间的区别在于他们的精确度不同。
 
3.1)浮点常量
 
即带小数点的实型数值，可以由直接带小数点的数值和科学计数法两种形式来表示：
 
带小数点的数值形式：由数字和小数点组成，如0.123、.123、123.、123.0。
 
科学计数法表示形式：由一般实数和e±n(E±n)组成，如12.3e3、5E-3，它们分别表示12.3乘以10的3次方，5乘以10的-3次方。需要注意的是，e或E之前必须有数字，且e或E后面的指数必须为整数。
 
3.2)浮点变量
 
浮点变量有单精度变量和双精度变量之分，不同的精度开销的内存字节数和表达的数值范围均有区别。两种浮点变量占内存字节数和数值范围
 
浮点常量也有单精度和双精度之分，前面列出的常量均是双精度常量，如果要特别说明为单精度常量，可以数据末尾加上f或F作为后缀，如12.34f。如果要特别指明一个浮点常量是双精度常量，数据末尾不需要添加后缀，或者在数据末尾加上d或D作为后缀，如12.34d。
 
float (单精度浮点型)一个float 32位，占用4个字节，例3.2F，默认是0.0f， 3.402823e+38 ~1.401298e-45(e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方)。
 
double (双精度浮点型)一个dobule 64位 占用8个字节，例3.2，默认是0.0， 1.797693e+308~4.9000000e-324 占用8个字节
 
注:double型比float型存储范围更大，精度更高，所以通常的浮点型的数据在不声明的情况下都是double型的。
 
如果要表示一个数据是float型的，可以在数据后面加上“F”。 浮点型的数据是不能完全精确的，所以有的时候在计算的时候可能会在小数点最后几位出现浮动，这是正常的。
 
相关介绍：
 
在Java基本类型在使用字面量赋值的时候，有几个简单的特性如下：
 
1】当整数类型的数据使用字面量赋值的时候，默认值为int类型，就是直接使用0或者其他数字的时候，值的类型为int类型，所以当使用 long a = 0这种赋值方式的时候，JVM内部存在数据转换。
 
2】浮点类型的数据使用字面量赋值的时候，默认值为double类型，就是当字面两出现的时候，JVM会使用double类型的数据类型。
 
3】从JDK 5.0开始，Java里面出现了自动拆箱解箱的操作，基于这点需要做一定的说明：
 
对应原始的数据类型，每种数据类型都存在一个引用类型的封装类，分别为Boolean、Short、Float、Double、Byte、Int、 Long、Character，这些类型都是内置的封装类，这些封装类(Wrapper)提供了很直观的方法，针对封装类需要说明的是，每种封装类都有一个xxxValue()的方法，通过这种方法可以把它引用的对象里面的值转化成为基本变量的值，不仅仅如此，每个封装类都还存在一个valueOf(String)的方法直接把字符串对象转换为相应的简单类型。
 
在JDK 5.0之前，没有存在自动拆解箱的操作，即Auto Box操作，所以在这之前是不能使用以下方式的赋值代码的：Integer a = 0;//这种赋值方式不能够在JDK 1.4以及以下的JDK编译器中通过,但是JDK 5.0出现了自动拆解箱的操作，所以在JDK 5.0以上的编译器中，以上的代码是可以通过的
 
引用数据类型：
 
数组
 
String：字符串型，用于存储一串字符
 
Java变量声明及使用：
 
数据类型变量名 =值、表达式；
 
例：String name = "柯南";
 
int a= 50;
 
注：“=”并不是数学中的“等号”，而是一个赋值运算符
 
Java变量命名规则：
 
1：必须以字母、下划线“_”、或“$”符号开头
 
2：可以包括数字、区分大小写
 
3：不能使用Java语言的关键字，例如int、class、public等
 
Java中的六种运算符：
 
·   算术运算符
 
·   赋值运算符
 
·   关系运算符
 
·   逻辑运算符
 
·   位运算符
 
·    三元运算符
 
算术运算符：
 
+：加法运算，求操作数的和
 
-：减法运算，求操作数的差
 
*：乘法运算，求操作数的乘积
 
/：除法运算，求操作数的商
 
%：求余运算，求操作数相除的余数
 
++：自增，操作数自加1
 
--：自减，操作数自减1
 
赋值运算符：
 
=：将右边的值赋给左边，例：int a = 1;
 
+=：左右两边的和相加赋给左边，例：int a = 1; a+=2;结果a的值为3
 
-=：左边减去右边的差赋给左边，例：int a =5;a-=2;结果a的值为3
 
*=：两边数值相乘的值赋给左边，例：int a = 2;a*=2;结果a的值为4
 
/=：左边除以右边的值赋给左边，例：int a = 6;a/=2;结果a的值为3
 
%=：左边除以右边的余数赋给左边，例：int a =7;a%=2;结果a的值为1
 
关系运算符
 
>：大于，例：int a = 1;int b = 2;System.out.print(a > b);其结果为false
 
>=：大于等于,例：int a = 1;int b = 2;System.out.print(a >= b);其结果为false
 
<=：小于等于,例：int a = 1;int b = 2;System.out.print(a <= b);其结果为true
 
==：等于,例：int a = 1;int b = 2;System.out.print(a == b);其结果为false
 
!=：不等于,例：int a = 1;int b = 2;System.out.print(a != b);其结果为true
 
其结果都是boolean类型，即要么是true要么是false
 
逻辑运算符
 
&&：与、并且(短路)，   两个条件同时为真时，结果为真
 
||：或、或者(短路)，   两个条件有一个为真时，结果即为真
 
!：非，(!+条件)  条件为真时，结果为假
 
Java中的数据类型转换
 
1：自动数据类型转换(放大转换)
 
满足自动数据类型转换条件：
 
1)两种类型要兼容：如数值类型(整型和浮点型)
 
2)目标类型大于源类型：例如int型数据可以自动转换为double类型
 
2：强制数据类型转换(缩小转换)
 
在变量前加上括号，在括号中指定要强制转换的类型
 
例：double a = 40.9;
 
int b= (int)a;
 
注：强制转换会损失数值精度，例如double类型变量a，经强制转换为int类型后值变为40

 
全局变量(成员变量)，局部变量，静态变量：
 
全局变量(成员变量)：
 
1.全局变量定义在类中，在整个类中都可以被访问
 
2.全局变量有默认的初始化值
 
3.成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中
 
局部变量：
 
1.局部变量定义在局部范围内：如方法，函数，语句中，只在作用域有效
 
2.局部变量没有默认初始化值
 
3.局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放
 
静态变量：
 
用static关键字修饰的变量，被所有对象所共享
 
成员变量与静态变量的区别：
 
1.声命周期不同
 
成员变量随对象创建而创建，随对象销毁而销毁
 
静态变量随类加载而加载，随类消失而消失
 
2.调用方式不同
 
成员变量只能被对象调用
 
静态变量可以被对象调用，也可以被类名调用
 
3、别名不同
 
成员变量也称为实例变量。
 
静态变量也称为类变量。
 
4、数据存储位置不同
 
成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
 
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据。
 
列表对比：
 
成员变量、局部变量、静态变量的区别
 
成员变量局部变量静态变量
 
定义位置在类中,方法外方法中,或者方法的形式参数在类中,方法外
 
初始化值有默认初始化值无,先定义,赋值后才能使用有默认初始化值
 
调用方式对象调用---对象调用，类名调用
 
存储位置堆中栈中方法区
 
生命周期与对象共存亡与方法共存亡与类共存亡
 
别名实例变量---类变量
 
基本数据类型(8个)：
 
int,byte,char,short,float,double,long,boolean
 
包装类数据(8个)：
 
Integer,Byte,Character,Short,Float,Double,Long,Boolean
 
java中的数据存储：
 
1. 寄存器(register)。 这是最快的存储区，因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限，所以寄存器由编译器根据需求进行分配。你不能直接控制，也不能在程序中感觉到寄存器存在的任何迹象。
 
------最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.
 
2. 堆栈(stack)。位于通用RAM中，但通过它的“堆栈指针”可以从处理器哪里获得支持。堆栈指针若向下移动，则分配新的内存；若向上移动，则释放那些 内存。这是一种快速有效的分配存储方法，仅次于寄存器。创建程序时候，JAVA编译器必须知道存储在堆栈内所有数据的确切大小和生命周期，因为它必须生成 相应的代码，以便上下移动堆栈指针。这一约束限制了程序的灵活性，所以虽然某些JAVA数据存储在堆栈中——特别是对象引用，但是JAVA对象不存储其 中。
 
------存放基本类型的变量数据和对象，数组的引用，但对象本身不存放在栈中，而是存放在堆(new 出来的对象)或者常量池中(字符串常量对象存放在常量池中)
 
3. 堆(heap)。一种通用性的内存池(也存在于RAM中)，用于存放所以的JAVA对象。堆不同于堆栈的好处是：编译器不需要知道要从堆里分配多少存储区 域，也不必知道存储的数据在堆里存活多长时间。因此，在堆里分配存储有很大的灵活性。当你需要创建一个对象的时候，只需要new写一行简单的代码，当执行 这行代码时，会自动在堆里进行存储分配。当然，为这种灵活性必须要付出相应的代码。用堆进行存储分配比用堆栈进行存储存储需要更多的时间。
 
------存放所有new出来的对象。
 
4. 静态存储(static storage)。这里的“静态”是指“在固定的位置”。静态存储里存放程序运行时一直存在的数据。你可用关键字static来标识一个对象的特定元素是静态的，但JAVA对象本身从来不会存放在静态存储空间里。
 
------存放静态成员(static定义的)
 
5. 常量存储(constant storage)。常量值通常直接存放在程序代码内部，这样做是安全的，因为它们永远不会被改变。有时，在嵌入式系统中，常量本身会和其他部分分割离开，所以在这种情况下，可以选择将其放在ROM中
 
------存放字符串常量和基本类型常量(public static final)
 
6. 非RAM存储。如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。
 
------硬盘等永久存储空间 就速度来说，有如下关系：
 
寄存器 >堆栈 > 堆 > 其它
 
这里我们主要关心栈，堆和常量池，对于堆和常量池中的对象可以共享，对于栈中的对象不可以共享。
 
栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。
 
栈内存：
 
某一个函数被调用时，这个函数会在栈内存里面申请一片空间，以后在这个函数内部定义的变量，都会分配到这个函数所申请到的栈。当函数运行结束时，分配给函数的栈空间被收回，在这个函数中被定义的变量也随之被释放和消失。栈内存比堆内存小得多
 
堆内存：
 
通过new产生的数组和对象分配在堆内存中。堆内存中分配的内存，由JVM提供的GC(垃圾回收机制)来管理。在堆内存中产生了一个数组对象后，我们还可以在栈中定义一个变量，这个栈中变量的取值等于堆中对象的首地址。栈内存中的变量就成了堆内存中数组或者对象的引用变量。我们以后就可以在程序中直接使用栈中的这个变量来访问我们在堆中分配的数组或者对象，引用变量相当于数组或者对象起的一个别名，或者代号。
 
引用变量是一个普通的变量，定义时在栈中分配；引用变量在被运行到它的作用域之外时就被释放，而我们的数组和对象本身是在堆中分配的，即使程序运行到使用new产生对象的语句所在的函数或者代码之后，我们刚才被产生的数组和对象也不会被释放。数组和对象只是在没有引用变量指向它，也就是没有任何引用变量的值等于它的首地址，它才会变成垃圾不会被使用，但是它任然占据着内存空间不放(这也就是我们Java比较吃内存的一个原因)，在随后一个不确定的时间被垃圾回收器收走。
 
堆内存和栈内存的区别
 
1、应用程序所有的部分都使用堆内存，然后栈内存通过一个线程运行来使用。
 
2、不论对象什么时候创建，他都会存储在堆内存中，栈内存包含它的引用。栈内存只包含原始值变量好和堆中对象变量的引用。
 
3、存储在堆中的对象是全局可以被访问的，然而栈内存不能被其他线程所访问。
 
4、栈中的内存管理使用LIFO的方式完成，而堆内存的管理要更复杂了，因为它是全局被访问的。堆内存被分为，年轻一代，老一代等等(Young Generation and Old Generation.)。
 
5、栈内存是生命周期很短的，然而堆内存的生命周期从程序的运行开始到运行结束。
 
6、我们可以使用-Xms和-Xmx JVM选项定义开始的大小和堆内存的最大值，我们可以使用-Xss定义栈的大小
 
7、当栈内存满的时候，Java抛出java.lang.StackOverFlowError异常而堆内存满的时候抛出java.lang.OutOfMemoryError: Java Heap Space错误
 
8、和堆内存比，栈内存要小的多，因为明确使用了内存分配规则(LIFO)，和堆内存相比栈内存非常快。
 
例(引用)：
 
String 类型的变量通常有两种赋值方式：一种直接赋值，例如String a = "hello world"；另一种是用构造方法，例如 String b = new String ("hello world");那么这里的a 和b是否相等呢？他们又有什么不同 呢？
 
如果用=作比较，则它们不相等，因为“=”比较的是基本数据类型的值是否相等或者比较对象是否为同一个对象；而变量a和变量b指向的是两个不同的对象，为什么这么说呢？先来理解一下2个变量的赋值过程，对于表达式String a = "hello world"，会先创建一个字符串对象“hello world”，而这个字符串实际上是放在字符串缓冲区中，然后把a指向这个对象；而对于String b = new String("hello world");则会创建两个对象一个是“hello world”这个放在字符串缓冲区中的，另一个是new 方法构造出来的对象new String() 这个对象，新对象中保存的是“hello world”对象罢了，这个对象是放在堆内存中，而b 指向这个new String ()对象，这显然是不同的两个对象，所以他们用 “=”比较的结果为false。
 
如果用equals()方法比较，这结果为true，因为equals()方法比较的是对象的内容，它们的内容都为“hello world”。
 
另外值得提醒的是，字符串缓冲区中对相同的字符串只会存一次。假如我们同时写了String a ="hello world"；String b = new String("hello world");那么字符串缓冲区实际只有一个hello world 字符串，在给b赋值时，会先检查字符串缓冲区中是否有“hello world”这个字符串，如果有则不创建，直接new String()，然后赋值，因此这种情况下，表达式String b= new String ("hello world")也只创建了一个对象。
 
总结：
 
栈内存：局部变量，对象的引用，基本数据类型
 
堆内存：全局变量，包装类，对象；