【Java基础知识】变量与常量、运算符

变量与常量

变量

在Java中每一个变量都有一个变量类型(type)，即先使用变量类型，再跟上一个变量名。

变量名必须是以字母开头，并由字母或者数字构成的序列，字母包括’A’~‘Z’,‘a’~‘z’,‘_’,‘$’,或者在某些语言中表示字母的任何Unicode字符，数字包括’0’~‘9’，不能使用空格或者运算符，并且大小写敏感：不同大小写代表不同变量名。

double salary;
int num;

Java 保留字 | 关键字也不能作为变量名。关键字：

声明了一个变量后，必须用赋值语句进行显示初始化，不然会报错。

int num;
System.out.println(num); // error: java: 可能尚未初始化变量num

赋值方法有多种，常用的有两种：(1)先声明再赋值，(2)在声明时就赋值。
变量的声明尽量靠近第一次使用的地方，这是一种良好的编写风格。

//  先声明再赋值       
int num;
num = 100;
//  在声明时就赋值     
double d = 100.12

常量

在 Java中使用 final 关键字指示常量，关键字在被赋值后就不能改变，习惯上使用大写字母表示。

final int N = 100000; // N 值不能被改变

如果想要这个变量在多个方法使用，可以将其称为 类常量 .可以使用关键字 static final 设置一个类常量,方法的声明只能在类上，不能在方法里面声明。否则会报 非法的表达式开始 的错误。

public static final int MAX = 999999;

public static void main(String[] args) {
	// 在 main函数里面声明 static 会报非法的表达式开始的错误
    static final int MAX = 10000; 
}

还有一种特殊的类就是枚举类型，类中的所有字段都是一个 类常量，后面我们细说。

enmu Size{ SMALL, MEDIUM, LARGE }

运算符

算数运算符

算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。

运算符	运算	示例	结果
+	正号	+7	7
-	负号	a=7;b=-a	a=7;b=-7
+	加号	a=7;b= a+a	a=7;b=14
-	减号	a=7;b=15-a	a=7;b=8
*	乘号	a=7;b=2*a	a=7;b=14
/	除号	a=7;b=a/7	a=7;b=1
%	取模(余)	a=7;b=a%3	a=7;b=1
++(左)	左自增：先运算,再取值	a=7;b=++a	a=8;b=8
++(右)	右自增：先取值,再运算	a=7;b=a++	a=8;b=7
- -(左)	左自减：先运算,再取值	a=7;b=- -a	a=6;b=6
- -(右)	右自减：先取值,再运算	a=7;b=a- -	a=6;b=7
+	字符串拼接	a=“hello”;b=a+“world”	a=“hello”;b=“helloworld”

关系运算符 | 比较运算符

关系运算符的结果都为 boolean 型，是 true 或者 false，常用于判断或者循环语句。

运算符	运算	示例	结果
==	等于	8 == 7	false
!=	不等于	8 != 7	true
>	大于	8 > 7	true
<	小于	8 < 7	false
>=	大于等于	1 >= 2	false
<=	小于等于	3 <= 2	false
instanceof	判断一个对象是否是类对象	“hello” instanceof String	true

逻辑运算符

用于连接多个条件，进行运算。

1、连接的条件都为boolean类型分为：短路与（&&），短路或（||），取反（!），逻辑与（&） 逻辑或（|），逻辑异或（^）

a	b	a&&b	a||b	!a	a&b	a|b	a^b
true	true	true	true	false	true	true	false
true	false	false	true	false	false	true	true
false	true	false	true	true	false	true	true
false	false	false	false	true	false	false	false

这里需要注意的是：
(1) 在进行 短路与(&&) 时，如果前面个表达式为 false 了，答案就已经为 false，后面个表达式就不再进行了
(2) 在进行 短路或(||) 时，如果前面个表达式为 true 了，答案就已经为 true，后面个表达式就不再进行了
(3) 在进行 逻辑与（&） 逻辑或（|），逻辑异或（^）不管前面表达式是什么，后面表达式依然进行运算

int a = 1, b = 2;
if(++a > 3 && ++b < 2) {}
System.out.println(a + " " + b); // a = 2, b = 2

int c = 1, d = 2;
if(++c > 0 || ++d < 1) {}
System.out.println(c + " " + d); // c = 2, d = 2

int e = 1, f = 2;
if(++e > 3 & ++f < 2) {}
System.out.println(e + " " + f); // e = 2, f = 3

int m = 1, n = 2;
if(++m > 0 | ++n < 1) {}
System.out.println(m + " " + n); // m = 2, n = 3

2、逻辑与（&） 逻辑或（|），逻辑异或（^），取反（~）还可以运用于两个数字，其逻辑是数字对应的二进制进行运算，1 对应 true，0 对应 false。

这里注意与boolean的取反（!）注意区别，虽然说逻辑大致相同，但运算符号与运算的对象不同。
计算机在底层进行运算时都是使用的补码进行运算，因为正数的原码与补码相同，但是负数的原码与补码不相同，需要特别注意。
原码：最高位为符号位，其余为对应数值的绝对值的二进制。 如 ：int a = -1；a原码因该是：1000 0000 0000 0000 0000 0000 0000 0001.
反码：正数的反码等于原码，负数的反码为在原码基础上，符号位不变，其余取反。如 int a = -1; 补码应该是：1111 1111 1111 1111 1111 1111 1111 1110.
补码：正数的补码等于原码，负数的补码为：在反码的基础，符号位不变，其余+1。如int a = -1 的补码应该是 1111 1111 1111 1111 1111 1111 1111 1111.
由补码到原码也是反向的原理：正数的补码等于原码，负数的补码到原码为 补码-1然后符号位不变，其余取反。

