Java语言提供了八种基本类型。六种数字类型（四个整数型（默认是int 型），两个浮点型（默认是double 型）），一种字符类型，还有一种布尔型。
1.基本数据类型
byte：
byte数据类型是8位、有符号的，以二进制补码表示的整数；（256个数字），占1字节
最小值是-128（-2^7）；
最大值是127（2^7-1）；
默认值是0；
byte类型用在大型数组中节约空间，主要代替整数，因为byte变量占用的空间只有int类型的四分之一；
例子：byte a = 100，byte b = -50。
short：
short数据类型是16位、有符号的以二进制补码表示的整数，占2字节
最小值是-32768（-2^15）；
最大值是32767（2^15 - 1）；
Short数据类型也可以像byte那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是0；
例子：short s = 1000，short r = -20000。
int：
int数据类型是32位、有符号的以二进制补码表示的整数；占4字节
最小值是-2,147,483,648（-2^31）；
最大值是2,147,485,647（2^31 - 1）；
一般地整型变量默认为int类型；
默认值是0；
例子：int a = 100000, int b = -200000。
long：
long数据类型是64位、有符号的以二进制补码表示的整数；占8字节
最小值是-9,223,372,036,854,775,808（-2^63）；
最大值是9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是0L；
例子： long a = 100000L，int b = -200000L。
long a=111111111111111111111111(错误，整数型变量默认是int型)
long a=111111111111111111111111L(正确，强制转换)
float：
float数据类型是单精度、32位、符合IEEE 754标准的浮点数；占4字节 -3.4*E38- 3.4*E38。。。浮点数是有舍入误差的
float在储存大型浮点数组的时候可节省内存空间；
默认值是0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。
float f=6.26(错误 浮点数默认类型是double类型)
float f=6.26F（转换正确，强制）
double d=4.55(正确)
double：
double数据类型是双精度、64位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是0.0d；
例子：double d1 = 123.4。
boolean：
boolean数据类型表示一位的信息；
只有两个取值：true和false；
这种类型只作为一种标志来记录true/false情况；
默认值是false；
例子：boolean one = true。
char：
char类型是一个单一的16位Unicode字符；用 ‘’表示一个字符。。java 内部使用Unicode字符集。。他有一些转义字符 ，2字节
最小值是’\u0000’（即为0）；
最大值是’\uffff’（即为65,535）；可以当整数来用，它的每一个字符都对应一个数字
2. 数据类型之间的转换
1).简单类型数据间的转换,有两种方式:自动转换和强制转换,通常发生在表达式中或方法的参数传递时。
自动转换
具体地讲,当一个较"小"数据与一个较"大"的数据一起运算时,系统将自动将"小"数据转换成"大"数据,再进行运算。而在方法调用时,实际参数较"小",而被调用的方法的形式参数数据又较"大"时(若有匹配的,当然会直接调用匹配的方法),系统也将自动将"小"数据转换成"大"数据,再进行方法的调用,自然,对于多个同名的重载方法,会转换成最"接近"的"大"数据并进行调用。这些类型由"小"到"大"分别为 (byte，short，char)--int--long--float—double。这里我们所说的"大"与"小",并不是指占用字节的多少,而是指表示值的范围的大小。
①下面的语句可以在Java中直接通过：
byte b;int i=b; long l=b; float f=b; double d=b;
②如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如
char c='c'; int i=c;
System.out.println("output:"+i);输出：output:99;
③对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。
short i=99 ; char c=(char)i; System.out.println("output:"+c);输出：output:c;
强制转换
将"大"数据转换为"小"数据时，你可以使用强制类型转换。即你必须采用下面这种语句格式： int n=(int)3.14159/2;可以想象，这种转换肯定可能会导致溢出或精度的下降。
2)表达式的数据类型自动提升, 关于类型的自动提升，注意下面的规则。
①所有的byte,short,char型的值将被提升为int型；
②如果有一个操作数是long型，计算结果是long型；
③如果有一个操作数是float型，计算结果是float型；
④如果有一个操作数是double型，计算结果是double型；
例， byte b; b=3; b=(byte)(b*3);//必须声明byte。
3)包装类过渡类型转换
一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。例如：
①当希望把float型转换为double型时：
float f1=100.00f;
Float F1=new Float(f1);
double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法
②当希望把double型转换为int型时：
double d1=100.00;
Double D1=new Double(d1);
int i1=D1.intValue();
简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)
而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。
4)字符串与其它类型间的转换
其它类型向字符串的转换
①调用类的串转换方法:X.toString();
②自动转换:X+"";
③使用String的方法:String.volueOf(X);
字符串作为值,向其它类型的转换
①先转换成相应的封装器实例,再调用对应的方法转换成其它类型
例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。也可以用:Double.valueOf("32.1").doubleValue()
②静态parseXXX方法
String s = "1";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );
③Character的getNumericValue(char ch)方法
5）Date类与其它数据类型的相互转换
整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：
①Date(int year, int month, int date)：以int型表示年、月、日
②Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分
③Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒
在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)。
获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。
而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。
有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，首先在文件开始引入，
import java.text.SimpleDateFormat;
import java.util.*;
java.util.Date date = new java.util.Date();
//如果希望得到YYYYMMDD的格式
SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");
String dateFormat=sy1.format(date);
//如果希望分开得到年，月，日
SimpleDateFormat sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);
总结：只有boolean不参与数据类型的转换
（1）.自动类型的转换：a.常数在表数范围内是能够自动类型转换的
b.数据范围小的能够自动数据类型大的转换（注意特例）
int到float，long到float，long到double 是不会自动转换的，不然将会丢失精度
c.引用类型能够自动转换为父类的
d.基本类型和它们包装类型是能够互相转换的
（2）.强制类型转换：用圆括号括起来目标类型，置于变量前
3.Java引用类型
Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注
引用类型：底层结构和基本类型差别较大
JVM的内存空间：（1）. Heap 堆空间：分配对象 new Student（）
（2）. Stack 栈空间：临时变量 Student stu
（3）.Code 代码区 ：类的定义，静态资源 Student.class
eg：Student stu = new Student（）； //new 在内存的堆空间创建对象
stu.study(); //把对象的地址赋给stu引用变量
上例实现步骤：a.JVM加载Student.class 到Code区
b.new Student()在堆空间分配空间并创建一个Student实例
c.将此实例的地址赋值给引用stu， 栈空间
4.负数的二进制表示法
一：表示法：
假设有一个 int 类型的数，值为5，那么，我们知道它在计算机中表示为：
00000000 00000000 00000000 00000101
5转换成二制是101，不过int类型的数占用4字节（32位），所以前面填了一堆0。
现在想知道，-5在计算机中如何表示？在计算机中，负数以原码的补码形式表达。
一个正数，按照绝对值大小转换成的二进制数；一个负数按照绝对值大小转换成的二进制数，然后最高位补1，称为原码。
比如 00000000 00000000 00000000 00000101 是 5的 原码。
10000000 00000000 00000000 00000101 是 -5的 原码。
备注：
比如byte类型,用2^8来表示无符号整数的话,是0 - 255了；如果有符号， 最高位表示符号,0为正,1为负,那么,正常的理解就是 -127 至 +127 了.这就是原码了,值得一提的是,原码的弱点,有2个0,即+0和-0（10000000和00000000）；还有就是,进行异号相加或同号相减时,比较笨蛋,先要判断2个数的绝对值大小,然后进行加减操作,最后运算结果的符号还要与大的符号相同；于是,反码产生了。
正数的反码与原码相同，负数的反码为对该数的原码除符号位外各位取反[每一位取反(除符号位)]。
取反操作指：原为1，得0；原为0，得1。（1变0; 0变1）
比如：正数00000000 00000000 00000000 00000101 的反码还是 00000000 00000000 00000000 00000101
负数10000000 00000000 00000000 00000101 的反码则是 11111111 11111111 11111111 11111010。
反码是相互的，所以也可称：10000000 00000000 00000000 00000101 和 11111111 11111111 11111111 11111010互为反码。
备注：还是有+0和-0,没过多久，反码就成为了过滤产物,也就是,后来补码出现了。
正数的补码与原码相同，负数的补码为对该数的原码除符号位外各位取反，然后在最后一位加1.
比如：10000000 00000000 00000000 00000101 的补码是：11111111 11111111 11111111 11111010。
那么，补码为：
11111111 11111111 11111111 11111010 + 1 = 11111111 11111111 11111111 11111011
备注：1、从补码求原码的方法跟原码求补码是一样的 ，也可以通过完全逆运算来做，先减一，再取反。
2、补码却规定0没有正负之分
所以，-5 在计算机中表达为：11111111 11111111 11111111 11111011。转换为十六进制：0xFFFFFFFB。
5.位运算
原文：https://blog.csdn.net/xiaochunyong/article/details/7748713
1、左移( << )
Test1、将5左移2位：
public class Test {
public static void main(String[] args) {
System.out.println(5<<2);//运行结果是20
}
}
运行结果是20，但是程序是怎样执行的呢？
首先会将5转为2进制表示形式(java中，整数默认就是int类型,也就是32位):
0000 0000 0000 0000 0000 0000 0000 0101 然后左移2位后，低位补0：
0000 0000 0000 0000 0000 0000 0001 0100 换算成10进制为20
2、右移( >> ) ，右移同理，只是方向不一样罢了(感觉和没说一样)
System.out.println(5>>2);//运行结果是1
还是先将5转为2进制表示形式：
0000 0000 0000 0000 0000 0000 0000 0101 然后右移2位，高位补0：
0000 0000 0000 0000 0000 0000 0000 0001
3、无符号右移( >>> )
我们知道在Java中int类型占32位，可以表示一个正数，也可以表示一个负数。正数换算成二进制后的最高位为0，负数的二进制最高为为1
例如 -5换算成二进制后为：
1111 1111 1111 1111 1111 1111 1111 1011 (刚开始接触二进制时，不知道最高位是用来表示正负之分的，当时就总想不通。。明明算起来得到的就是一个正数-_-)
我们分别对5进行右移3位、 -5进行右移3位和无符号右移3位：
public class Test {
public static void main(String[] args) {
System.out.println(5>>3);//结果是0
System.out.println(-5>>3);//结果是-1
System.out.println(-5>>>3);//结果是536870911
}
}
我们来看看它的移位过程(可以通过其结果换算成二进制进行对比)：
5换算成二进制： 0000 0000 0000 0000 0000 0000 0000 0101
5右移3位后结果为0，0的二进制为： 0000 0000 0000 0000 0000 0000 0000 0000 // (用0进行补位)
-5换算成二进制： 1111 1111 1111 1111 1111 1111 1111 1011
-5右移3位后结果为-1，-1的二进制为： 1111 1111 1111 1111 1111 1111 1111 1111 // (用1进行补位)
-5无符号右移3位后的结果 536870911 换算成二进制： 0001 1111 1111 1111 1111 1111 1111 1111 // (用0进行补位)
通过其结果转换成二进制后，我们可以发现，正数右移，高位用0补，负数右移，高位用1补，当负数使用无符号右移时，用0进行部位(自然而然的，就由负数变成了正数了)
注意：笔者在这里说的是右移，高位补位的情况。正数或者负数左移，低位都是用0补。(自行测试)
4、位与( & )
public class Test {
public static void main(String[] args) {
System.out.println(5 & 3);//结果为1
}
}
还是老套路，将2个操作数和结果都转换为二进制进行比较：
5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101
3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011
-------------------------------------------------------------------------------------
1转换为二进制：0000 0000 0000 0000 0000 0000 0000 0001
位与：第一个操作数的的第n位于第二个操作数的第n位如果都是1，那么结果的第n为也为1，否则为0
5、位或( | )
public class Test {
public static void main(String[] args) {
System.out.println(5 | 3);//结果为7
}
}
5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101
3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011
-------------------------------------------------------------------------------------
7转换为二进制：0000 0000 0000 0000 0000 0000 0000 0111
位或操作：第一个操作数的的第n位于第二个操作数的第n位 只要有一个是1，那么结果的第n为也为1，否则为0
6、位异或( ^ )
package com.xcy;
public class Test {
public static void main(String[] args) {
System.out.println(5 ^ 3);//结果为6
}
}
5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101
3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011
-------------------------------------------------------------------------------------
6转换为二进制：0000 0000 0000 0000 0000 0000 0000 0110
位异或：第一个操作数的的第n位于第二个操作数的第n位 相反，那么结果的第n为也为1，否则为0
7、位非( ~ ) 位非是一元操作符
package com.xcy;
public class Test {
public static void main(String[] args) {
System.out.println(~5);//结果为-6
}
}
5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101
-------------------------------------------------------------------------------------
-6转换为二进制：1111 1111 1111 1111 1111 1111 1111 1010
位非：操作数的第n位为1，那么结果的第n位为0，反之。
由位运算操作符衍生而来的有：
&= 按位与赋值
|= 按位或赋值
^= 按位非赋值
>>= 右移赋值
>>>= 无符号右移赋值
<<= 赋值左移
和 += 一个概念而已。
举个例子：
package com.xcy;
public class Test {
public static void main(String[] args) {
int a = 5
a &= 3;
System.out.println(a);//结果是1
}
}
--------------------
