Java 变量之变量数据类型

Java数据类型图： 





1.基本数据类型

　　基本数据类型，也称内置类型，是可以在栈直接分配内存的，Java保留基本数据类型最大的原因也在此：性能。关于这一点可以参考：Java为什么需要保留基本数据类型。 

　　另外，要注意，Java是基于JVM的，所以，其所占字节固定，与机器平台无关，所有地方统一占用内存大小（除了boolean，以及byte/short/boolean数组的时候每个单元所占的内存是由各个JVM自己实现的）。 

　　总共有四类八种基本数据类型（注1）： 

1).整型：全部是有符号类型。 

1.byte：1字节（8bit），高位为符号位，其余7位为数据位，范围：-2的7次方~2的7次方-1（1111,1111~0111,1111），即-128~127（下面的计算方式相同）；



注意：byte类型虽然在语义（逻辑）上是占用1字节，但实际上，JVM中是将其当做int看
的，也就是事实上是占用了32位，4字节的，所以其运算效率和int没区别，short也一样。
之所以要有byte/short类型，一是因为某些地方要明确使用这些范围类型，二是，
在byte[]数组中，JVM存储的则是真的1字节，short[]2字节。（但也有的JVM其byte[]
数组也是4字节1位）

2.short：2字节（16bit），高位为符号位，其余15位为数据位，范围：-2的15次方~2的15次方-1，即-32768~32767；

3.int：4字节（32bit），范围-2的31次方~2的31次方-1；Java默认的整型类型，即：



long l = 0xfffffffffff;//0x表示这个数是16进制数，0表示8进制。
//编译器报错，因为右边默认是int，但其超出了范围（没超出int范围的话
//编译器会隐式将int转为long），故报错（同样的错误也会出现在float）。

同样的还有：



short s = 123;//（这个123也是int类型，这里，= 操作编译器能隐式转换） 
s = s + 123;//编译器报错，那是因为s+1是int类型（编译器先将s转化为int，再+1），
//这里，+ 操作编译器不能隐式转换（会提示失真，即精度可能会受损），正确的做法：
s = (short)(s + 123)//注意，不是(short)s + 123。

类型转化详见：Java 数据类型转化。 

4.long：8字节（64bit），范围：-2的63次方~2的63次方-1；声明大的long方法：



long l = 0xfffffffffffL;//即在后面加上L或l。
//（强制转化：long l = (long)0xfffffffffff也没用）

2).浮点型 

5.float：4字节（32bit），单精度，数据范围：(-2^128)~(-2^(-23-126))-(0)-(2^-149)~2^128。浮点数，通俗来说就是小数，但是，这是有精度要求的，即在这区间float可不是能表达任意小数的，而是在一定精度下，比如float有效位7~8位（包括整数位和小数位，有效小数位是6~7位，这里为什么是7~8（6~7），参考：Java中float/double取值范围与精度），即0.123456789后面的9JVM是不认识的（8能认识，整数位为0则不算是有效位，例如12.1234567后面的7也不认识，只有6位有效小数位（注意，看的是有效位，不是有效小数位，float有7~8位有效位）），即：



if(0.123456781f == 0.123456789f){//注意后面加f/F，否则就是double
    System.out.println("true");
}else{
    System.out.println("false");
}
//打印结果：true
//事实上，浮点数值的比较是不能直接用==判断的，这里原因就要追究到浮点数的内存结构
//浮点数比较可以用一个差值，但这种情况只是近似的比较
//如果想要精确，可以使用BigDecimal
System.out.println(Float.MIN_VALUE);//1.4E-45 = 2^-149
//这里的“最小值”意味float能表示的最小小数，实际上float最小值等于最大值取负
System.out.println(Float.MAX_VALUE);//3.4028235E38 = 2^128

6.double：8字节（64bit），双精度，范围：-2^1024~(-2^(-1022-52))-0-(2^－1074)~2^1024，Java默认的浮点类型，即若后面不加f/F，默认是double类型，即：



