大家好，这是我的学习笔记：零基础学java笔记整理：day03_java语言中的数据类型，没有华丽的辞藻，我喜欢直奔主题。
目录
一、数据类型基本知识
1.1、数据类型的作用是什么？
程序当中有很多数据，每一个数据都有相关的类型，不同数据类型的数据占用空间大小不同。
数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的空间。
1.2、java中的数据类型包括两种
* 基本数据类型
* 引用数据类型【后边讲】
- 类
- 接口
- 数组
......
1.3、基本数据类型
* 基本数据类型包括四大类八小种：
第一类：整数型
byte,short,int,long
第二类：浮点型
float,double
第三类：布尔型
boolean
第四类：字符型
char
字符串"abc"不属于基本数据类型，属于”引用数据类型“，字符属于基本数据类型：
* 字符串使用双引号"abc"
* 字符使用单引号 'a'
1.4、八种基本数据类型各自占用空间大小是多少？
| 基本数据类型 | 占用空间大小【单位：字节】 |
| byte | 1 |
| short | 2 |
| int | 4 |
| long | 8 |
| float | 4 |
| double | 8 |
| boolean | 1 |
| char | 2 |
1.5、什么是二进制？
* 数据的一种表示形式，十进制表示满足满十进一原则，二进制表示满足满二进一原则。
例如：十进制
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
例如：二进制
0 1 10 11 100 101 110 111 1000 1001 ......
0 1 2 3 4 5 6 7 8 9
* 计算机在任何情况下都只能识别二进制，例如：只认识101010101010001010101....
【现代的计算机底层采用交流电的方式，接通和断开两种状态，计算机只识别1或0，其他不认识】
1.6、字节（byte）
1 Byte = 8 bit 【1个字节 = 8 个比特位】1个比特位表示一个二进制位：1/0
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
1 TB = 1024*1024*1024*1024*8 bit
int最常用
1.7、byte类型的取值范围
整数型当中的byte类型，占用1个字节，所以byte类型的数据占用8个比特位，那么byte类型的取值范围是什么？
* java中的数字类型，数字都是有正负之分的，所以在数字的二进制当中有一个二进制被称为“符号位”，
并且这个“符号位” 在所有二进制位的最左边，0表示正数，1表示负数。
* byte类型最大值：01111111
【
00000000 00000000 00000000 10000000(二进制)
减去1的结果是：
00000000 00000000 00000000 01111111(二进制)
】
* byte类型最大值：2的7次方 -1，结果是：127
* byte类型最小值：-128【具体怎么用二进制表示，和原码反码补码有关。先不用管这里（计算机存的都是补码，大学的微机原理学过。）】
* byte类型取值范围：[-128~127]
* byte类型可以表示256个不同的数字【256个不同的二进制】
【byte取值范围 记住】
1.8、二进制和十进制之间的转换规则：
* 二进制转换成十进制
* 十进制转换成二进制
短除法
【计算机导论 数制】
1.9、计算机是怎么表示现实世界中的文字的呢？
* 八种基本数据类型中，计算机在表示byte,short,int,long,float,double,boolean这七种数据类型的时候比较容易，
因为底层都是数字，十进制的数字和二进制之间存在一种固定的转换规则。
* 但是八种基本数据类型中char类型表示的是现实世界中的文字，文字和计算机二进制之间“默认”情况下是不存在
任何转换关系的。
* 为了让计算机可以表示现实世界中的文字，我们需要进行人为的干涉，需要人提前制定好“文字”和“二进制”之间的对照关系，
这样的对照转换关系被称为“字符编码”。
* 计算机最初只支持英文，最先出现的字符编码是：ASCII码 【采用一个字节编码】
'a' --> 97 【01100001】
'A' --> 65
'0' --> 48
【这三个要记住，以后有用】
'a' --（按照ASCII解码）--> 01100001
01100001 ---按照ASCII解码--> 'a'
编码和解码的时候采用同一套字典/对照表，不会出现乱码
当解码和编码的时候采用的不是同一套对照表，会出现乱码问题。
*随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO指定的，这种编码方式支持西欧语言，向上兼容ASCII码，
仍然不支持中文，这种编码方式是：ISO-8859-1，又被称为latin-1
* 随着计算机向亚洲发展，计算机开始支持中文、日文、韩文等国家的文字，
其中支持简体中文的编码方式：
GB2312 < GBK < GB18030 容量从小到大（自己查这三种的范围）
GB2312 支持常用的简体中文
GBK
GB18030
* 支持繁体中文：大五码<big5>
* 后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：unicode编码，
unicode编码方式有多种具体的实现：
- UTF-8
- UTF-16
- UTF-32
......
* java语言采用的是那一种编码方式呢？
- java语言采用的是unicode编码方式，所以“标识符”可以用中文。
* 在实际开发中，一般使用UTF-8编码方式较多【统一编码方式】
（* 关于字符编码要记住什么？
能说出字符编码在计算机里起什么作用？ 字符编码起转换作用，对照表作用
常用的几个字符编码的名字：
专门针对英文的 ASCII码 国标码：ISO-8859-1，又被称为latin-1
支持简体中文的：GB2312 < GBK < GB18030
支持繁体中文：大五码<big5>
unicode编码方式有多种具体的实现：
等等）
1.10、八种基本数据类型取值范围
| 类型 | 取值范围 |
| byte | [-128 ~ 127] |
| short | [-32768 ~ 32767] |
| int | [-2147483648 ~ 2147483647] |
| long | |
| float | |
| double | |
| boolean | [true , false] |
| char | [0 ~ 65535] |
注意：short和char所表示的种类总数是一样的，只不过char可以表示更大的正整数。
因为char没有负数。
1.11、八种基本数据类型的默认值
| 数据类型 | 默认值 |
| byte,short,int,long | 0 |
| float,double | 0.0 |
| boolean | false |
| char | \u0000 |
备注：
* 八种基本数据类型的默认值是一切向0看齐
* 在C语言中，boolean的值true是1，false是0】
* char默认值 \u0000 【暂时看不懂，后边说】
代码示例如下：
public class DateTypeTest02
{
//这里的static必须加，别问为什么！
static int k = 1000;
//变量还是遵守这个法则：必须先声明，再赋值，才能访问。
//成员变量没有手动赋值，系统会默认赋值【局部变量不会】
static int f; //成员变量
public static void main(String[] args){
/*
int i; //i没赋值不能访问
System.out.println(i);
*/
System.out.println(k);
System.out.println(f);
}
}二、char类型
2.1 char类型的使用方法
参考如下代码示例：
public class DateTypeTest01
{
public static void main(String[] args){
//定义一个char类型的变量，起名C，同时赋值字符'a'
char c = 'a';
System.out.println(c);
//一个中文占用2个字节，char类型正好是2个字节
//所以java中的char类型可以存储一个中文字符
char x = '国';
System.out.println(x);
//编译错误
//ab是字符串不能使用单引号括起来
//char y = 'ab';
//"a"是字符串类型
//K变量是char类型
//类型不兼容，编译错误
//char k = "a";
//声明
char e;
//赋值
e = 'e';
System.out.println(e);
//再次赋值
e = 'f';
System.out.println(e);
}
}
/*
class 学生
{
}
*/
//在DOS窗口输入javac *.java 回车，编译成功，生成类名为学生的字节码文件2.2 转义字符
转义字符 \
转义字符出现在特殊字符之前，会将特殊字符转换成普通字符。
\n 换行符
\t 制表符tab
\' 普通的单引号
\\ 普通的反斜杠
\" 普通的双引号
参考以下代码示例加深理解：
public class DateTypeTest03
{
public static void main(String[] args){
//普通的n字符
char c1 = 'n';
System.out.println(c1);
//依照目前所学知识，以下程序无法编译通过，因为显然是一个字符串，不能使用单引号括起来
//但是经过编译，发现编译通过了，这说明以下并不是一个字符串，而是“一个”字符
//反斜杠在java语言中具有转义功能。
char c2 = '\n';
//System.out.println和System.out.print()的区别
/*
System.out.println("Hello");
System.out.println("World!");
*/
//System.out.println()和System.out.print的区别：
//println输出之后换行，print表示输出，但是不换行
/*
System.out.print("Hello");
System.out.println("World!");
*/
System.out.print("A");
System.out.print(c2);
System.out.println("B");
//普通的t字符
char x = 't';
System.out.println(x);
// \t 制表符tab
//强调：制表符和空格不同，他们的ASCII不一样，体现在键盘上两个不同的“按键”。
char y = '\t';
System.out.print("A");
System.out.print(y);
System.out.print("B");
//要求在控制台上输出“反斜杠字符”
//反斜杠将后面的单引号转义成不具备特殊含义的普通单引号字符，
//左边的单引号缺少了结束的单引号字符，编译报错
/*
char k = '\';
System.out.println(k);
*/
/*
\\
解释：第一个反斜杠具有转义功能，将后面的反斜杠转义为普通的反斜杠字符。
结论：在java中两个反斜杠代表一个普通的反斜杠字符
*/
char k = '\\';
System.out.println(k);
//在控制台上输出一个普通的单引号字符
//java中不允许这样编写程序，编译报错
//char = '';
//以下编译报错：第一个单引号和第二个单引号配对儿，最后的单引号找不到另一半儿！
//char a = ''';
//System.out.println(a);
//反斜杠具有转义功能，将第二个单引号转换成普通的单引号字符。
//第一个单引号和最后单引号配对儿。
char a = '\'';
System.out.println(a);
char f = '"';
System.out.println(f);
System.out.println("HelloWorld!");
System.out.println("“HelloWorld!”");
//编译错误
//System.out.println(""HelloWorld!"");
//纠正如下：
System.out.println("\"HelloWorld!\"");
char m = '中';
System.out.println(m);
//JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式
//怎么使用这个命令：
//在命令行输入native2ascii，回车，然后输入文字之后即可得到unicode编码
char n = '\u4e2d';
System.out.println(n);
//编译错误
//char g = '4e2d';
//编译错误
//char g = 'u4e2d';
//编译通过：反斜杠u联合起来后面的一串数字是某个文字的unicode编码
char g = '\u4e2d';
System.out.println(g);
//g = '\u456a';
//g = '\u256a';
//g = '\u256b';
g = '\u456b';
System.out.println(g);
System.out.println("========================================");
//char类型默认值
char c10 = '\u0000';
System.out.println(c10);
}
}
/*
十进制：0 1 2 3 4 5 6 7 8 9 10 11 12 13...
二进制：0 1 10 11 100 101 110...
十六进制：0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20
八进制：0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20...
*/小技巧提取：JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式
怎么使用这个命令：在命令行输入native2ascii，回车，然后输入文字之后即可得到unicode编码
三、 整数型
| 数据类型 | 占用空间大小 | 默认值 | 取值范围 |
| byte | 1 | 0 | [-128 ~ 127] |
| short | 2 | 0 | [-324768 ~ 324767] |
| int | 4 | 0 | [-2147483648 ~ 2147483647] |
| long | 8 | 0L |
1、java语言当中的“整数型字面值”被默认当做int类型来处理，要让这个“整数型字面值”被当做long类型来处理的话，
需要在“整数型字面值”后面添加l/L，建议使用大写的L
2、java语言中的整数型字面值有三种表示方式：
第一种方式：十进制【是一种缺省默认的方式】常用
第二种方式：八进制【在编写八进制整数型字面值的时候需要以0开始】
第三种方式：十六进制【在编写十六进制整数型字面值的时候需要以0x开始】
代码示例如下：
public class DateTypeTest04
{
public static void main(String[] args){
int a = 10;
int b = 010;//整数型字面值以0开头的，后面那一串数字就是八进制形式
int c = 0x10;//整数型字面值以0x开头的，后面那一串数字就是十六进制形式
System.out.println(a); //10
System.out.println(b); //8
System.out.println(c); //16
System.out.println(a+b+c); //34
//123这个整数型字面值是int类型
//i变量声明的时候也是int类型
//int类型的123赋值给int类型的变量i，不存在类型转换
int i = 123;
System.out.println(i);
//456整数型字面值被当做int类型
//x变量在声明的时候是long类型，占用8个字节
//int类型的字面值456赋值给long类型的变量x，存在类型转换
//int类型转换成long类型
//int类型是小容量
//long类型是大容量
//小容量可以自动转换成大容量，称为自动类型转换机制
long x = 456;
System.out.println(x);
//2147483647字面值是int类型，占用8个字节
//y是long类型，占用8个字节，自动类型转换
long y = 2147483647;
System.out.println(y);
//编译错误：过大的整数：2147483648
//2147483648被当做int类型4个字节处理，但是这个字面值超出int类型范围
//long z = 2147483648; //【面试题】
//解决错误：
//2147483648字面值一上来就当做long类型来处理，在字面值后面添加L
//z是long类型变量，以下程序不存在类型转换
long z = 2147483648L;
System.out.println(z);
}
}3、当一个整数型字面值没有超出byte,short,char的取值范围，这个字面值可以直接赋值给byte,short,char类型的变量。这种机制SUN允许了，目的是方便程序员的编程。
没超出范围的，SUN公司自动进行强制类型转换，超出范围就要手动添加强制转换符进行转换，超出范围的会损失精度，后果自负。
强制类型转换原理及参考代码如下：
public class DateTypeTest05
{
public static void main(String[] args){
//100L是long类型字面值
//x是long类型变量
//不存在类型转换，直接赋值
long x = 100L;
//x变量是long类型，8个字节
//y变量是int类型，4个字节
//以下程序可以编译通过吗？
//编译报错：大容量不能直接赋值给小容量
//int y = x;
//大容量转换成小容量，需要进行强制类型转换
//强制类型转换需要加“强制类型转换符”
//加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度。
//所以强制类型转换谨慎使用，因为损失精度之后可能损失很严重
//强转原理：
//原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
//强转之后的数据：00000000 00000000 00000000 01100100
//将左边的二进制砍掉【所有的数据强转的时候都是这样完成的】
int y = (int)x;
System.out.println(y);
//原始数据：00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
//强转之后的数据：10000000 00000000 00000000 00000000
//10000000 00000000 00000000 00000000 目前存储在计算机内部，计算机存储数据都采用补码的形式存储的
//所以10000000 00000000 00000000 00000000现在是一个补码形式
//将以上的补码转换到原码就是最终的结果
long k = 2147483648L;
int e = (int)k;
System.out.println(e); //损失精度严重，结果是负数 【-21474836348】
//分析以下程序是否可以编译通过？
//依据目前所学内容，以下程序是无法编译通过的
//理由：50是int类型的字面值，b是byte类型的变量，显然是大容量int转换成小容量byte
//大容量转换成小容量是需要添加强制类型转换符的，以下程序没有添加强制类型转换符号，所以编译报错。
//但是，在实际编译的时候，以下代码编译通过了，这说明：在java语言当中，
//当一个整数型字面值没有超出byte类型取值范围时，该字面值可以直接赋值给byte类型的变量 【重点】
byte b = 50; //可以
byte c = 127; //可以
//编译报错：128这个int类型的字面值已经超出了byte类型的取值范围，不能直接赋值给byte类型的变量
//byte b1 = 128;
//纠正错误：需要使用强制类型转换符
//但是一定会损失精度
//原始数据：00000000 00000000 00000000 10000000
//强转之后：10000000 【这是存储在计算机内部的一个补码，它的源码是什么】
byte b1 = (byte)128; //-128
System.out.println(b1);
/*
计算机二进制有三种表示形式：
原码
反码
补码
计算机在任何情况下地层表示和存储数据的时候采用了补码形式。
正数的补码：和原码相同
负数的补码：负数的绝对值对应的二进制码所有二进制位取反，再加1
补码：10000000
原码计算过程：
* 10000000 -1 --> 01111111
* 10000000 --> 128
* -128
*/
//原始数据：00000000 00000000 00000000 11000110
//强制类型转换之后：11000110
//11000110现在在计算机当中存储，它是一个补码，将补码转换成原码就是该数字：
//11000110 - 1 --> 11000101
//所有二进制位取反得到 00111010 【2 + 8 + 16 + 32】--> 58
//符号位是1，得到负数 -58
byte m = (byte)198;
System.out.println(m); //
//short s = 32767; //通过
//short s1 = 32768; //编译报错
//65535是int类型，4个字节
//cc是char类型，2个字节
//按照以前所学知识点，以下程序编译报错
//char cc = 65535; //通过
//cc = 65536; //编译报错
/*
由上总结：
当一个整数型字面值没有超出byte,short,char的取值范围，
这个字面值可以直接赋值给byte,short,char类型的变量。
这种机制SUN允许了，目的是方便程序员的编程。
没超出范围的，SUN公司自动进行强制类型转换，超出范围就要手动添加强制转换符进行转换，
超出范围的会损失精度，后果自负。
*/
}
}四、浮点型数据类型
float 单精度【4个字节】
double 双精度【8个字节，精度较高】
1、double的精度太低【相对来说的】，不适合做财务软件。财务涉及到钱的问题，要求精度较高，所以SUN在基础SE类库当中为程序员准备了精度更高的类型，只不过这种类型是一种引用数据类型，不属于基本数据类型，它是：java.math.BigDecimal
其实java程序中SUN提供了一套庞大的类库，java程序员基于这套基础的类库来进行开发。
所以要知道java的SE类库的字节码在哪儿，要知道java的SE类库的源码在哪儿？
* SE类库的字节码：D:\programs\Java\jdk1.8.0_91\jre\lib\rt.jar （一般是C:\programs\Java\jdk1.8.0_91\jre\lib\rt.jar 我把Java安装在了D盘，所以是D ）
* SE类库的源码：D:\programs\Java\jdk1.8.0_91\src.zip
例如：String.java和String.class
我们的（String[] args）中的String使用的就是String.class字节码文件
2、在java语言中，所有的浮点数字面值【3.0】，默认被当做double类型来处理，要想该字面值当做float类型来处理，需要在字面值后面添加F/float
注意：
double和float在计算机内部二进制存储的时候，都是近似值。
在现实世界中有一些数字是无限循环的，例如：3.333333333333333...
计算机的资源是有限的，用优先的资源存储无限的数据只能存储近似值。
代码示例如下：
public class DateTypeTest06
{
public static void main(String[] args){
//3.0是double类型的字面值
//d是double类型的变量
//不存在类型转换
double d = 3.0;
System.out.println(d);
//5.1是double类型的字面值
//f是float类型的变量
//大容量转换成小容量需要加强制类型转换符，所以以下程序编译报错。
//float f = 5.1;
//解决方案：
//第一种方式：强制类型转换
//float f = (float)5.1;
//第二种方式:没有类型转换
float f = 5.1f;
}
}五、布尔数据类型
boolean
1、注意读音要读正确：英[ˈbuːliən]
2、在java语言当中boolean类型只有两个值：true，false，没有其他值。不像C语言中，0和1可以表示假和真。
3、在底层存储的时候boolean类型只占用1个字节，因为实际存储的时候false底层是0，true底层是1.
4、布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句中。
参考代码如下：
public class DateTypeTest07
{
public static void main(String[] args){
//编译错误：不兼容的类型
//boolean flag = 1;
boolean loginSuccess = true;
//if语句以后讲【条件控制语句】
if(loginSuccess){
System.out.println("恭喜你，登录成功")
}else{
System.out.println("对不起，用户名不存在或者密码错误！");
}
}
}六、基本数据类型之间的互相转换规则
转换规则：
1、八种数据类型当中，除布尔类型之外，剩下的7种数据类型之间都可以相互转换
2、小容量向大容量转换，称为自动类型转换，容量从小到大的顺序：
byte < short < int < long <float < double
char <
注：
任何浮点类型不管用多少个字节，都比整数型容量大。
char和short可表示的种类数量相同，但是char可以取更大的正整数
3、大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，
但是在运行阶段可能会损失精度，所以谨慎使用。
4、当整数字面值没有超出byte,short,char的取值范围，可以直接赋值给byte,short,char类型的变量。
5、byte,short,char混合运算的时候，各自先转换成int类型再做运算。
6、多种数据类型混合运算，先转换成容量最大的那种类型再做运算。
【这6条规则要背会，理解记忆】
注意：
byte b = 3; 可以编译通过，3没能超出byte类型取值范围
int i = 10;
byte b = i / 3;编译报错，编译器只检查语法，不会“运算”i / 3
思维过程：要分清楚编译期和运行期的事，编译期结束适可而止
示例代码如下：
public class DateTypeTest08
{
public static void main(String[] args) {
//出现错误，1000超出了byte的范围
//byte a = 1000;
//正确，因为20没有超出byte范围，
//所以赋值
byte a = 20;
//报错，变量不能重名
//short a = 1000;
//正确，因为数值1000没有超出short类型范围
//所以赋值正确
short b = 1000;
//正确，因为默认就是int
int c = 1000;
//正确，可以自动转换
long d = c;
//错误，出现精度丢失问题，大类型--->>小类型会出现问题
//int e = d;
//将long强制转换成int类型
//因为值1000没有超出int范围，所以转换是正确的
int e = (int)d;
//因为java中的运算会转成最大类型
//而10和3默认为int，所以运算后的最大类型也是int，所以是正确的
int f = 10/3; //3
//声明10为long类型
long g = 10;
//出现错误，多个数值在运算过程中，会转换成容量最大的类型
//以下示例最大类型为double，而h为int，所以就会出现大类型（long）到小类型（int）的转换，会出现精度丢失问题
//int h = g / 3;
//可以强制转换，因为运算结果没有超出int范围
int h = (int)g/3;
//可以采用long类型来接收运算结果
//long h = g / 3;
//出现精度损失问题，以下问题主要是优先级的问题
//将g转换成int，然后又将int转换成byte，最后byte类型的g和3运算，那么
//它的运算结果类型就是int，所以赋值给byte就出现了精度损失问题
//byte h = (byte)(int)g/3;
//正确
//byte h = (byte)(int)(g/3);
//不能转换，还因为优先级问题
//byte h = (byte)g/3;
//可以转换，因为运算结果没有超出byte范围
//byte h = (byte)(g/3);
//可以转换，因为运算结果没有超出short范围
//short h = (short)(g/3);
short i = 10;
byte j = 5;
//错误，short和byte运算，首先会转换成int再运算
//所以运算结果为int，int赋值给short就会出现精度丢失问题
//short k = i + j;
//可以将运算结果强制转换成short
//short k = (short)(i + j);
//因为运算结果为int，所以可以采用int类型接收
int k = i + j;
char l = 'a';
System.out.println(l); //a
//输出结果为97，也就是a的ascii值
System.out.println((byte)l); //97
int m = l + 100;
//输出结果为197，取得a的ascii码值，然后与100进行相加运算
System.out.println(m); //197
double dd = 10 / 3;
System.out.println(dd); //3.0
dd = 10.0 / 3; //3.3333333333333335
System.out.println(dd);
}
}
2149
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
