JavaSE从零学起3. JAVA数据类型：引用数据类型、内置数据类型、基本数据类型扩展、自动类型转换、强制类型转换

JAVA数据类型

强类型语言与弱类型语言

Java是一门强类型语言。变量的使用要严格符合规定。所有的变量都必须先定义后才能使用。

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(a);
    }
}

运行上述代码会报错：java: 找不到符号 符号: 变量 a 位置: 类 basicalinstruction.Demo01

因为我们并没有在使用变量a之前对它下定义。

• 强类型语言
  强类型语言是一种强制类型定义的语言，一旦某一个变量被定义类型，如果不经过强制转换，则它永远就是该数据类型了，强类型语言包括Java、C#、Python、C++等语言。

​ Eg：定义了一个整数，如果不进行强制的类型转换，则不可以将该整数转化为字符串。

• 弱类型语言

弱类型语言是一种弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过显性强制转换。弱类型语言包括vb 、PHP、javascript等语言。

Eg：

 int a = 5;
 String b = "5";
 c = a + b;
 d = a - b；
 输出c的答案不是10，而是55，再次是将a的类型转化为了字符串，然后进行拼接。输出d的答案是0，是将b的类型转化为了数字，然后进行减法。  

• 强类型语言和弱类型语言区别
  强类型语言与弱类型语言间判别的根本是是否会隐性的进行语言类型转变。强类型语言在速度上略逊于弱类型语言，但是强类型定义语言带来的严谨性又能避免不必要的错误,毕竟鱼和熊掌不可兼得。

  使用哪种语言还是要按需而定。编写简单小应用，使用弱类型语言可节省很多代码量，有更高的开发效率。而对于构建大型项目，使用强类型语言可能会比使用弱类型更加规范可靠。

数据类型

Java数据类型分为内置数据类型和引用数据类型。

引用数据类型

---

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

• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。

介绍内置数据类型之前，我们先来了解位（bit）和字节(Byte).

字节与位

• 什么是位（bit）:是计算机***内部数据***存储的*最小单位。1100是一个四位二进制数。
• 字节（byte）:是计算机中 数据处理 的基本单位，习惯用B来表示
• 1B = 8 bits
• 1KB = 1024B
• 1MB = 1024KB
• 1GB = 1024MB

电脑的32位和64位到底什么意思？

1. 32位和64位意思是处理器一次能处理的最大位数；

2. 32位系统的最大寻址空间是2的32次方=4294967296(bit)= 4(GB)左右；

3. 64位系统的最大寻址空间为2的64次方=4294967296(bit)的32次方，数值大于1亿GB。

4. 32位的CPU只能安装32位系统,64位的CPU既可以安装32位系统也可以安装64位系统。

内置数据类型

---

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

在IDEA中可以按住"Ctrl"点击相应的包装类名查看详情，不需要强制记忆每种数据类型的范围。

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128（-2^7）
最大值：Byte.MAX_VALUE=127 (2^7-1)
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
Example：byte a = 100，byte b = -50。

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768（-2^15）
最大值：Short.MAX_VALUE=32767(2^15-1)
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
Example：short s = 1000，short r = -20000。

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648（-2^31）
最大值：Integer.MAX_VALUE=2147483647（2^31-1）
一般地整型变量默认为 int 类型；
Example：int a = 100000, int b = -200000

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808（-2^63）
最大值：Long.MAX_VALUE=9223372036854775807 （2^63-1）
Example：long a = 100000L，Long b = -200000L。(long型值后面必须加'L')
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
Example: float f1 = 234.5f。(float型值后面必须加'f')

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

基本类型：boolean 
boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535
char 数据类型可以储存任何字符；
例子：char letter = 'A';

Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。

实际上，JAVA中还存在另外一种基本类型 void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

基本数据类型扩展

整型表示方法：

二进制（binary）：0

十进制（decimal）：自然数

八进制（octal）：0b

十六进制（hexadecimal）：0x

int a = 0b1 /* 二进制*/
int b = 10 /* 十进制*/
int c = 011 /* 八进制*/      
int d = 0x1F /* 十六进制：1~9 A~F表示10~15 */

    输出结果：
    1
    10
    9（1*8^0 + 1* 8^1 =9）
    31(15*16^0 + 1*16^1 =31)   