float f = 1.23;//编译报错，因为
float f = 1.23f;//或float f = 1.23F;
//默认是double，1.23(double)转成float，做隐式转换，但是double转成float是
//取值范围大的转成取值范围小的会损失精度，因此不能转换（详见Java数据类型转换）
//那为什么，int可以转换成byte、short，int范围更大不是？
//前面已经说过了，byte、short实际在JVM上就是int，因此编译器是不会认为会损失精度的
//但是int是不能转换成boolean，虽然boolean也是4字节（一般JVM），但在JVM认为这
//两者完全是两个东西，当然不能转换（强制也不行，你不能把猫强制转换成鸟，完全两个物种），而byte、short都是整型，同int是一个类型

3).字符型 

7.char：2字节（16bit），表示一个字符（可以是汉字），字符编码采用Unicode（说的更准确点，字符集（charset）采用UCS-2，编码（encoding）采用UTF-16），实际上就是一个16位的无符号整型，但是，要注意的是，因为随着发展，char所能代表的字符个数（UCS-2字符集）被限定死了，所以并不推荐使用。（更多内容，以及关于Unicode、UTF8/16参考：Unicode、UTF8以及Java char。）



char c = 3+5;//正确，char是无符号整型，但不能这样
int a1 = 3;int a2 = 5;char c0 = a1+a2;//这里需要强制转换才行
char c1 = -3;//编译错误，char不能表示负数，即使
char c2 = (char)-3;//编译正确，但无意义（乱码）
char c3 = '3';//正确，输出字符3
char c4 = "3";//编译错误，双引号，表示的是字符串
char c5 = '65';//编译错误，这里65是两个字符

4).布尔型 

8.boolean：逻辑上：1bit，但是实际上，boolean并没有具体规定，完全是看各个JVM实现，不过《Java虚拟机规范》给出了4个字节（同byte解释）和boolean数组一个字节的定义。

注1： 

(1).这种分法是一种比较流行的分法，事实上应该为两种：数值类型与布尔型。数值类型分为整型和浮点型。整型包括：byte、short、int、long、char；浮点型：float、double；布尔型boolean。之所以将char认为是整型是因为char在JVM就是以无符号整型存在的。 

(2).事实上Java中除去这8种以及对象类型，还有一种比较特殊的类型存在，那就是Void。java.lang.Void，是一个占位符类，不可实例化，保存着Java关键字void的Class对象。为什么说它特殊呢？明明是一个类，难道不是对象类型？那是因为void.class.isPrimitive()（这个方法是用来判断一个Class对象是否是基本类型的）返回的是true，所以Void也算是基本类型的一个了（错了），只不过它比较特殊，不能算是一种数据，只是一种象征。 

20160921 改：上面弄错了，把Void和void两个混为一体了，事实上，可以简单的把这两者的关系看成类似包装类和基本类型的关系，像Integer和int的关系，java.lang.Void是一个不可实例化的占位符类来保存一个引用代表了Java关键字void的Class对象：

public static final Class<Void> TYPE = Class.getPrimitiveClass("void");

而Integer也有类似的语句：



public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

区别只是，Void仅仅是为void服务，即所谓的占位符类，不做他用。所以Void类只是一个普通类，而void则可以认作为如同int一样的基本类型。

2.引用数据类型

　　也称对象变量类型，复合数据类型，包含类、接口、数组（除了基本类型外，就是引用类型）。引用类型与基本类型最大的区别在于：



int a = 5;//这里的a是对象（严格来说不算是对象，只是个符号标识），5是数值
Integer a = 5;//这里的a是一个引用，5才是一个对象，更形象常见的是：
Object o = new Object();//o是引用（栈中），new Object()是对象（堆中）
//第二行代码中，5被自动包装成Integer对象

　　这里的引用有点像C/C ++中的指针，但是同指针不同的是，你不能通过改变它的值从而去改变它所指向的值。即



ClassA p = new ClassA();//C++中，这个时候是可以这样操作的：
p = p + 1;//向前移动一个单元，Java则不能
//这种操作，其实是对内存直接的操作，很显然，Java是不允许程序员做这种操作的

