Day02 Java基础语法（数据类型、常量、变量、数据类型转换、运算符）

一、程序

1.1 程序概述

软件是什么？其实软件就是用来处理数据的程序。可以把软件分为两个部分，一个部分是“数据”；另一个部分是“数据处理的逻辑”。
程序 = 数据 + 逻辑
什么是数据？用电商来举例，用户就是数据，商品也是数据。
那么什么是数据处理逻辑呢？购买商品的流程就是数据处理逻辑了。
程序开发离不开数据，其实说白了程序就是用来处理数据的。在Java中我们要学习数据的类型及数据量。
通常数据是会发生变化的，而数据的处理逻辑是不发生变化的。例如商品的数量种类是会变化的，用户的数量也是会变化的，但购买的流程通常不会变化。

1.2 数据类型

1.2.1 数据类型分类

Java的数据类型分为两大类：

• 基本数据类型：包括整数、浮点数、字符、布尔 。
• 引用数据类型：包括类、数组、 接口 。

1.2.2 基本数据类型

四类八种基本数据类型：

数据类型	数据类型	内存占用	取值范围
字节型	byte	1个字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int（默认）	4个字节	-231次方~2的31次方-1
长整型	long	8个字节	-2的63次方~2的63次方-1
单精度浮点数	float	4个字节	1.4013E-45~3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324~1.7977E+308
字符型	char	2个字节	0-65535
布尔类型	boolean	1个字节	true，false

Java中的默认类型：整数类型是 int 、浮点类型是 double 。
long类型：建议数据后加 L 表示。
float类型：建议数据后加 F 表示。

[*:当心数值超出int类型最大边界 注意使用long类型，否则会丢失精度]
一年的毫秒数：365L * 24 * 60 * 60 * 1000

1.3 常量

1.3.1 概述

是指在Java程序中固定不变的数据。

1.3.2 分类

类型	含义	数据举例
整数常量	所有的整数	0，1， 567， -9
小数常量	所有的小数	0.0， -0.1， 2.55
字符常量	单引号引起来,只能写一个字符,必须有内容	‘a’ ，‘好’
字符串常量	双引号引起来,可以写多个字符,也可以不写	“A” ，“Hello” ，“你好” ，“”
布尔常量	只有两个值（流程控制中讲解）	true ，false
空常量	只有一个值（引用数据类型中讲解）	null
其中整数类型可以有多种表示形式

• 十进制表示方式：正常数字 如 13、25等
• 二进制表示方式：以0b(0B)开头 如0b1011 、0B1001
• 十六进制表示方式：以0x(0X)开头 数字以0-9及A-F组成 如0x23A2、0xa、0x10
• 八进制表示方式：以0开头 如01、07、0721

其中字符类型可以有多种表示形式

• char c = ‘\t’; //转义字符，打印为 Tab键的效果
• char c = 55; //通过ascii编码进行赋值，打印为 7
• char c = ‘\u4e2d’ //通过Unicode编码进行赋值，打印为 中

1.4 变量

1.4.1 概述

常量是固定不变的数据，那么在程序中可以变化的量称为变量。
Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。
结论：变量是内存中装载数据的小盒子，你只能用它来存数据和取数据变量；必须要有明确的类型，什么类型的变量装载什么类型的数据。。

1.4.2 变量的定义

格式：

数据类型 变量名 = 数据值;

例子:

public class Variable {
	public static void main(String[] args){
		//定义字节型变量
		byte b = 100;
		//定义短整型变量
		short s = 1000;
		//定义整型变量
		int i = 123456;
		//定义长整型变量
		long l = 12345678900L;
		//定义单精度浮点型变量
		float f = 5.5F;
		//定义双精度浮点型变量
		double d = 8.5;
		//定义布尔型变量
		boolean bool = false;
		//定义字符型变量
		char c = 'A';
	}
}

1.4.3 变量使用的注意事项

• 变量定义后可以不赋值，使用时再赋值。不赋值不能使用。

public static void main(String[] args) {
	int x;
	x = 20; //为x赋值20
	System.out.println(x);//读取x变量中的值，再打印
}

