基本数据类型取值范围
注意: short和 char 所表示的种类总数是一样的，只不过char可以表示更大的正整数。因为char没有负数。
Char类型总结
/*
字符型：
char
1、char占用2个字节。
2、char的取值范围：[0-65535]
3、char采用unicode编码方式。
4、char类型的字面量使用单引号括起来。
5、char可以存储一个汉字。
*/
public class CharTest01{
public static void main(String[] args){
// char可以存储1个汉字吗？
// 可以的，汉字占用2个字节，java中的char类型占用2个字节，正好。
char c1 = '中';
System.out.println(c1);
char c2 = 'a';
System.out.println(c2);
// 0如果加上单引号的话，0就不是数字0了，就是文字0，它是1个字符。
char c3 = '0';
System.out.println(c3);
// 错误: 不兼容的类型: String无法转换为char
//char c4 = "a";
// 错误: 未结束的字符文字
//char c5 = 'ab';
注意：未结束的字符文字 这种错误是什么意思？ 应为我们的 JVM 在运行到char变量
的时候，认为值一定是两个单引号加一个字符，认为a后面一定是一个单引号，但
发现是一个b，所以认为是未结束的字符，认为缺少了一个单引号。
// 错误: 未结束的字符文字
//char c6 = '1.08';
}
}
/*
关于java中的 转义字符
java语言中“\”负责转义。
\t 表示 制表符 tab
*/
public class CharTest02{
public static void main(String[] args){
// 普通的't'字符
char c1 = 't';
System.out.println(c1);
//char x = 'ab';
// 根据之前所学，以下代码应该报错。
// 经过测试以下代码 \t 实际上是1个字符，不属于字符串
// 两个字符合在一起表示一个字符，其中 \t 表示“制表符tab”
char c2 = '\t'; //相当于键盘上的tab键
System.out.println("abcdef");
System.out.println("abctdef");
// \的出现会将紧挨着的后面的字符进行转义。\碰到t表示tab键。
System.out.println("abc\tdef");
System.out.print("abc");
//char c3 = 'n'; // 普通的n字符
char c3 = '\n'; // 换行符
//System.out.print(c3);
System.out.println(c3);
System.out.println("def");
// 假设现在想在控制台输出一个 ' 字符怎么办？
// 错误: 空字符文字
//System.out.println(''');
// \' 表示一个普通不能再普通的单引号字符。（\'联合起来表示一个普通的 '）
System.out.println('\'');
// 假设现在想在控制台输出一个 \ 字符怎么办？
//错误: 未结束的字符文字
//System.out.println('\');
// 在java中两个反斜杠代表了一个“普通的反斜杠字符”
System.out.println('\\');
// 双引号括起来的是字符串
System.out.println("test");
// 希望输出的结果是："test"
// 错误: 需要')'
//System.out.println(""test"");
System.out.println("“test”"); //内部的双引号我用中文的行吗？可以。
System.out.println("");
// 编译报错。
//System.out.println(""");
//System.out.println("\"");
System.out.println("\"test\"");
// 这个可以输出吗？
// 这个不需要专门进行转义。
// 这个 ' 在这里只是一个普通的字符，不具备特殊含义。
System.out.println("'");
//以下都有问题
//System.out.println(''');
//System.out.println(""");
// 可以的。
System.out.println("'这样呢'");
// 编译报错，因为：4e2d 是一个字符串
// 错误: 未结束的字符文字
//char x = '4e2d';
// 反斜杠u表示后面的是一个字符的unicode编码。
// unicode编码是十六进制的。
char x = '\u4e2d';
System.out.println(x); // '中'
}
}
/*
1、整数能否直接赋值给char
2、char x = 97;
这个 java 语句是允许的，并且输出的结果是'a'
经过这个测试得出两个结论：
第一个结论：当一个整数赋值给char类型变量的时候，会自动转换成char字符型，
最终的结果是一个字符。
第二个结论：当一个整数没有超出byte short char的取值范围的时候，
这个整数可以直接赋值给byte short char类型的变量。
*/
public class CharTest03{
public static void main(String[] args){
char c1 = 'a';
System.out.println(c1);
// 这里会做类型转换吗？
// 97是int类型（这是java中规定，默认当做int处理）
// c2是char类型
//char c2 = (char)97; // 不需要这样做。
char c2 = 97;
System.out.println(c2); // 'a'
// char类型取值范围：[0~65535]
char c3 = 65535; // 实际上最终是一个“看不懂”的字符。
System.out.println(c3);
//错误: 不兼容的类型: 从int转换到char可能会有损失
//char c4 = 65536;
// 怎么解决以上问题？
char c4 = (char)65536;
byte x = 1;
short s = 1;
char c = 1;
}
}
整数类型总结
/*
在java中有一条非常重要的结论，必须记住：
在任何情况下，整数型的“字面量/数据”默认被当做int类型处理。（记住就行）
如果希望该“整数型字面量”被当做long类型来处理，需要在“字面量”后面添加L/l
建议使用大写L，因为小写l和1傻傻分不清。
*/
public class IntTest02{
public static void main(String[] args){
// 分析这个代码存在类型转换吗，以下代码什么意思？
// 不存在类型转换
// 100 这个字面量被当做int类型处理
// a变量是int类型，所以不存在类型的转换。
// int类型的字面量赋值给int类型的变量。
int a = 100;
System.out.println(a);
// 分析这个程序是否存在类型转换？
// 分析：200这个字面量默认被当做int类型来处理
// b变量是long类型，int类型占4个字节，long类型占8个字节
// 小容量可以自动转换成大容量，这种操作被称为：自动类型转换。
long b = 200;
System.out.println(b);
// 分析这个是否存在类型转换？
// 这个不存在类型转换。
// 在整数型字面量300后面添加一个L之后，300L联合起来就是一个long类型的字面量
// c变量是long类型，long类型赋值给long类型不存在类型转换。
long c = 300L;
System.out.println(c);
// 题目：
// 可以吗？存在类型转换吗？
// 2147483647默认被当做int来处理
// d变量是long类型，小容量可以自动赋值给大容量，自动类型转换
long d = 2147483647; // 2147483647是int最大值。
System.out.println(d);
// 编译器会报错吗？为什么？
// 在java中，整数型字面量一上来编译器就会将它看做int类型
// 而2147483648已经超出了int的范围，所以在没有赋值之前就出错了。
// 记住，不是e放不下2147483648，e是long类型，完全可以容纳2147483648
// 只不过2147483648本身已经超出了int范围。
// 错误: 整数太大
//long e = 2147483648;
// 怎么解决这个问题呢？
long e = 2147483648L;
System.out.println(e);
}
}
/*
1、小容量可以直接赋值给大容量，称为自动类型转换。
2、大容量不能直接赋值给小容量，需要使用强制类型转换符进行强转。
但需要注意的是：加强制类型转换符之后，虽然编译通过了，但是运行
的时候可能会损失精度。
*/
public class IntTest03{
public static void main(String[] args){
// 不存在类型转换
// 100L是long类型字面量，x是long类型字面量。
long x = 100L;
// x是long类型，占用8个字节，而y变量是int类型，占用4个字节
// 在java语言中，大容量可以“直接”赋值给小容量吗？不允许，没有这种语法。
// 编译错误信息：错误: 不兼容的类型: 从long转换到int可能会有损失
//int y = x;
// 大容量转换成小容量，要想编译通过，必须加强制类型转换符，进行强制类型转换。
// 底层是怎么进行强制类型转换的呢？
// long类型100L：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
// 以上的long类型100L强转为int类型，会自动将“前面”的4个字节砍掉：00000000 00000000 00000000 01100100
int y = (int)x; // 这个(int)就是强制类型转换符，加上去就能编译通过。
// 但是要记住：编译虽然过了，但是运行时可能损失精度。
System.out.println(y); // 100
// 定义变量a int类型，赋值100
int a = 100;
System.out.println(a);
int b = a; // 将变量a中保存的值100复制一份给b变量。
System.out.println(b);
}
}
/*
java中有一个语法规则：
当这个整数型字面量没有超出byte的取值范围，那么这个
整数型字面量可以直接赋值给byte类型的变量。
这种语法机制是为了方便写代码，而存在的。
*/
public class IntTest04{
public static void main(String[] args){
// 分析：以下代码编译可以通过吗？
// 300 被默认当做int类型
// b变量是byte类型
// 大容量转换成小容量，要想编译通过，必须使用强制类型转换符
// 错误: 不兼容的类型: 从int转换到byte可能会有损失
//byte b = 300;
// 要想让以上的程序编译通过，必须加强制类型转换符
// 虽然编译通过了，但是可能精度损失。
// 300这个int类型对应的 二进制 ：00000000 00000000 00000001 00101100
// byte占用1个字节，砍掉前3个字节，结果是：00101100 (44)
byte b = (byte)300;
System.out.println(b); // 44
// 这个编译能通过吗？
// 1是int类型，默认被当做int类型来看。
// x是byte类型，1个字节，大容量无法直接转换成小容量。
// 按说是编译报错的。
byte x = 1;
byte y = 127;
// 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte z = 128;
// 当整数型字面量没有超出short类型取值范围的时候，该字面量可以直接赋值给short
// 类型的变量。
short s = 1;
short s1 = 32767;
// 错误: 不兼容的类型: 从int转换到short可能会有损失
//short s2 = 32768;
System.out.println(s);
}
}
/*
1、计算机在任何情况下都只能识别二进制
2、计算机在底层存储数据的时候，一律存储的是“二进制的补码形式”
计算机采用补码形式存储数据的原因是：补码形式效率最高。
3、什么是补码呢？
实际上是这样的，二进制有：原码 反码 补码
4、记住：
对于一个正数来说：二进制原码、反码、补码是同一个，完全相同。
int i = 1;
对应的二进制原码：00000000 00000000 00000000 00000001
对应的二进制反码：00000000 00000000 00000000 00000001
对应的二进制补码：00000000 00000000 00000000 00000001
对于一个负数来说：二进制原码、反码、补码是什么关系呢？
byte i = -1;
对应的二进制原码：10000001
对应的二进制 反码 （符号位不变，其它位取反）：11111110
对应的二进制补码（反码+1）：11111111
5、分析 byte b = (byte)150;
这个b是多少？
int类型的4个字节的150的二进制码是什么？
00000000 00000000 00000000 10010110
将以上的int类型强制类型转为1个字节的byte，最终在计算机中的 二进制码 是：
10010110
千万要注意：计算机永远存储的都是二进制补码形式。也就是说上面
10010110 这个是一个二进制补码形式，你可以采用逆推导的方式推算出
这个二进制补码对应的原码是啥！！！！！！
10010110 ---> 二进制补码形式
10010101 ---> 二进制反码形式
11101010 ---> 二进制原码形式
*/
public class IntTest05{
public static void main(String[] args){
// 编译报错：因为150已经超出了byte取值范围，不能直接赋值，需要强转
//byte b = 150;
byte b = (byte)150;
// 这个结果会输出多少呢？
System.out.println(b); // -106
}
}
/*
结论：byte、char、short做混合运算的时候，各自先转换成int再做运算。
*/
public class IntTest06{
public static void main(String[] args){
char c1 = 'a';
byte b = 1;
// 注意：这里的"+"是负责求和的
System.out.println(c1 + b); // 98
// 错误: 不兼容的类型: 从int转换到short可能会有损失
//short s = c1 + b; // 编译器不知道这个加法最后的结果是多少。只知道是int类型。
// 这样修改行吗？
//错误: 不兼容的类型: 从int转换到short可能会有损失
//short s = (short)c1 + b;
short s = (short)(c1 + b);
//short k = 98;
int a = 1;
//错误: 不兼容的类型: 从int转换到short可能会有损失
// short x = 1; 可以
short x = a; // 不可以，编译器只知道a是int类型，不知道a中存储的是哪个值。
System.out.println(x);
}
}
/*
结论：多种数据类型做混合运算的时候，最终的结果类型是“最大容量”对应的类型。
char+short+byte 这个除外。
因为char + short + byte混合运算的时候，会各自先转换成int再做运算。
*/
public class IntTest07{
public static void main(String[] args){
long a = 10L;
char c = 'a';
short s = 100;
int i = 30;
// 求和
System.out.println(a + c + s + i); //237
// 错误: 不兼容的类型: 从long转换到int可能会有损失
// 计算结果是long类型
//int x = a + c + s + i;
int x = (int)(a + c + s + i);
System.out.println(x);
// 以下程序执行结果是？
// java中规定，int类型和int类型最终的结果还是int类型。
int temp = 10 / 3; // / 是除号。（最终取整）
System.out.println(temp); // 3.33333吗？结果是：3
// 在java中计算结果不一定是精确的。
int temp2 = 1 / 2;
System.out.println(temp2); // 0
}
}
public class TypeTransferTest{
public static void main(String[] args){
// 编译报错，因为1000已经超出范围了。
//byte b1 = 1000;
// 可以
byte b2 = 20;
// 可以
short s = 1000;
// 可以
int c = 1000;
// 可以
long d = c;
// 编译报错
//int e = d;
// 可以
int f = 10 / 3;
// 可以
long g = 10;
// 编译报错
//int h = g / 3;
// 可以
long m = g / 3;
// 编译报错
//byte x = (byte)g / 3;
// 可以
short y = (short)(g / 3);
// 可以
short i = 10;
// 可以
byte j = 5;
// 编译报错
//short k = i + j;
// 可以
int n = i + j;
// 可以
char cc = 'a';
System.out.println(cc); // a
System.out.println((byte)cc); // 97
// cc 会先自动转换成int类型，再做运算
int o = cc + 100;
System.out.println(o); // 197
}
}
浮点型总结
/*
关于java语言中的浮点型数据
浮点型包括：
float 4个字节
double 8个字节
float是单精度
double是双精度
double更精确
比如说：
10.0 / 3 如果采用float来存储的话结果可能是：3.33333
10.0 / 3 如果采用double来存储的话结果可能是：3.3333333333333
但是需要注意的是，如果用在银行方面或者说使用在财务方面，double
也是远远不够的，在java中提供了一种精度更高的类型，这种类型专门
使用在财务软件方面：java.math.BigDecimal （不是基本数据类型，属于
引用数据类型。）
float和double存储数据的时候都是存储的近似值。
为什么？
因为现实世界中有这种无线循环的数据，例如：3.3333333333333....
数据实际上是无限循环，但是计算机的内存有限，用一个有限的资源
表示无限的数据，只能存储近似值。
long类型占用8个字节。
float类型占用4个字节。
哪个容量大？
注意：任意一个浮点型都比整数型空间大。
float容量 > long容量。
java中规定，任何一个浮点型数据默认被当做double来处理。
如果想让这个浮点型字面量被当做float类型来处理，那么
请在字面量后面添加F/f。
1.0 那么1.0默认被当做double类型处理。
1.0F 这才是float类型。（1.0f）
*/
public class FloatTest01{
public static void main(String[] args){
// 这个不存在类型转换
// 3.1415926是double类型
// pi是double类型
double pi = 3.1415926;
System.out.println(pi);
// 这个可以吗？
//错误: 不兼容的类型: 从double转换到float可能会有损失
//float f = 3.14;
// 怎么修改以上的代码呢？
// 第一种方式:在字面量后面添加F/f
//float f = 3.14f;
//float f = 3.14F;
// 第二种方式：强制类型转换，但可能损失精度。谨慎使用。
float f = (float)3.14;
System.out.println(f);
// 分析这个程序，可以编译通过吗？
// 错误: 不兼容的类型: 从double转换到int可能会有损失
// 原理：先将5转换成double类型，然后再做运算，结果是double
// 大容量无法直接赋值给小容量，需要强转。
//int i = 10.0 / 5;
// 怎么修改
int i = (int)10.0 / 5;
System.out.println(i); // 2
// 可以这样修改吗？强转的时候只留下整数位。
int x = (int)(10.0 / 5);
System.out.println(x); // 2
}
}
