目录：
1.基本数据类型
2.引用数据类型
数据类型：
Java语言是一个强类型语言
1.所有变量，必须先声明类型，再使用。
2.指定类型的变量，只能装对应类型的数据。通俗来讲，什么样的瓶子装什么样的酒。
Java数据类型可分为两大类：
1.基本数据类型
共8个
4个整型（不支持小数）： byte short int long
2个浮点型（支持小数）： float double
1个字符型 ： char
1个 boolean 型 ： boolean（只支持两个值：true 或者 false）
四个整数（不支持小数）：
byte： 一个字节。 1 byte =8 bit （每个 bit 相当于一个硬币，有两个状态） -128~127 256
short：两个字节。 -32768~32767 65536
int： 四个字节。 -2G~2G-1
long： 八个字节。 -2^63~2^63-1
整数Test程序 及 运行结果：
public class 整数Test
{
public static void main(String[] args)
{
int a;
a = 456;
int b;
b = a;
System.out.println("~~~~" + a);
System.out.println("~~~~" + b);
byte bb = (byte)345;
System.out.println("~~~~" + bb); //溢出
byte b2 = (byte)385;
System.out.println("~~~~" + b2); //溢出 补码
}
}
2个浮点数（支持小数）：
A.浮点数有两种表现形式：
1.10进制形式： 5.12 .512（没有整数部分 0 可以省略）
2.科学记数法： .12e4
B.浮点数默认是 double 类型
如果想使用一个 float 型的浮点数，应该在浮点数后添加 F 或 f。
推荐使用 double 型的浮点数。
C.浮点数有三个特殊值：
正无穷大：用正浮点数除以 0 就是正无穷大。所有正无穷大都相等。（Double.POSITIVE_INFINITY）
负无穷大：用负浮点数除以 0 就是负无穷大。所有负无穷大都相等。 （Double.NEGATIVE_INFINITY）
非数： 用 0.0 除以 0 就是非数。 非数与自己不相等。 （Double.NaN）
浮点数Test程序 及 运行结果：
public class 浮点数Test
{
public static void main(String[] args)
{
double b = .512;
System.out.println(b);
double bb = .12e4;
System.out.println(bb);
float f = 1.12f;// 0.12 默认是double 类型
double max1 = 0.5/0.0;
double max2 = 6666666/0.0;
System.out.println(max1 == max2);
double max3 = -0.5/0.0;
double max4 = -666666/0.0;
System.out.println(max3 == max4);
double nan1 = 0.0/0.0;
double nan2 = 0.0/0.0;
System.out.println(nan1 == nan2);
}
1个字符型：char
A. 每个字符型的变量只能装一个字符，既可是英文的，也可是中文的。而且用单引号包起来。
B.字符型的值有 3 种表示方式：
1. ‘a’ ， ‘中’
2. 转义字符： ‘\n’ 换行 将当前位置移到下一行开头
\r 回车 将当前位置移到本行开头
\t 横向跳格 水平制表(HT) （跳到下一个TAB位置）
\b 退格 将当前位置移到前一列
\f 换页(FF)，将当前位置移到下页开头
\" 代表一个双引号字符
\' 代表一个单引号（撇号）字符
\\ 代表一个反斜线字符''\'
3. 直接用 Unicode 的形式来表示。
C. 每个字符占 2 个字节（16位），一共有 65536 种状态，相当于可表示 65536 个字符。
整个 Java 一共也就是支持 65536 个字符。
字符型的变量，直接可作为“正整数”使用，最高位依然是数值位。0~65535。
字符型Test程序 及 运行结果：
public class 字符型Test
{
public static void main(String[] args)
{
char c = 'a';
char c2 = '国';
char rr = '\r'; //相当于13
char nn = '\n'; //相当于10
System.out.println((int)rr);
System.out.println((int)nn);
System.out.println(rr + nn);
System.out.println("------------");
//System.out.println(rr + "" +nn);
System.out.println(rr);
System.out.println(nn);
System.out.println("============");
System.out.println("******");
char bb = '\b'; //相当于键盘上的 backspace
System.out.println(bb);
System.out.println(bb);
System.out.println(bb);
System.out.println(bb);
System.out.println(bb);
char achar = 'a'; //数值是97
System.out.println((int)achar);
char Achar = 'A'; //65
System.out.println((int)Achar);
char zerochar = '0'; //数值是48
System.out.println((int)zerochar);
// 一个字符占 16 bit，因此可写成 4 位的 16 进制
char ca = '\u0042'; // 66 必须是 \u (unicode形式)
System.out.println(ca);
}
}
练习：简单随机“验证码” 程序 及 运行结果：
// 生成一个六位、随机大写字母
import java.util.*;
public class RandomStr
{
public static void main(String[] args)
{
// 控制代码循环 6 次
for(int i = 0;i < 6;i++)
{
Random rand = new Random();// 创建一个随即对象
int randNum = rand.nextInt(25);// 生成一个 0~25 之间的随机数
System.out.print((char)(randNum + 65));// 得到 65~65+25 之间的数值
}
}
}
/****************************************
补充1：TB 之上 接着就是拍字节(PB)、艾字节(EB)、泽它字节(ZB，又称为皆字节)、尧它字节(YB)、最大是千亿亿亿字节（BB）、最小是比特（b，又称为位）。
补充2：整数有如下 4 种表示形式
10 进制整数： 默认就是
16 进制整数： 0x 0开头，0~9 abcdef
8 进制整数： 以 0 开头，0~7
2 进制整数： 以 0b 开头，0~1
当我们直接使用一个整数时，整数默认是 int 类型。
如果想使用一个 long 型的整数，应该在整数后添加 L 或 l。
补充:3：关于整数的存储：
1. 最高位是符号位。
最高位是 0 代表正数，最高位是 1 代表负数
2.所有数值在计算里都以补码形式保存的。
原码： 直接换算出的二进制码
反码： 除符号位不变之外，其他位都取反。
补码： 负数补码 = 反码 +1；正数补码 = 原码。
补码的设计目的是:
⑴使符号位能与有效值部分一起参加运算,从而简化运算规则.
⑵使减法运算转换为加法运算,进一步简化计算机中运算器的线路设计
******************************/
基本数据类型的类型转换：
1.Java 是强类型的语言。
A. 所有变量，必须先声明，后使用。
B. 指定类型的变量，只能装相应类型的值
8 个基本类型，7个数值型 + 1个boolean型
7 个数值型 （4 个整型、2 个浮点型、 char 可当成正整数型）
Java 的类型转换可分为两种：
1. 自动类型转换：
表数范围小的，可以自动转换表数范围大的。
直接写一个整数，默认是 int 型，但如果它的范围在 byte、short 表数范围之内，而且程序直接将该值赋给 byte、short 类型的变量，系统会自动把它当成 byte、short 用
1.所有数值型，都可以自动转换为 double 类型。
2.所有数值型，除了 double 之外，都可以自动转换为 float 型
3.所有整型都可以自动转换为 long 型
2.强制类型转换
当我们要把表数范围大的变量或值，转为表数范围小的，就需要使用强制转换。
语法格式： （类型）
强转是可能丢失精度的。
强制类型转换 （溢出的计算）程序 及 运行结果：
public class 强制转换
{
public static void main(String[] args)
{
double d = 34;// 34默认是 int 型，int 型可以自动转换 double ，因此是对的
float ff = 12;// 12默认是 int 型，int 型可以自动转换 float
float fo = '\u0078';// '\u0078'是 char 型，char 可以自动转换 float 型
double dd = '\r';// '\r'是 char 型，char 可以自动转换 double 型
int iVal = 'A';// 'A'是 char 型，char 型可自动转换成 int 型
float ft = (float)d;// 由于 d 是 double 型，double 不能自动转换为float
// 因此需要进行强转
double de = fo;// 由于 fo 是 float 型，float 型可以自动转换为 double
char cr = (char)dd;// 由于 dd 是 double 型，double 型不能自动转换为 char
// 因此需要强转
//强转是可能丢失精度的。
short st = (short)33330;// 33330默认是 int 型，int 不能自动转换为 short （ -32768~32767）。因此强转
System.out.println(st);
byte bb = 12;// 12 默认 int，但由于 12 在byte内，系统会自动把它当成byte
int it = -3;
byte bt = (byte)it;// it 是 int 型，不能自动转换为byte，因此强转
System.out.println(bt);
}
}
3.表达式类型的自动提升
规则：整个表达式的数据类型，与表达式中最高等级的运算数的类型相同。
自动提升程序 及 运行结果：
public class 自动提升
{
public static void main(String[] args)
{
byte bt = 2; // 2 是 int 型。
// 由于2在 byte 范围，而是直接赋整数值
// 系统会自动将它当成 byte 处理。
bt = bt + 1; // 错误的 正确应该为：bt = (byte)(bt + 1)
// 1 默认是 int 型
// 整个表达式的类型与 1 的类型相同，因此表达式的类型就提升成了 int 型
int a = 5;
a = (int)((a + 20) / 2.5); // 2.5 是 double 型
System.out.println(a);
int it = 10;
it = it / 4; // it 是 int，4也是int，整个表达式依然是 int 型。
System.out.println(it);
it = 10;
double du = it / 4; // it是int，4也是int，整个表达式依然是 int 型。
System.out.println(du);
}
}
直接量：
直接在源代码中指定的值，就是直接量。
8 个基本数据类型，都可以指定直接量。
boolean 类型，只有两个直接变量：true，false
null 直接量，只能赋值给引用变量。null 直接量不能赋值给基本类型的变量。
2.引用数据类型
类，接口，数组
以上，未完
写在最后：
今早终于把东西搬过来了，总算是为自己可能三个月的实习找到了一个窝！！！昨天坐一号线地铁去大望路找女票，地铁的一幕引发了我的思考，一对小夫妻带着大概几个月的娃，孩子哭哭啼啼，孩子的父亲并没有多大耐心，只有母亲去安慰孩子……或许再过几年，我也要为人父，本来是觉得这件事距离我很远的啊，再看看公司的前辈，也有很多已经结婚了。北京这个地方，确实很迷人，扎根北京的想法我也不知道想过没，总之作为女票口中第一代进京的我们来说，是有些难吧，可能终将有一天，我也会变成房奴吧，哈哈。但是不管怎么说，还是要抓住眼下，世界会残酷的淘汰掉不会改变的人(昨地铁上看到的一句话)，来，干了这碗驴杂汤！