• 变量使用时有作用域的限制。

public static void main(String[] args) {
	int x = 20;
{
    int y = 20;
}
	System.out.println(x);//读取x变量中的值，再打印
	System.out.println(y);//读取y变量中的值失败，失败原因，找不到y变量，因为超出了y变量作用范围，所以不能使用y变量
}

• 变量不可以重复定义。

public static void main(String[] args){
      int x = 10;
      double x = 5.5;//编译失败，变量重复定义
}

1.4 数据类型转换

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

1.4.1 自动转换

一个 int 类型变量和一个 byte 类型变量进行加法运算， 结果会是什么数据类型？

public static void main(String[] args) {
	int i = 1;
	byte b = 2;
	// byte x = b + i; // 报错
	//int类型和byte类型运算，结果是int类型
	int j = b + i;
	System.out.println(j);//int类型的3
}

运算结果，变量的类型将是 int 类型，这就是出现了数据类型的自动类型转换现象。

• 自动转换：将 取值范围小的类型 自动提升为 取值范围大的类型 。
• 格式：

范围大的数据类型 变量 = 范围小的数据类型值
double d = 1000;
或
int i = 100;
double d2 = i;

转换原理图解

byte 类型内存占有1个字节，在和 int 类型运算时会提升为 int 类型 ，自动补充3个字节，因此计算后的结果还是 int 类型。

同样道理，当一个 int 类型变量和一个 double 变量运算时， int 类型将会自动提升为 double 类型进行运算。

public static void main(String[] args) {
	int i = 1;
	double d = 2.5;
	//int类型和double类型运算，结果是double类型
	//int类型会提升为double类型
	double e = d+i;
	System.out.println(e);//double类型的3.5
}

转换规则

范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int 。
byte -> short -> int -> long -> float -> double

byte 和 char 之间永远需要互相强转
char 类型和 short 类型之间永远需要互相强转

1.4.2 强制转换

将 1.5 赋值到 int 类型变量会发生什么？产生编译失败，肯定无法赋值。

	int i = 1.5; // 错误

double 类型内存8个字节， int 类型内存4个字节。 1.5 是 double 类型，取值范围大于 int 。可以理解为 double 是8升的水壶， int 是4升的水壶，不能把大水壶中的水直接放进小水壶去。
想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成 int 类型才能赋值。

• 强制类型转换：将 取值范围大的类型 强制转换成 取值范围小的类型 。

比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

• 格式

数据类型 变量名 = （数据类型）被转数据值

将 1.5 赋值到 int 类型，代码修改为：

	// double类型数据强制转成int类型，直接去掉小数点。
	int i = (int)1.5;

同样道理，当一个 short 类型与 1 相加，我们知道会类型提升，但是还想给结果赋值给short类型变量，就需要强制转换。

	public static void main(String[] args) {
		//short类型变量，内存中2个字节
		short s = 1;
		/*
		出现编译失败
		s和1做运算的时候，1是int类型，s会被提升为int类型
		s+1后的结果是int类型，将结果在赋值会short类型时发生错误
		short内存2个字节，int类型4个字节
		必须将int强制转成short才能完成赋值
		*/
		s = s + 1；//编译失败
		s = (short)(s+1);//编译成功
	}

转换原理图解

强烈注意

• 浮点转成整数，直接取消小数点，可能造成数据损失精度。
• int 强制转成 short 砍掉2个字节，可能造成数据丢失。

// 定义s为short范围内最大值
short s = 32767;
// 运算后，强制转换，砍掉2个字节后会出现不确定的结果
s = (short)(s + 10);

5.4.3 ASCII编码表

	public static void main(String[] args) {
		//字符类型变量
		char c = 'a';
		int i = 1;
		//字符类型和int类型计算
		System.out.println(c+i);//输出结果是98
	}

在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念。

• 编码表 ：就是将人类的文字和一个十进制数进行对应起来组成一张表格。

字符	数值
0	48
9	57
A	65
Z	90
a	97
z	122

