基础数据类型详解

基础数据类型详解

1 基础数据类型分类

各种基础数据类型所占字节数的大小(单位Byte)
整数型数据 byte 1 short 2 int 4 long 8
小数型数据 float 4 double 8
字符型数据 char 2
布尔型数据 boolean 1

1.1 整数型数据类型

数据类型所占空间的大小：
    byte --- 字节型数据类型，在内存中占用1个Byte，所能表示的范围是多少？-128~127
    short--- ..... 在内存中占用2个Byte，所能表示的范围是多少？-32768 ~ 32767
    int ---- 整型 在内存中占用4Byte，所能表示的范围是多少？-2147483648 ~ 2147483647
    long --- 长整型 在内存中占用8Byte
在java中，定义整数型数据的时候，如果字面量是十进制的数值，那么java会自动默认为int型。
    也就是说：int short byte long 这几个，只要后面跟的是十进制的整数，那么它们都被默认为int型

    Test01.java:12: 错误: 不兼容的类型: 从int转换到byte可能会有损失
					byte b = -129;
 为什么有损失？怎么损失的？
class Test01 
{
	public static void main(String[] args) 
	{
		//基础数据类型--8种基本数据类型
		// int short long byte 这四种是整数
		// float double  这两种是小数
		// char			这种是字符
		// boolean      这种是true false

		// byte b = -128; //这样可以吗？可以
		byte b = (byte)300;
		System.out.println(b); // 这个结果是多少？

		byte m = -1;
		// 第一步，-1这个字面量被默认为int型，它的存储方式为：11111111 ... 11111111
		// 第二步，在byte取值范围内，会自动截掉前面3个Byte，只留下最后一个Byte，
		//		   因为，前面的全是0以及符号位
		// 第三步，只保留最好一个字节，该字节中存储的是该字面量的补码形式(正数的原码、反码、补码都一样)
		//		   负数的补码需要计算，我们需要的是原码，
		// 			拿到的是补码，补码先-1，然后符号位不变，按位取反，得到原码

		System.out.println(m);
/*
	E:\java基础\1-20-2>javac Test01.java
	Test01.java:12: 错误: 不兼容的类型: 从int转换到byte可能会有损失
					byte b = -129;
							 ^
	1 个错误
*/
		// short s = 32767;
	}
}

1.2 关于计算机内存中存储的二进制

记住，在计算机内存存储的二进制都是以补码的形式进行存储，在内存中第一位表示符号位，0表示正，1表示负
什么是补码？
对于一个正数来说，它的原码、反码、补码都一个样
        如：10的原码：00000000 00000000 00000000 00001010
对于一个负数来说，它的原码、反码、补码是什么样子的、
    原码很简单，就是一个整数的二进制表示，第一位是符号位
    如：-1的原码：10000000 00000000 00000000 00000001
    	反码：符号位不变，其他位取反也就是说，原来是0的要变成1，是1的要变成0，记住符号位不变
      -1的反码：11111111 11111111 11111111 11111110
      补码：反码+1
      -1的补码：11111111 11111111 11111111 11111111

1.3 long和int的区别

class Test01 
{
	public static void main(String[] args) 
	{
		// long l = 3000; // 这样可以吗。我们知道 3000 默认为int型，直接给long赋值可以吗？
		// 对于long来说，它有8Byte，int是4Byte，所以能够直接转换
		//long l = 2147483648; // 这样写可以吗？为什么？
		// 这样做不可以，编译不通过。
		// 因为整型的字面量会被默认为int型，2147483648超出了int的范围。所以编译器报错。
		/*
			E:\java基础\1-20-2>javac Test01.java
			Test01.java:7: 错误: 整数太大
							long l = 2147483648; // 这样写可以吗？为什么？
									 ^
			1 个错误
		*/
		long l = 2147483648L;// 这样做就可以让编译器编译通过。
		// 3000 和 3000L有什么区别？从字面量上看，没啥区别，但是实质上有本质的区别
		// 3000 是int型，只要4Byte装，3000L是long，要8个Byte装。
		// 大写的L和小写的l都可以，但是l和1好像不太好区分，所以建议大家都用L
		System.out.println(l);
	}
}

