Java知识点复习：Day03

目录

1. 数据类型
            •1.1 基本数据类型
            •1.2 引用数据类型
            •1.3 注意事项
2. 变量
            •2.1 变量的概念及其应用
            •2.2 注意事项
            •2.2.1 注意事项实例
3. 数据类型转换
            •3.1 自动类型转换（隐式）
            •3.2 强制类型转换（显式）
4. 运算符
5. ASCII编码表

---

1. 数据类型

1.1 基本数据类型
整数类型：byte、short、int、long
浮点类型：float、double
字符类型：char
布尔类型：boolean

1.2 引用数据类型（暂不要求掌握）
字符串、类、数组、接口、Lambda

1.3 注意事项

1. 字符串不是基本类型，而是引用类型。
2. 浮点型可能只是一个近似值，并非精确的值。
3. 数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4个字节，long是8字节。
4. 浮点数当中默认类型是double,如果一定要使用long类型，需要加上一个后缀L，推荐使用大写字母后缀，方便识别。

---

2. 变量

2.1 变量的概念及其应用
变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。

数学中，可以使用字母代替数字运算，例如：X=1+5，或者6=X+5。
程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的问题。比如X保存5，X也可以保存6，这样X保存的数据是可以改变的，也就是我们所讲解的变量。

Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。

public class HelloWorld{
	public static void main(String[] args){
		//创建一个变量
		//格式：数据类型 变量名;
		int num1;
		//向变量当中存入一个数据
		//格式：变量名称 = 数据值
		num1 = 10;
		// 当打印输出变量名称的时候，显示出来的是变量内容
		System.out.println(num1); // 10
		
		num1 = 20;
		System.out.println(num1);// 20
		
		int num2 = 25;
		System.out.println(num2);// 25
		
		num2 = 35;
		System.out.println(num2);// 35
		
		System.out.println("**************************");
		
		byte num3 = 30; //右边的数值范围不能超过左侧数据类型的取值范围（byte 取值范围为-128~127）
		System.out.println(num3);
		// 例如：byte num4 =(int)(400);  右侧数值超出了byte数据范围，错误！
		//  System.out.println(num4);   
		short num5 = 50; // 取值范围：-32768~32767
		System.out.println(num5);
		long num6 = 3000000000L;// 不加L无法运行，对于long常量，则要在整数的后面加上L
		System.out.println(num6);//3000000000
		
		float num7 = 2.5F;
		System.out.println(num7);// 2.5
		
		double num8 = 1.2;
		System.out.println(num8);// 1.2
		
		char zifu = 'A';
		System.out.println(zifu);// A
		
		zifu = '爱';
		System.out.println(zifu);// 爱
		
		boolean var1 = true;
		System.out.println(var);// true
		
		void1=false;
		System.out.println(var1);// false
		// 将一个变量的数据内容，赋值交给另一个变量
		// 右侧的变量名称var1已经存在，里面装的是false布尔量
		// 将右侧变量里面的false值，向左交给var2变量进行储存
		boolean void2 = var1;
		System.out.println(var2);// false
		System.out.println("2020080605036"+"luoxin");
	}	
}
		
	

2.2 注意事项

1. 如果创建多个变量，那么变量之间的名称不可以重复。
2. 对于float和long类型来说，字母后的F和L不要丢掉。
3. 如果使用byte和short类型的变量，那么右侧的数据值不能超过左侧的范围。
4. 没有进行赋值的变量，不能直接使用；一定要赋值之后，才能使用。
5. 变量的使用不能超过作用域的范围。
   【作用域】：从定义变量的第一行开始，一直到直接所属大阔号结束为止。
   6.可以通过一个语句来创建多个变量，但是一般情况不推荐这么写。

2.2.1 注意事项实例

public class HelloWorld{
	public static void main(String[] args){
		int num4;// 定义了一个变量，但是没有进行赋值
		//System.out.println(num4); //直接使用打印输出就是错误的！
		
		//System.out.println(var5); //在创建变量之前，不能使用这个变量
		
		int num5 = 500;
		System.out.println(num5);// 500
		
		{
			int num6 = 60;
			System.out.println(num6);
		}
		// int num6 = 60;
		// System.out.println(num6);// 已经超出大括号的范围，超出了作用域，变量不能再使用了
		
		//同时创建三个全都是int类型的变量
		int a,b,c;
		a=10;
		b=20;
		c=30;
		System.out.println(a); //10
		System.out.println(b); //20
		System.out.println(c); //30
		//同时创建三个int变量，并且同时各自赋值
		int x=100,y=200,z=300;
		System.out.println(x);// 100
		System.out.println(y);// 200
		System.out.println(z);// 300
		System.out.println("2020080605036"+"luoxin");
	}	
}