• 将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII（
  American Standard Code for Information Interchange 美国标准信息交换码）。

在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。char类型提升为了int类型。char类型内存2个字节，int类型内存4个字节。

二、运算符

2.1 算术运算符

运算符是用来计算数据的符号。数据可以是常量，也可以是变量。被运算符操作的数我们称为操作数。
算术运算符最常见的操作就是将操作数参与数学计算，具体使用看下图：

运算符	运算规则	范例	结果
+	正号	+3	3
+	加	2+3	5
+	连接字符串	“中”+“国”+‘强’	“中国强”
-	负号	int a=3;-a	-3
-	减	3-1	2
*	乘	2*3	6
/	除	5/2	2
%	取模，两个数字相除取余数	5%2	1
++	自增	int a=1;a++/++a	2
–	自减	int a=3;a–/–a	2
我们在使用算术运算符时，记得要注意下列事项：

• 加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。
• 除法“/”当两边为整数时，取整数部分，舍余数。当其中一边为浮点型时，按正常规则相除。
• “%”为整除取余符号，小数取余没有意义。结果符号与被取余符号相同。
• 整数做被除数，0不能做除数，否则报错。
• ++，--运算符后置时，先使用变量a原有值参与运算操作，运算操作完成后，变量a的值自增1或者自减1；
• ++，--运算符前置时，先将变量a的值自增1或者自减1，然后使用更新后的新值参与运算操作。

2.2 赋值运算符

赋值运算符就是为变量赋值的符号，如 a+=2 也就是为 a = a + 2

运算符	运算规则	范例	结果
=	赋值	int a=2	2
+=	加后赋值	int a=2，a+=2	4
-=	减后赋值	int a=2，a-=2	0
*=	乘后赋值	int a=2，a*=2	4
/=	整除后赋值	int a=2，a/=2	1
%=	取模后赋值	int a=2，a%=2	0
注意：诸如+=这样形式的赋值运算符，会将结果自动强转成等号左边的数据类型。
如：

	short s = 1;
	s+=1;//等价于 s = (short)(s+1); 结果为2

2.3 比较运算符

比较运算符，又叫关系运算符，它是用来判断两个操作数的大小关系及是否相等关系的，结果是布尔值 true 或者 false。

运算符	运算规则	范例	结果
==	相等于	4==3	false
!=	不等于	4!=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true

2.4 逻辑运算符

用于布尔值进行运算的，运算的最终结果为布尔值 true 或 false。

运算符	运算规则	范例	结果
&	与	false&true	false
|	或	false|true	true
^	异或	true^flase	true
!	非	!true	flase
&&	短路与	false&&true	false
||	短路或	false||true	true

&& 短路与

• 两边都是true，结果是true
• 一边是false，结果是false
• 短路特点：符号左边是false，右边不再运算

|| 短路或

• 两边都是false，结果是false
• 一边是true，结果是true
• 短路特点： 符号左边是true，右边不再运算

2.5 按位运算符

从现代计算机中所有的数据二进制的形式存储在设备中。即0、1两种状态，计算机对二进制数据进行的运算(+、-、*、/)都是叫位运算，即将符号位共同参与运算的运算。

符号	描述	运算规则
&	与	两个位都为1时，结果才为1
|	或	两个位都为0时，结果才为0
^	异或	两个位相同为0，相异为1
~	取反	0变1，1变0
<<	左移	各二进位全部左移若干位，高位丢弃，低位补0
>>	右移	各二进位全部右移若干位，对无符号数，高位补0，有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补0（逻辑右移）

2.5.1 按位与运算符（&）

定义：参加运算的两个数据，按二进制位进行“与”运算。

运算规则：逢0写0

0&0=0 0&1=0 1&0=0 1&1=1

总结：两位同时为1，结果才为1，否则结果为0。
例如：9 & 5即
 0000 1001
 &
 0000 0101
 =
 0000 0001
9 & 5结果为十进制的1

扩展：& 在某些情况下取代 %
x % 2^(n) 等价于 x & 2^(n)-1

2.5.2 按位或运算符（|）