1.4 float 和 double

class Test01 
{
	public static void main(String[] args) 
	{
		float pi = 3.14;
		double pi2 = 3.1415926;

		System.out.println(pi);
		System.out.println(pi2);
	}
}
编译器报错：
E:\java基础\1-20-2>javac Test01.java
Test01.java:5: 错误: 不兼容的类型: 从double转换到float可能会有损失
                float pi = 3.14;
                           ^
1 个错误
                               
                               
class Test01 
{
	public static void main(String[] args) 
	{
		float pi = 3;
		double pi2 = 3.1415926;

		System.out.println(pi);
		System.out.println(pi2);
	}
}
编译通过。
    
E:\java基础\1-20-2>javac Test01.java

E:\java基础\1-20-2>java Test01
3.0
3.1415926

    
为什么？
1. 只要是字面量为小数，系统默认为double型的，double占了8个字节，float只占了4个字节
2. 如果给的字面量是整数，它就编译通过了呢？因为int是4字节，float也是4字节的，所以能通过。
3. 补充，float比long所表示的范围要大。这个东西希望你们记住就可以了，float占4个字节，long占8个字节，但是float要比long大。
4. 定义float类型的变量，其后的字面量为小数一定要带F

1.5 char

class Test01 
{
	public static void main(String[] args) 
	{
		// float pi = 3.1;
		double pi2 = 3.1415926;
		char c = 'a'; // 2Byte
		int cc = 'a';
		char ch = 98; // 这样行不行？
		char ch1 = 32767;// 这样可以吗？可以啊。没有越界，因为char是2Byte
		char ch2 = -32767;// 这样可以吗？不可以。为什么呀？因为char是没有负数取值的
		System.out.println(ch2);
		System.out.println(pi2);
	}
}


class Test01 
{
	public static void main(String[] args) 
	{
		char c = 'a'; // 2Byte
		int cc = c; // 这样可以吗？可以
		System.out.println(c);
		System.out.println(cc);
	}
}

class Test01 
{
	public static void main(String[] args) 
	{
		int c = 'a'; 
		char cc = c; // 这样可以吗？为什么？因为c是int型的变量，它是4Byte的，如果直接赋值给char，这样编译器是无法识别的。
		System.out.println(c);
		System.out.println(cc);
	}
}

编译会报错：
E:\java基础\1-20-2>javac Test01.java
Test01.java:6: 错误: 不兼容的类型: 从int转换到char可能会有损失
                char cc = c; // 这样可以吗?
                          ^
1 个错误
                              
                              
结论：在基础数据类型中，如果大转小，不强制类型转换，编译是通不过的。
                                                       
class Test01 
{
	int i = 10; // 1 
	
	int i;		// 2
    int j = 10; // 2
    i = j;      // 2

	// 请问1 和 2 等价吗？是一样的吗？不一样
	public static void main(String[] args) 
	{
		int c = 'a'; 
		char cc = c; // 这样可以吗？为什么？
		System.out.println(c);
		System.out.println(cc);


		// 整数型的字面量都默认为int
		short i = 10;
		// 拆分 我们以前说这样的方式是等价的，到底等不等价呢？其实不等价！！！！！！
		int j = 10;
		short i = j;
	}
}

1.6 boolean

class Test01 
{
	public static void main(String[] args) 
	{
		boolean flag = true;// flase
		int j = (int)flag;// 这样可以吗？
		/*	
			E:\java基础\1-20-2>javac Test01.java
			Test01.java:6: 错误: 不兼容的类型: boolean无法转换为int
							int j = (int)flag;// 这样可以吗？
										 ^
			1 个错误
		*/
		System.out.println(j);
	}
}

		boolean flag = true;// false
		int j = (int)flag;// 这样可以吗？
		/*	
			E:\java基础\1-20-2>javac Test01.java
			Test01.java:6: 错误: 不兼容的类型: boolean无法转换为int
							int j = (int)flag;// 这样可以吗？
										 ^
			1 个错误
		*/
		System.out.println(j);
	}
}