---

3. 数据类型转换

3.1 自动类型转换（隐式）

1. 特点：代码不需要进行特殊处理，自动完成。
2. 规则：数据范围从小到大。（与所占位数不一定相关）

public class HelloWorld{
	public static void main(String[] args){
		System.out.println(1024);// 这就是一个整数，默认就是int类型
		System.out.println(3.14);// 这就是一个浮点数，默认就是double类型
		
		//左边是long类型，右边是默认的int类型，左右不一样
		//一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行储存
		//int-->long,符合数据范围从小到大的要求
		//这一行代码发生了自动类型转换
		long num1 = 100;
		System.out.println(num1); //100
		
		
		//左边是double类型，右边是float类型，左右不一样
		//float-->double,符合从小到大的规则
		//也发生了自动类型转换
		double num2 = 2.5F;
		System.out.println(num2);//2.5
		
		
		//左边是float类型，右边是long类型
		//long-->float,范围float更大一些，符合从小到大的规则
		//也发生了自动类型的转换
		float num3 = 30L;
		System.out.println(num3);//30.0
		
		System.out.println("2020080605036"+"luoxin");
	}	
}

3.2 强制类型转换（显式）

注意事项：

1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
2. byte/short/char 这三种类型都可以发生数字运算，例如加法"+"。
3. byte/short/char 这三种类型在运算的时候，都会被首先提升为int类型，然后再计算。
4. 布尔类型（boolean）不能发生数据类型转换。

public class HelloWorld{
	public static void main(String[] args){
		//左边是int类型，右边是long类型，不一样
		// long-->int,不是从小到大
		//不能发生自动类型转换！
		//格式：范围小的类型 范围小的变量名 = (范围小的类型)原本范围大的数据;
		int num = (int)100L;
		System.out.println(num);// 100
		
		//long 强制转换为int类型
		int num2 = (int)6000000000L;
		System.out.println(num2); //1705032704 数据溢出（整数）
		
		//double-->int 强制类型转换
	    int num3 = (int)3.99;
		System.out.println(num3);//3  精度损失（不是四舍五入，所有的小数位都会被舍弃掉）
		
		
		char zifu1 = 'A';//这是一个字符型变量，里面是大写字母A
		System.out.println(zifu1+1);// 66 大写字母A被当做65处理了 
		// 计算机的底层会用一个数字（二进制），来代表字符A，也就是65
		// 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
		
		byte num4 = 40; //注意！ 右侧的数值大小不能超过左侧的类型范围
		byte num5 = 50;
		
		// byte + byte --> int + int --> int  提升了
		int result1 = num4 + num5;
		System.out.println(result1);// 90
		
		short num6 = 60;
		// byte + short --> int + int--> int
		// int强制转换为short，注意：必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
		short static2 =(short)(num6+num4);
		System.out.println(static2); // 100
		
		System.out.println("2020080605036"+"luoxin")
		
	}
}

---

4. 运算符

运算符： 进行特定操作的符号，例如： +
表达式： 用运算符连起来的式子叫做表达式。例如： 20 + 5 。又例如 ： a + b

四则运算：
加： +
减： -
乘： *
除： /

取模（余数）：%

public class HelloWorld{
	public static void main(String[] args){
		// 两个常量之间也可以进行数字运算
		System.out.println(20+30);
		
		// 两个变量之间的也可以进行数字运算
		
		int a = 20;
		int b = 30;
		System.out.println(a-b); // -10
		
		// 变量和常量之间可以混合使用
		System.out.println(a*10); // 200
		
		int x = 10;
		int y = 3;
		int result1 = x/y;
		System.out.println(result1); // 3
		
		int result2 = x%y;
		System.out.println(result2); // 余数， 模 ，1
		
		
		//int + double --> double + double --> double
		
		double result3 = x + 2.5;
		System.out.println("2020080605036"+"luoxin");
		
	}
}

注意事项

1. 一旦运算当中有不同类型的数据，那么结果将会是数据类型范围最大的那种（如上代码中的最后一种演示。）

2. 对于一个整数的表达式来说，除法用的是整数，整数除以整数，结果仍然是整数。只看商，不看余数。只有对于整数的除法来说，取模运算符才有余数的意义。

---

5.ASCII编码表