JAVA之变量和运算符

一、变量和类型 1.0 变量与常量

常量指的是运行时类型不能发生改变，主要有两种体现形式：
1.字面值常量

如：10,int 十进制字面值常量，010,int,八进制字面值常量

2.final 关键字修饰的常量

final int a = 10; 
a = 20; // 编译出错. 提示 无法为最终变量a分配值

常量不能在程序运行过程中发生修改

变量是指程序运行时可变的量，相当于开辟一块内存空间来储存数据

类型名称	字节空间
byte	1字节（8位）
short	2字节（16位）
int	4字节（32位）
float	4字节（32位）
long	8字节（64位）
double	8字节（64位）
char	2字节（16位）
boolean	1字节（8位）

1.1 整形变量(int)

int num=1;//定义一个整型变量
System.out.println(num);

整型数据范围：-2^31 -> 2^31-1
使用场景：存储普通整数
注意：当运算结果超过int最大范围就会出现溢出情况

1.2 长整型变量（long）

long num=10L;//定义一个长整型变量，初始值写作10l（l大小写皆可）;
System.out.println(num);

数据范围： -2^63 -> 2^63-1
使用场景：足够绝大部分工程场景
注意：使用10初始化也可以，10的类型是int，10l的类型是long，使用10l比10更好

1.3 双精度浮点型变量（double）

double num=1.0;
System.out.println(num);

数据范围：由于浮点数内存布局和整数差别很大，不能单纯的用2^n表示
使用场景：存储双精度浮点数

1.4 单精度浮点型变量（float）

float num=1.0f;//写作1.0F也行
System.out.println(num);

使用场景：存储浮点数
对于浮点型一般使用double，不推荐使用float

1.5 字符型变量（char)

char ch='A';
System.out.println(ch);

Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文

1.6字节类型变量（byte)

byte value=0;
System.out.println(value);

数据范围：-128->127
使用场景：存储字节数据
注意：字节类型和字符类型互不相关

1.7 短整型变量（short）

short value=0;
Sytem.out.println(value);

数据范围：-32768 -> +32767
使用场景：兼容性考虑（很少使用）

1.8 布尔类型变量(boolean)

boolean value=true;
System.out.println(value);

boolean 类型的变量只有两种取值, true 表示真, false 表示假，默认为false
Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定

1.9 字符串类型变量（string)

string name="zhangshan";
System.out.println(name);

注意：string不是基本类型，而是引用类型.由于字符串中一些特定不方便表示需要进行转义
转义字符.

转义字符	解释
n	换行
t	水平制表符
’	单引号
"	双引号
\	反斜杠

1.9.1 字符串拼接

String a = "hello"; 
String b = "csdn"; 
String c = a + b; 
System.out.println(c); 
String str = "result = "; 
//字符串和整数进行拼接
int n = 10; 
int m = 20; 
String result = str + n + m; 
System.out.println(result); 
// 执行结果
result = 1020 

任何类型的数据和字符串进行拼接，其结果都是一个字符串

1.10 变量的作用域

class Test { 
 public static void main(String[] args) { 
 { 
 int x = 10; 
 System.out.println(x); // 编译通过; 
 } 
 System.out.println(x); // 编译失败, 找不到变量 x. 
 } 
} 

变量的作用域一般是变量定义在的代码块，大括号内.

二、变量之间的相互转换 2.1 int和long/double相互赋值

int a=10;
long b=20;
a=b;//编译出错，提示会损失精度
b=a;//编译通过
int c=10;
double d=1.0;
c=d;//编译出错，提示会损失精度
d=c;//编译通过

long和double表示的范围相对int而言表示的范围更大，可以将int赋值给long和double，但是不能讲double和long赋值给int.
不同数字类型的变量之间赋值，表示范围更小的类型能隐式转换为范围较大的类型，反之不行，需要强制类型转换，强制类型转换可能会导致精度丢失.

2.2 int和boolean相互赋值

int a=10;
boolean b=true;
b=a;//编译出错
a=b;//编译出错

int和boolean是毫无相关的两种类型，不能相互赋值

2.3 int字面值常量给byte赋值

byte a=100;//编译通过
byte b=256;//编译出错，从int转换为byte可能有损失

byte表示的数据范围是-128 -> +127

2.4数值提升 2.4.1 int和long混合运算

int a=10;
long b=20;
int c=a+b;//编译出错，提升将long转成int损失精度
int c=(int)(a+b);
long d=a+b;

当long和int混合运算时候，int会提升为long，得到的结果为long类型，如果非要用int来接受结果，需要用强制类型转换.

2.4.2 byte和byte运算

byte a = 10; 
byte b = 20; 
byte c = a + b; 
System.out.println(c); // 编译报错
byte a = 10; 
byte b = 20; 
byte c = (byte)(a + b); 
System.out.println(c);//编译正确