int a = 0B111, b = -0B100; // 这里描述的都是原码
// a 的补码为 0000 ... 0000 0111
// b 的补码为 1111 ... 1111 1100
// a&b的补码为0000 ... 0000 0100
// a&b的原码为0000 ... 0000 0100 即 4
// a|b的补码为1111 ... 1111 1111
// a|b的原码为1000 ... 0000 0001 即 -1
// a^b的补码为1111 ... 1111 1011
// a^b的原码为1000 ... 0000 0101 即 -5
// ~a 的补码为1111 ... 1111 1000
// ~a 的原码为1000 ... 0000 1000 即 -8
System.out.println(a & b); // 4
System.out.println(a | b); // -1
System.out.println(a ^ b); // -5
System.out.println(~a); // -8

3、位运算：左移（<<） 右移（>>） 无符号右移（>>>）

都是基于数字的二进制的.
(1)左移(<<) 高位舍去,低位填0；
(2)右移(>>) 高位正数填0，负数填1，低位舍去；
(3)无符号右移(>>>) 高位填0，低位舍去。
(4)！不存在无符号左移，即不存在(<<<)这个操作。
左移其实就是乘2操作，右移其实就是除2操作，但是都要小心越界的情况。
在使用无符号右移时不要对负数使用，应该对无符号数使用，即正数，不然运算结果会天差地别。

// (1)算术左移===========
int c = -0B110; // 描述原码 -6
// c补码为    1111 ... 1111 1010
// c<<2补码为 1111 ... 1110 1000
// c<<2原码为 1000 ... 0001 1000 即-24
System.out.println(c<<2); // -24
// ====================越界情况====================
// int的最大值 二进制为 0111 1111 ... 1111 1111 一共32位
int max = Integer.MAX_VALUE; // 2147483647
// max 的补码  0111 1111 ... 1111 1111
// max<<2的补码1111 1111 ... 1111 1100 这里移动的高位舍去
// max<<2的原码1000 0000 ... 0000 0100
System.out.println(max << 2); // -4
// int的最小值 二进制位 1000 0000 ... 0000 0000 一共32位
// 这里是计算机的特殊处理，在最开始
// 0000 0000 ... 0000 0000 代表数字 0
// 1000 0000 ... 0000 0000 也代表数字0
// 为了避免重复与合理利用，将 1000 0000 ... 0000 0000 代表int的最小值即 -2147483648
int min = Integer.MIN_VALUE;
// min 的原码 1000 0000 ... 0000 0000
// min 的补码 0000 0000 ... 0000 0000，由1 0000 0000 ... 0000 0000高位舍去  
// min<<2的补码 0000 0000 ... 0000 0000 不管移多少位都是 0
// min<<2的原码 0000 0000 ... 0000 0000
System.out.println(min << 2); // 0

//(2)算术右移,算术右移没有越界情况 都是除2
int a = 0B1101; // 13
System.out.println(a >> 1); // a / 2 = 6

//(3)无符号右移
int a = 0B0010; // 2
// a的补码     0000 0000 ... 0000 0010
// a>>>1的补码 0000 0000 ... 0000 0001
// a>>>1的原码 0000 0000 ... 0000 0001
System.out.println(a >>> 1); // 1
// =======对负数使用=========
int b = -0B0010; // -2
// b的原码     1000 0000 ... 0000 0010
// b的补码     1111 1111 ... 1111 1110
// b>>>1的补码 0111 1111 ... 1111 1111
// b>>>1的原码 0111 1111 ... 1111 1111 => 这个是int的最大值
System.out.println(b >>> 1); // 2147483647

赋值运算符

基本运算符： $=$； 复合运算符：$+=，-=，\ast =，/=，\%=$

// 基本运算符 =
int a = 10;
// 复合运算符
a += 10; // => 相当于 a = a + 10;
a -= 10; // => 相当于 a = a - 10;
a *= 10; // => 相当于 a = a * 10;
a /= 10; // => 相当于 a = a / 10;
a %= 10; // => 相当于 a = a % 10;
System.out.println(a); // a = 0;

三元运算符

基本语法为：条件表达式 ？ 表达式1 ： 表达式2；
运算规则：如果条件表达式为 true ，运算结果为 表达式1；

int a = 10 > 8 ? 10 : 8; // a = 10

运算符优先级

数学函数与常量

在 Math 类中，包含了各种各样的数学函数。
计算平方根：$Math.sqrt(num)$

double x = 4;
double y = Math.sqrt(x);
System.out.println(y); // y = 2.0;

计算幂运算：$Math.pow(x,y)$
常用三角函数：
$Math.sin$
$Math.cos$
$Math.tan$
$Math.atan$
$Math.atan2$

指数函数，以及反函数-自然对数和以10为底的对数：
$Math.exp$
$Math.log$
$Math.log10$

用于表示 $\pi$ 和 $e$ 常量的近似值
$Math.PI$
$Math.E$

总结一下：如果计算机底层的二进制不够熟悉的可以了解一下计算机组成原理，但位移运算一般在底层开发与算法设计使用较多，只需要理解清楚即可。都是 Java的基础知识，慢慢打牢基础还是特别重要的。