　　其实质就是，Java的引用不支持对内存直接操作，而指针则可以，所以，Java用起来更安全，但不够灵活，而指针，自由度大，但同时，要更加小心因为指针操作不当而引起的各种内存问题。在Java中，任何对象都需要通过引用才能访问到，没有引用指向的对象被视为垃圾对象，将会被回收。 

　　引用，其实质同指针一样（可以理解为受限制的指针），存放的是一个地址，至于是实例对象的地址，还是一个指向句柄池的地址（这里可以参考：(3) Java内存结构），完全是看各个JVM的实现了。 

　　Java中的枚举类型，都是Enum类的子类，算是类中的一种，也是引用类型。 

　　引用类型又称为对象变量类型，是相对于基本数据类型来说的（基本数据类型不是对象），而又被称为复合数据类型，可以这样理解，引用类型的数据最终都是由基本数据类型构成的。而像接口，接口是不能实例化的，最终的实现还是由类实现的；数组在JVM中的实现也是通过类实现的，每个类型的一维数组，二维数组……都是一个类，只是这是一个特殊的类，它的对象头有别于一般对象的对象头（最主要的就是，数组对象头有对象长度）。 

　　另外，关于Java引用可以参考：Java中的引用。

Java变量有三部分组成，变量的数据类型，变量名（变量的标识符），变量的值；


Java变量的数据类型分为两大类，
一、是基本类型，直接包含值的类型。有boolean，byte，int，long，short，char，float，double；
boolean isFalse=false；


二、是引用类型，除了上面8个基本类型，其余都是引用类型，可以使用new关键字来创建对象。
例如包装类（Boolean，Byte，Integer，Long，Short，Character，Float，Double）、String、Object、Class、数组（如int[]、byte[]、char[]..）等等；
String strName=new String("Hello World");

 1、变量是什么呢？

 变量是一个数据存储空间的表示！变量是存储数据的一个基本单元，不同的变量是相互独立的。变量就好比旅馆中的房间，如下图：

2、数据类型。

数据类型总体来说分为2大类：一类是：数值型，如int、double 一类是：非数值型，如String、char。常见的java数据类型就是我们刚才说的4种，说明如下图：


 3、变量的声明以及使用。

定义变量有2种方式：
   1>数据类型 变量名  // 先声明一个变量
   如：String name; // 先声明一个变量
     变量名=值   //给变量赋值

     name="张三"; //给变量赋值
2>数据类型 变量名=值   //声明一个变量同时给该变量赋值

   String name="张三";   //声明一个变量同时给该变量赋值 

使用存储的变量他们称之为”变量调用“：System.out.println(name); //输出变量name存储的值
小札：使用声明的变量名就是在使用变量对应的内存空间中存储的数据。

小结：变量都必须声明和赋值后才能使用
4.java中变量的命名要符合一定的规则。

一张图直观的了解下，如下图：


从上图我们可以看出一下几点：

1、变量必须以 字母、下划线 "_"或"$"符号开头

2、变量名可以包括数字，但不能以数字开头

3、变量名不能包含，除了下划线 "_"或"$"符号以外的任何特殊字符

4、特殊情况 变量不能使用java语言的关键字，如：int、class、public等


java中变量的长度没有任何限制，但是java区分大小写 如：name和Name是两个不同的变量

小札：变量名要简短且能清楚的表达变量的作用，通常第一个单词的首字母小写，其后单词的首字母大写

如：myScore
5、运算符。
1>赋值运算符
变量名=表达式【在java里等号就是赋值运算符】
"="可以讲某个数值赋给变量，或是 某个表达式的值赋给等号左边的变量。

表达式就是符号（如加号、减号）与操作数（如b、3等）的组合。
如：int b;
int a=(b+3) * (b-1) ; 
小札：后一个语句将变量b的值取出后进行计算，然后再将计算结果存储到变量a中。
小结：“=”的功能是将等号右边表达式的结果赋值给等号左边的变量。 
2>算术运算符

所谓的 “+”     加法运算符    求操作数的和    如：5+3等于8 

 所谓的 “-”     减法运算符    求操作数的差     如：5-3等于2 