定义：参加运算的两个对象，按二进制位进行“或”运算。

运算规则：逢1写1

0|0=0 0|1=1 1|0=1 1|1=1

总结：参加运算的两个对象只要有一个为1，其值为1。
例如：9 | 5即
 0000 1001
 |
 0000 0101
 =
 0000 1101
9 | 5结果为十进制的13

2.5.3 异或运算符（^）

定义：参加运算的两个数据，按二进制位进行“异或”运算。

运算规则：

0^0=0  0^1=1   1^0=1   1^1=0

总结：参加运算的两个对象，如果两个相应位相同为0，相异为1。
例如：9 ^ 5即
 0000 1001
 ^
 0000 0101
 =
 0000 1100
9 ^ 5结果为十进制12

扩展： ^ 可以再不借助第三块空间的方式交换两个变量的值
只能交换boolean char byte short int long

		int x = 45;
		int y = 90;

		//创建第三方交换
		int z = x;
		x = y;
		y = z;

		//不创建第三方：
		x = x ^ y;
		y = x ^ y;
		x = x ^ y;

2.5.4 取反运算符 (~)

定义：参加运算的一个数据，按二进制进行“取反”运算。
运算规则：

~1=0   ~0=1

总结：对一个二进制数按位取反，即将0变1，1变0。
例如：byte x = 9;
求: ~x;
9的二进制：  00001001
取反：   1111 0110
-1的二进制：1111 1111
拿-1的二进制与取反后的二进制相比较，在-1的基础上减去不同位的值。
即 -1-8-1 = -10

2.5.5 左移运算符（<<）

定义：将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。
设 a=1010 1110，a = a<< 2 将a的二进制位左移2位、右补0，即得a=1011 1000。
若左移时舍弃的高位不包含1，则每左移一位，相当于该数乘以2。

2.5.6 右移运算符（>>）

定义：将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。
例如：a=a>>2 将a的二进制位右移2位，左补0 或者 左补1得看被移数是正还是负。
操作数每右移一位，相当于该数除以2。

<<相当于乘以 >>相当于除以
移动多少位 相当于乘以/除以2的几次方数

*2	*4	*8	*16.....  *2(n)
<<1	<<2	<<3	<<4.....  <<n

/2	/4	/8	/16.....  /2(n)
>>1	>>2	>>3	>>4.....  >>n

>>和>>>之间的区别？
	>>叫做有符号右移 移动之后空缺的高位看原本的
	符号位
	>>>叫做无符号右移 移动之后空缺的高位直接补0

2.6 三元运算符

2.6.1 格式：

数据类型 变量名 = 布尔类型表达式？结果1：结果2

2.6.2 三元运算符计算方式：

布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

2.7 运算符优先级

优先级	描述	运算符
1	括号	()、[]
2	正负号	+、-
3	自增自减，非	++、--、!
4	乘除，取余	*、/、%
5	加减	+、-
6	移位运算	<<、>>、>>>
7	大小关系	>、>=、<、<=
8	相等关系	==、!=
9	按位与	&
10	按位异或	^
11	按位或	|
12	逻辑与	&&
13	逻辑或	||
14	条件运算	?:
15	赋值运算	=、+=、-=、*=、/=、%=
16	位赋值运算	&=、|=、<<=、>>=、>>>=

扩展：常量和变量的运算

	public static void main(String[] args){
		byte b1=1;
		byte b2=2;
		byte b3=1 + 2;
		/*	1 和 2 是常量，为固定不变的数据，在编译的时候（编译器javac），
			已经确定了 1+2 的结果并没有超过byte类型的取值范围，可以赋值给变量 b3 ，
			因此 b3=1 + 2 是正确的*/
		byte b4=b1 + b2;
		/*	b1 和 b2 是变量，变量的值是可能变化的，在编译的时候，
		编译器javac不确定b1+b2的结果是什么，因此会将结果以int类型进行处理，
		所以int类型不能赋值给byte类型，因此编译失败。*/
		System.out.println(b3);//3
		System.out.println(b4);//编译报错
	}