java中的基本数据类型？各占多少位？多少字节？取值范围？
1.Int 32 4 -2,147,483,648 ~ 2,147,483,647
2.Short 16 2 -32768 ~ 32678
3.long 64 8 -9,223,372,036,854,775,808~+9,223,372,036,854,775,807
4.float 32 4 -3,40292347E+38 ~ +3,40292347E+38
5.double 64 8 -1.79769313486231576E+308 ~ 1.79769313486231576E+308
6.char 16 2 ‘\u0000′ ~ ‘\uFFFF’
7.boolean 1 0.125 true/false
8.byte 8 1 -128 ~ 127
- 1.未带有字符后缀标识的整数默认为int类型；未带有字符后缀标识的浮点数默认为double类型。
- 2.如果一个整数的值超出了int类型能够表示的范围，则必须增加后缀“L”（不区分大小写，建议用大写，因为小写的L与阿拉伯数字1很容易混淆），表示为long型。
- 3.带有“F”（不区分大小写）后缀的整数和浮点数都是float类型的；带有“D”（不区分大小写）后缀的整数和浮点数都是double类型的。
- 4.编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查，如果超出了它们的取值范围就会报错。
- 5.int型值可以赋给所有数值类型的变量；long型值可以赋给long、float、double类型的变量；float型值可以赋给float、double类型的变量；double型值只能赋给double类型变量。
补充：
class Demo01
{
public static void main(String[] args)
{
//byte -- -128~127
//解决方案：把数据类型提升。
//我们可以通过把数据赋值给short,int,long来解决问题。
//但是，我们不想这样做，就只想把数据赋值给byte类型。
//数据类型转换
//从大到小：所占用的字节数比数据类型所能表示的大。
//从小到大：所占用的字节数比数据类型所能表示的小。
//一个整数，默认是int类型。
//也就是说这个130和300其实是int类型的
//那么，现在你是把int类型赋值给byte类型，
//也就是从大到小的赋值。这个时候，可能会有溢出。
//因为你是4个字节的数据，而我只有1个。
//如果不想使用提升数据类型的方式，那么， 我们就只能使用强制转换了
//强制类型转换的应用场景：
//在把一个大的数据类型的值赋值给小的数据类型的时候，需要使用强制类型转换。
//使用格式是：
//数据类型 变量 = (数据类型)值;
byte b1 = (byte)130;//可能有数据溢出
byte b2 = (byte)300;//可能有数据溢出
System.out.println(b1);//-126
System.out.println(b2);//44
//现在我们解决了这个问题，请问大家是否都看懂了这个结果呢?
}
}
/*
问题：为什么byte b1 = (byte)130;结果是-126呢?
思考：
A:130这个数据默认是int类型的。
B:在参与运算的时候，得变成补码表示。
C:找到130的补码。通过观察数据，我们知道130是一个正数。
D:正数的原码，反码，补码都相同。所以我们只要写出了130的原码就知道补码。
E:写出130的原码。他的原码其实就是他的二进制表示。
十进制的130 -- 二进制数据来
十进制到二进制：用十进制的数据除以2，直到商为0，余数反转。
F:8421码?
8个bit位的数据
1 1 1 1 1 1 1 1
128 64 32 16 8 4 2 1
1 0 0 0 0 0 1 0
也就是130的二进制：
00000000 00000000 00000000 10000010
G:接下来我们把130给强制转换为了byte类型，那么，这个时候，就出问题了。
byte类型占用1个字节。而我们的130现在占用的是4个字节。
所以，在强制转换的过程中，会有字节数据的丢失。
但是，我们不用搭理它。
直接按照我们的结果来看：
00000000 00000000 00000000 10000010
强制转换为byte类型后，我们的结果就是
10000010
H:这个时候，我们看到了10000010。这个数据应该是补码形式存在的。
我们最终通过显示器看到的应该是原码。
而最高位的1也透露了这个数其实是一个负数。
那么， 我们就应该按照刚才讲解的原码，反码，补码的规则
推出这个负数的原码表示。
补码：1 0000010
反码：1 0000001
原码：1 1111110
I:最终我们的数据值是：1 1111110
而我们通过控制台看到的是十进制数据，所以，我们还要把改二进制转换为十进制。
1 1111110
最高位是符号位。所以，该数的结果是一个负数。
128 64 32 16 8 4 2 1
符号位 1 1 1 1 1 1 0
- 64+32+16+8+4+2
-126
问题：
为什么byte b2 = (byte)300 结果是44呢?
第一步：把300的二进制写出来。
1 1 1 1 1 1 1 1 1
256 128 64 32 16 8 4 2 1
1 0 0 1 0 1 1 0 0
300的二进制：
00000000 00000000 00000001 00101100
第二步：所有数据的存储和操作都是补码形式。
截取数据300。
得到：00101100
得到的是一个补码，而我们发现最高位是0,说明是一个正数。所以，这个补码其实也就是原码。
所以，我们直接获取该值即可。
128 64 32 16 8 4 2 1
符号位 0 1 0 1 1 0 0
+ 32+8+4
+44
byte
-128 - 127
byte b = 127;
byte b = (byte)128;//-128
byte b = (byte)129;//-127
byte b = (byte)130;//-126
*/class Demo02 {
/*
* 这是主函数，是程序的入口 它的出现可以保证程序的独立运行，
*/
public static void main(String[] args) {
/*
byte b = 1;
byte c = 1;
b = b + 1; //int赋值到byte报错
c++;
System.out.println(b == c);
*/
/*
//byte b = 127;
//1是int类型的
//1.JVM在进行定义的变量初始化时，首先检测右侧的数据自身的数据类型
//与左侧的常量的数据类型之间是否存在有可转化的可能性
//2.检测具有可转换性，检测左边的数据类型的范围-128 +127
//3.检测左侧数据的值是否在范围内
//4.如果在范围内，自动将左侧的数据转型成左侧的类型
//5.如果不在范围内，报错
*/
/*
byte b = 127;
byte bs = b;
//1.检测右边的数据类型是否与左边相同
//如果相同，编译通过
//如果不相同，编译失败
*/
byte b = 0;
byte c = 50;
// byte d = b + c; //编译报错，byte类型运算的时候自动转换为int类型
byte d = (byte) (b + c);
System.out.print(d);
}
}public class Test {
/**
* byte 8 bits -128 - + 127
* 1 bit = 1 二进制数据
* 1 byte = 8 bit
* 1 字母 = 1 byte = 8
* bit(位) 1 汉字 = 2 byte = 16 bit
*/
public static void main(String[] args) {
byte b1 = 127;
byte b2 = -128;
byte b3 = 'a';
byte b4 = 'A'; // 一个字母 = 1 byte = 8 bit
System.out.println(b3); //输出97
System.out.println(b4); //输出65
// byte b5 ='aa'; 报错
// byte b6 ='中'; 报错 一个汉字 2个字节 16bit
short s1 = '中'; // 一个汉字 2个字节 16bit short 是 16 bit位的
System.out.println(s1);
// short s2 = '汉字'; // 2个汉字 4个字节 32 bit int 是32 bit的
// int i1 = '汉字'; 但是 int 是数字类型的 , char 是 16 bit的 = 2 byte = 一个汉字
char c1 = '中';
System.out.println(c1);
}
}
229
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