所谓的 “*”      乘法运算符    求操作数的乘积    如：5*3等于15
所谓的 “/”       除法运算符    求操作数的商      如：5/3等于1 
所谓的 “%”     取余运算符    求操作数相除的余数    如：5%3等于2 
特殊:所谓的 “<<” 左移运算符   使指定值的所有位都左移规定的次数   它的通用格式如下所示 ：value<<num 

如：value=64 num=2 【先把64转化为二进制（01000 0000）然后再移动2次变为（10000 0000）所以value最终变为256】
所谓的 “>>” 右移运算符 使指定值的所有位都右移规定的次数 它的通用格式如下所示 ：value>>num

如：value=256 num=2 【先把256转化为二进制（0001 0000 0000）然后再移动2次变为（01000 0000）所以value最终变为64】
6、数据类型转换。
一、自动数据类型转换【放大转换】
1>如果一个操作数为double类型，那么整个表达式可提升为double型。

2>满足自动类型转换的条件

  1.两种类型要兼容：数值类型（整型和浮点型） 互相兼容、
  2.目标类型大于源类型：double型可以存放int型数据,因为double类型变量分配的空间宽度足够存储int型变量。 
如：double a=34.56;int b=1;

double c=a+b;  

b的结果是35.56
 二、强制数据类型转换【缩小转换】
（数据类型） 表达式

即：在变量前加上括号，括号中的类型就是你要强制转换成的类型

如：double a=34.567

int b=(int)a;  b的结果是34

小札：自动类型转换是从宽度小的类型转换为宽度大的类型，所以称之为“放大转换”。 

强制类型转换是从宽度大的类型转换为宽度小的类型，所以称之为“缩小转换”。 

文章目录
1.Java数据类型
1.1 java的两大数据类型
1.1.1 内置数据类型
1.1.2 引用数据类型
1.1.3 基本类型对应的包装类
2.Java常量
2.1 文本常量
2.1.1  常量类型
3.Java变量
3.1声明变量的基本格式
3.2Java变量类型
3.2.1  局部变量
3.2.2  实例变量
3.3.3  类变量（静态变量）
4.Java装箱和拆箱
4.1int 和Integer比较
4.2Integer与Integer比较（牵扯缓存）

1.Java数据类型

1.1 java的两大数据类型


内置数据类型（别名：简单类型，基本类型）


引用数据类型



1.1.1 内置数据类型


Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。


简单类型（分以下两种）


数值类型（细分）
整型：byte、short、int、long 和 char
浮点型：float 和 double


布尔型：boolean






简单类型
所占字节
最小值
最大值
默认值




byte
1
-128（-2^7）
127（2^7-1）
0


short
2
-32768（-2^15）
32767（2^15 - 1）
0


char
2
\u0000（即为0）
\uffff（即为65,535）
空


int
4
（-2^31）
（2^31 - 1）
0


float
4
1.4E-45
3.4028235E38
0.0f


long
8
（-2^63）
（2^63 -1）
0L


double
8
4.9E-324
1.7976931348623157E308
0.0d


boolean
只true 和 false


false




1.1.2 引用数据类型


在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型， 量一旦声明后，类型就不能被改变了。


引用类型
分为：类类型、接口类型、数组类型、null类型


所有引用类型的默认值都是null


1.1.3 基本类型对应的包装类




基本数据类型
包装类




byte
Byte


int
Integer


short
Short


long
Long


float
Float


double
Double


boolean
Boolean


char
Character



2.Java常量
定义：常量在程序运行时是不能被修改的
在 Java 中使用 final 关键字来对局部变量声明，声明方式和变量类似：
final double DI = 3.14;

通常使用大写字母表示常量，且final修饰的常量只能被赋值一次
2.1 文本常量
代码中出现的文本形式常数，及文本常量，通常用来表示简单类型、String类型和null类型的值
2.1.1  常量类型


1.整数常量 ： 所有整数
//例如：
int int1 = 123;                   //整形常量123为int型
long long1 = 123L;                //整形常量123为long型
//等等