由于计算机cpu通常都是按照4个字节为单位读取数据，在计算a+b时候会将a和b提升为int，得到结果是int.

2.5 int和string之间的相互转换 2.5.1 int转成string

int num = 10; 
String str1 = num + ""; // 方法1 
String str2 = String.valueOf(num); // 方法2 

2.5.2 string转成int

String str = "100"; 
int num = Integer.parseInt(str); 

三、运算符 3.1 算数运算符

基本四则运算符：±*/%

int a=1;
int b=2;
int c=0;
System.out.println(a+b);//结果为3
System.out.println(a-b);//结果为-1
System.out.println(a*b);//结果为2
System.out.println(a/b);//结果为0
System.out.println(a/c);//运行错误

int/int结果还是int，所以这里计算结果为0，需要使用double来运算;
0不可以作为除数;
取余符号：%，不仅可以对int求模，也能对double求模;

System.out.println(11.5 % 2.0); // 运行结果1.5 
System.out.println(10 % -3); // 运行结果1 
System.out.println(-10 % -3); // 运行结果-1
System.out.println(-10 % 3); // 运行结果-1

增量赋值运算符 *%= += -= = /=

int a = 10; 
a += 1; // 等价于 a = a + 1 
System.out.println(a); 

自增自减运算符++ –

int a = 10; 
int b = ++a; //结果为11
System.out.println(b); 
int c = a++; 
System.out.println(c); 结果为10

.如果不取自增运算的表达式的返回值, 则前置自增和后置自增没有区别.

int a=10;
++a;
System.out.println(a);

如果取表达式的返回值, 则前置自增的返回值是自增之后的值, 后置自增的返回值是自增之前的值

3.2 关系运算符（== != < > <= >=）

int a = 10; 
int b = 20; 
System.out.println(a == b); //结果false
System.out.println(a != b); //结果false
System.out.println(a < b); //结果true
System.out.println(a > b); //结果false
System.out.println(a <= b); //结果为true
System.out.println(a >= b); //结果为false

关系运算符的表达式返回值都是boolean类型，返回值不是true，就是false

3.3 逻辑运算符（&& || !）

操作数1	操作数2	运算符	结果
true	true	&&	true
true	false	&&	false
false	false	&&	false
true	true	||	true
true	false	||	true
false	false	||	false

操作数	运算符	结果
true	!	false
false	!	true

逻辑运算符的操作数和返回值都是 boolean .
逻辑与&&

int a=1;
int b=2;
int c=3;
System.out.println(a 
都是true，则为true，否则为false
 逻辑或||
 
int a=1;
int b=2;
int c=3;
System.out.println(a 
都是false，为false，否则为true;
 逻辑非！
 
int a = 10; 
int b = 20; 
System.out.println(!a < b); 
 
操作数为 true, 结果为 false; 操作数为 false, 结果为 true(这是个单目运算符, 只有一个操作数).
 短路求值
 
System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false 
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true 
 
3.4 位运算符（& | ~ ^） 
操作数1
操作数2
运算符
结果
1
1
&
1
1
0
&
0
0
0
&
0
1
1
|
1
1
0
|
1
0
0
|
0
0
0
^
0
1
1
^
0
1
0
^
1
 
操作数
运算符
结果
1
~
0
0
~
1
位操作表示按二进制位运算
 按位与& ：两个二进制位都是1，则结果都是1，否则结果为0
 按位或：如果两个二进制都是0，则结果为0，否则为1
 当&和|的操作数为整数时，表示按位运算，当操作数为boolean时表示逻辑运算
 按位取反~：: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1
 
3.5 移位运算（<< >> >>>） 
左移 <<: 最左侧位不要了, 最右侧补 0.
 
int a = 0x10; 
System.out.printf("%xn", a << 1); 
// 运行结果(注意, 是按十六进制打印的) 
20 
 
右移 >>: 最右侧位不要了, 最左侧补符号位（0正数补0，负数补1）
 
int a = 0x10; 
System.out.printf("%xn", a >> 1); 
// 运行结果(注意, 是按十六进制打印的) 
8 
 
int b = 0xffff0000; 
System.out.printf("%xn", b >> 1); 
// 运行结果(注意, 是按十六进制打印的) 
ffff8000 
 
无符号右移 >>>: 最右侧位不要了, 最左侧补 0.
 
int a = 0xffffffff; 
System.out.printf("%xn", a >>> 1); 
// 运行结果(注意, 是按十六进制打印的) 
7fffffff 
 
无符号左移<<<：无
 
3.6 条件运算符 
int a = 10; 
int b = 20; 
int max = a > b ? a : b;
 
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.