浮点数比较：

float x = 0.1f;
double y =1.0/10d;

System.out.println(x);
System.out.println(y);
System.out.println(x==y);

    输出结果：
    0.1
    0.1
    false

原因：float和double类型主要是为了科学计算和工程计算而设计的。他们执行二进制浮点运算，这是为了在广泛的数字范围上提供较为精确的快速近似计算而精心设计的。然而，它们并没有提供完全精确的结果，所以我们不应该用于精确计算的场合。浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。往往产生误差不是因为数的大小，而是因为数的精度。因此，产生的结果接近但不等于想要的结果。例如，在经过大量计算后，一个浮点型的数3.14在计算机中可能就存储成3.140000000001，也有可能存储为3.1499999999999，这种情况下会对比较操作带来极大的干扰。

char a = 'C';
char b = '牛';
System.out.println(a);
System.out.println(b);
System.out.println((int)(a));//此处把char类型强制转换成int类型进行输出
System.out.println((int)(b));
   
   输出结果：
   C
   牛
   67
   29275

由输出结果可知，

字符本质上还是数字

原理是Unicode编码机制（例如"a"的Unicode编码是0061）：

char c1 = '\u0061';
char c2 = '\u0079';//"\u"表示Unicode编码
System.out.println(a);
System.out.println(b);
    输出结果：
    a
    y

java常用转义字符：

符号	字符含义
\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x0)
\s	空格 (0x20)
\t	制表符
"	双引号
’	单引号
\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

System.out.println("I am a coder!I like coding!");

System.out.println("I am a coder!\tI like coding!");

System.out.println("I am a coder!\nI like coding!");

输出结果：
I am a coder!I like coding!

I am a coder!	I like coding!

I am a coder!
I like coding!

boolean值扩展

boolean flag = true;if(flag==true){} //新手写的代码
if(flag){} //老手写的代码  
二者等价；

类型转换

---

Java是强类型语言，所以有时进行运算的时候要用到类型转换。

自动类型转换

低---------->高byte,short,char-->int-->long-->float-->double

当数据类型所占字节由低到高转换时,属于自动类型转换。

//将int类型的m赋值给浮点型的nSystem.out.println(m);System.out.println(n);输出
int m = 500;float n = m;

输出结果：   
500    500.0

强制类型转换

当数据类型所占字节由高到低转换时,需要用到强制类型转换。

(类型)变量名；  //高—————>低

int a= 127;byte b = (byte)a;//把int类型强制转换成byte类型，由高到低
int c= 128;byte d =(byte)c; 
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);

输出结果：
127    127    128   -128//c与d输出结果不同是因为溢出，byte范围是-128~127

注意点

1. 不能对布尔值进行转换

int a= 127;boolean b = a;

输出结果：    
java: 不兼容的类型: int无法转换为boolean

2. 不能把对象转换成不相干的类型
3. 把高容量转换到低容量的时候，要强制转换
4. 转换的时候可能存在内存溢出或者精度问题！

精度问题：
System.out.println((int)54.9f);
System.out.println((int)39.2d);

输出结果：
5439

计算时的内存溢出问题：
int a = 1000000;
int b = 2000000;
int c = a*b;
System.out.println(a);
System.out.println(b);
System.out.println(c);

输出结果：
1000000200000000-1454759936

输出结果如上是因为c的值已经大于int的最大范围。
为了解决上述问题，我们可以将int转为更大容量的long计算。

int a = 1000000;
int b = 200000000;
long c = a*b;
System.out.println(c);

输出结果：    
-1454759936

依然报错，因为long c = int * int是在a*b两个int值计算完成以后才将计算结果转换为long的。在转换之前已经溢出。
所以，我们应该按照如下写法：

int a = 100_0000;//JDK7新特性：数字内部可以用下划线分隔
int b = 2_0000_0000;//JDK7新特性：数字内部可以用下划线分隔
long c = a*（long）b;
System.out.println(c);

输出结果：    
200000000000000