2.小数常量 ： 所有小数
//例如：
double d1 = 12.3;                 //双精度浮点型
double d2 = 12.3D;                //双精度浮点型
double d3 = 0.123E2;              //双精度浮点型
float f1 = 12.3f;                 //单精度浮点型
float f2 = 0.123E2f;              //单精度浮点型



3.布尔常量 ： 只有true和false
//例如：
boolean b1 = true;



4.字符常量 ：使用单引号（‘）引起来的单个字符
//例如：
char ch1 = 'A';
char ch2 = '\101';               //ASCII:65,即'A'
char ch3 = '\u0041';             //ASCII:65,即'A'



5.字符串常量 ：使用“”引起来的字符序列
String str1 = "哲"；

//字符串常量和字符常量都可以包含任何Unicode字符
//例如：
char a = '\u0001';
String a = "\u0001";




​ 6.null常量 ： 只有一个值null
//例如: 
Object obj1 = bull;  




3.Java变量
3.1声明变量的基本格式
在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：
type identifier [ = value][, identifier [= value] ...] ;

格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。
以下列出了一些变量的声明实例。注意有些包含了初始化过程。
int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 1, e = 2, f = 3; // 声明三个整数并赋予初值
byte b = 22;         // 声明并初始化 b
String s = "qzz";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char a = 'a';        // 声明变量 a 的值是字符 'a'。

3.2Java变量类型

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

//例子：

public class Variable{
    static int qzzBl=0;    // 类变量
 
    String str="hello world";  // 实例变量
 
    public void method(){
 
        int i =0;  // 局部变量
 
    }
}

3.2.1  局部变量

局部变量声明在方法、构造方法或者语句块中
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁
访问修饰符不能用于局部变量
局部变量只在声明它的方法、构造方法或者语句块中可见
局部变量是在栈上分配的
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用

//以下实例中age是一个局部变量。定义在pupAge()方法中，它的作用域就限制在这个方法中。
public class Test{ 
   public void pupAge(){
      int age = 0;//如果是 int age；  未初始化，则编译器会报错
      age = age + 7;
      System.out.println("小狗的年龄是: " + age);
   }
   
   public static void main(String[] args){
      Test test = new Test();
      test.pupAge();
   }
}

3.2.2  实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；


3.3.3  类变量（静态变量）

类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。


4.Java装箱和拆箱
Integer中的装箱的代码
public static Integer valueOf(int i){
      if(i>=IntegerCache.low && i<=IntegerCache.high){
          return IntegerCache.cache[i+(-IntegerCache.low)];
      }
    return new Integer(i);
}

基本类型自动封装到它相同类型的包装中，此过程调用valueOf方法
4.1int 和Integer比较
int 和Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较
Integer a = 10;//装箱      本质操作：Integer a = new Integer(10);
int i = a;//拆箱           本质操作：int i = new Integer (10).intValue();
System.out.println(i == a);           //ture

4.2Integer与Integer比较（牵扯缓存）
Integer与Integer比较的时候（牵扯缓存）

==  比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象
equals  用来比较的是两个对象的内容是否相等

/**需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二是当大于这个范围的时候，直接new Integer来创建Integer对象.
*/
//例子：
Integer i1 = 127;   //直接赋值的时候会进行自动的装箱
Integer i2 = 127
System.out.println(i1 == i2);           //true
System.out.println(i1.equals(i2));      //true       

//i1、i2是自动装箱产生的对象，其值都是127，127正好在-128<=i7<=127
//这个范围内的，那么会去IntegerCache中取，该对象应该是一个对象，在堆中的
//地址应该是一样的，所以在判断两个对象是不是==的时候，会输出相等。


 Integer i3 = 129;   //直接赋值的时候会进行自动的装箱
 Integer i4 = 129;
 System.out.println(i3 == i4);         //false
 System.out.println(i3.equals(i4));    //true
//i3和i4是自动装箱产生的Integer的对象，但是其大小超过了范围：-128<=A <=127，
//这里会直接自己创建该对象即：new Integer(128);显然这两个对象都是new出来，
//在堆中的地址值是不同的，所以二者不相等。

运行结果：
true
true
false
true

Process finished with exit code 0


                                                         2018.10.13/周六
                                                         by 922