Java变量和运算符详解

Java变量和运算符

已在思维导图中对变量知识框图进行整理！

使用markdown进行详细记录

分以下几点进行介绍：

变量基本原理
基本类型和引用类型变量
变量使用和注意事项
运算符

1. 变量基本原理

1.1 变量概念

变量表示内存中一块数据存储区域，可以使用变量名访问该存储区域，获取变量值或修改变量值。

变量三要素：数据类型+变量名+值 -----> int a = 10；int数据类型，a变量名，10变量值

变量a指向存储值10的地址，当然，变量a和10都存储在栈上存储区域

1.2 变量注意事项

表示内存中一块存储区域，变量类型不同，占用空间不同，例如数据类型int占4个字节；
该区域有确定的数据类型和变量名；
变量必须先声明，再赋值，然后才能使用，或者一步到位，直接初始化赋值；声明：int a，赋值a = 10，之后才能使用a变量，或者int a = 10，声明和赋值一起，即初始化，才能使用
该存储区域中的数据可以在同一种数据类型的范围变化；int a = 10；a = 20对a的值进行修改，20在int范围之内，所以只要a的值在int范围内，可以随意修改
变量名在同一作用域下不能重复；比如在同一代码块，或者子代码块中，不能重复

2. 基本数据类型和引用数据类型

2.1 基本数据类型

包含：boolean、byte、char、short、int、long、float、double八种

整数类型：byte（1个字节）、char（2个字节）、short（2个字节）、int（4个字节）、long（8个字节）

浮点类型：float（4个字节）、double（8个字节）

布尔类型：boolean（true和false）1个字节

基本数据类型自动和强制转型

向上转型：

byte–>short–>int–>long–>float–>double

char–>int–>long–float–double

char和byte、char和short无自动类型转换

向下转型，即强制类型转换：

由高精度向低精度，由占字节多的向占字节少的转型，需要强制转型。

整型默认使用int类型，浮点数默认使用double类型，如下：

System.out.println(10);//10默认为int型
System.out.println(10.23);//10.23默认为double型
short s1 = 10;//如果赋的是确定的值（常量），判断常量在不在short范围，如果在赋值成功，如果不在，赋值失败
short s2 = s1 + 10;//错误！10默认为int类型，s1和int相加，s1由short自动提升为int类型，两者相加结果为int类型，再赋值给s2时出错，int->short，向下转型，丢失精度，要进行强制转换
short s2 = (short)(s1 + 10);//正确
long l1 = 1024；//1024为int类型，向上转型赋值给long
long l2 = 1024l;//这样表示将long类型值赋值给long 需要加l或Lfloat f1 = 10.23;//10.23在float范围，赋值正确 或者10.23f、10.23F表示float
float f2 = f1 + 3.3;//错误！3.3为double类型，f1+3.3为double类型，赋值给float，错误
float f2 = float(f1 + 3.3);//正确，需要强制类型转换

2.1.1 char字符类型

char字符本身是一个整数，在进行数学计算时，将char字符转换为对应的码表值（Unicode码）进行计算，输出是以字符的形式输出。

编码：

ASCII码：1个字符占用1个字节，可以表示英文字母、转义字符、null、+、-、*、/、0-9、>、<、%、$、&、#、空格、换行等，即键盘上大部分键值，可以表示0~127，128个字符，不能表示中文，只能用于美国编程
```
char c1 = '0';
int i1 = c1;//48,48为'0'字符对应的ASCII码值   字符'0'，对应码值48
char c2 = 48;
System.out.println(c1);//'0'
System.out.println(c2);//'0'
//总结：都以字符形式输出，以码值方式计算
```
Uincode码：对ASCII码的升级，兼容ASCII的128个字符，1个字母和1个汉字（就是1个字符）都占2个字节，可以表示65536个字符，缺点是1个字母占2个字节，浪费内存空间
UTF-8编码：在互联网中使用较多的编码格式，对Unicode改进，根据不同的符号进行变长的编码格式，1~6个字节，1个字母占1个字节，1个汉字占3个字节，兼容ASCII码，javaWeb开发中使用UTF-8
gbk编码：1个字母占1个字节，1个汉字占两个字节，windows控制台使用gbk编码
gb2312编码
big5编码：繁体中文（香港、台湾）

char字符例子

char c1 = 'a';//输出'a'
char c2 = 'a' + 1;//输出'b' 不需要强转是因为'a'和1都是常量，只判断常量在不在char范围内，不判类型
char c3 = (char)(c1 + 1);//必须要强转，因为c1为变量，判断左边和右边类型是否一致，1为int类型，相加时c1提升为int类型，和1相加的结果为int类型，赋值给char时，精度降低，不兼容，需要强制类型转换，可以这样理解，int占四个字节，char占2个字节，4个字节赋值给2个字节是不兼容的。这也说明char本身是整数
//char存入和读取的过程，char c = 'a'
//存入：'a'--->码值97--->二进制0110 0001--->存储
//读取：二进制0110 0001--->码值97--->'a'--->显示

2.1.2 int类型

int类型占4个字节，是java默认的整型类型，byte、short、char和int进行运算时，会自动提升为int类型进行计算。如果int和long、float、double进行计算，会自动提升为相应数据类型。

byte b = 10;
char c = 'a';
short s = 10;
//下面的b、c、s都会提升为int类型进行计算
int sum = b + 10;
sum = c + 10;
sum = s + 10;
long l = sum + 10;//sum提升为long类型 20
float f = sum + 1.1f;//sum提升为float类型  21.1
double d = sum + 1.1;//sum提升为double类型 21.1

2.1.3 long类型

long类型占8个字节，long到float和double会进行自动转型，到int或以下需强制转型

long l = 10;
float f = l + 1.1f;//11.1f
double d = l + 1.1;//11.1
int i = (int)(l + 10);//20 需强制类型转换

2.1.4 float类型

float单精度浮点类型，占4个字节，精度为小数点后6~7位，在小数后需加f或F以表示float类型，计算得到浮点数尽量不要做判断，因为浮点数是小数，是一个近似值，如果是确定的浮点数可以进行判断

float f = 1.1f;
double d = f + 1.1;//2.2
f = (float)(f + 1.1);//2.2f (f + 1.1)为double类型，需要强转成float
//比较
float f1 = 1.1f;
float f2 = 1.1f;
boolean ok = f1 == f2;//true 由于1.1f是明确浮点数，可以判定为相等
float f3 = 8.7f / 3;//2.8999999f，其近似于2.9f
float f4 = 2.9f;
ok = f3 == f4;//false，按照数据计算f3应该为2.9，但是计算器算出来的是2.8999999f，所以小数是一个近似值
//通过数据计算的两个浮点数真要判断相等，应使用两个浮点数差值的绝对值<精度值进行判定
ok = Math.abs(f3 - f4) < 0.000001；//即可判断相等

2.1.5double类型

double双精度浮点类型，占8个字节，精度为小数点后15~16位，java默认的浮点类型，与float一样，不可以判断计算得到的浮点数==。

2.2引用数据类型

引用数据类型：String、数组、类、接口

String s = new String("abc");
int[] arr = new int[3];
Person person = new Person();
Runnable runnable = new Thread();
//以上的s、arr、person、runnable都是引用数据类型，它们的对象都在堆上

3. 变量使用和注意事项

不要进行两个浮点数（计算得到）==比较，使用Math.abs(f3 - f4) < 0.000001；
注意自动类型转换和强制类型转换，由精度高向精度低转换时，需要强制类型转换；
定义float变量时加后缀f或F，定义long变量时后缀加l或L；
基本类型到String类型转换，基本类型+“”；
String类型到基本类型转换，使用包装类。Integer.parseInt(“123”);Double.parseDouble(“123”);Long.parseLong(“123”);Float.parseFloat(“123”);

4.运算符

算术运算符：+、-、*、/、%、++、–等；
关系运算符（比较）：>、>=、<、<=、==、!=等，结果为表达式 true或false；
逻辑运算符：&、&&、|、||、!、^{等，!为取反，为true或false，}异或，两者不同时为true；
赋值运算符：=、+=、-=、/=、*=、%=、<<=、>>=、&=、^=、!=等，有直接赋值，还有在赋值之前进行相应计算再进行赋值；
位运算符：&、|、^、~、>>、<<、>>>，主要针对二进制进行位运算；
单目运算符：++、–、~、!，操作单个变量

4.1 算术运算符

/：除法

int a = 10 / 3;//结果为3，整数相除结果取商整数部分，接收为int，直接赋值
double b = 10 / 3;//结果为3.0，整数相除结果取商整数部分，接收为double类型，向上转型，为3.0
b = 10.0 / 3;//结果为3.3333333333333335，10.0为double类型，3提升为double类型，相当于浮点数相除，得到结果直接赋值
float c = 10 / 3;//结果3.0，与double一致
c = (float) (10.0 / 3);//结果3.3333333，需要强制类型转换
c = 10.0f / 3;//结果3.3333333，不需要转型，3提升为float类型

%：取余或取模

int a = 10 % 5;//结果0
a = 10 % 3;//结果1
//一般用取模进行一些判断，比如a % 2的结果只有0和1，可以进行奇数和偶数的过滤，a % 3的结果只有0,1和2，可以进行负载均衡的判断

++：加1

//前置++ 先增加再赋值 后置++ 先赋值再增加
int i = 1;
i = ++i;//i的结果为2 过程：先i = i+1=>i = 2,temp = i(2),i = temp(2)
i = i++;//i的结果为2 过程：先temp = i(2),i = i + 1=>i = 3,i = temp(2)
//其实上述例子有些绕
int temp = 0;
int j = 1;
temp = j++;//结果为1 先赋值（将j的值赋给temp），j再增加1，这时j=2
temp = ++j;//结果为3 先增加1（j+1=>3），再将结果赋值给temp

–：减1

与++的用法一样

4.2 关系运算符

关系运算符其实是比较运算符，是一个表达式，结果为true和false，主要用于条件判断

int a = 3;
int b = 4;
boolean ok = a > b;//false
ok = a < b;//true
ok = a >= b;//false
ok = a <= b;//true
ok = a == b;//false
ok = a != b;//true
if (ok) {//逻辑代码........
}

4.3 逻辑运算符

主要连接两个表达式，其结果是true和false

&和&&区别，&&短路判断，如果第一个条件不满足，不判断第二个条件

|和||与上述一样，||如果第一个条件满足，不判断第二个条件

&和|两边条件都会进行判断

//&和&&两个表达式都为真，才为真
boolean ok = 3 > 2 & 5 < 10;//ture
ok = 3 > 2 & 5 < 2;//false
ok = 1 > 2 && 5 < 10;//false，1 > 2不满足，不会进入5 < 10判断
//|和||一个为真就为真
ok = !ok;//true，取反

4.4 赋值运算符

有直接赋值和间接赋值（先进行计算，将计算结果赋值）

int a = 10;//直接赋值
a += 10;//20，先+10，在进行赋值
//间接赋值运算过程有强制类型转换
float f = 10.0f;
f +=  0.0;//等价于f = f + 0.0;0.0为double类型，两者相加为double类型，按理赋值失败，其实底层进行强制类型转换，结果为10.0f
short s = 10;
s += 10;//20，底层将int类型转换为short类型

4.5 位运算

位运算主要是针对二进制进行运算。

二进制：计算机底层是根据二进制进行计算（按二进制补码进行计算和存储），计算机计算的最小单元是位，1byte = 8bit；

二进制：0b00000001 转为十进制为1 由0和1表示；

八进制：0234 转为十进制为156 2乘以8的二次方+3乘以8一次方+4乘以8的0次方由0~7表示；

十六进制：0x34 转为十进制为52 3乘以16一次方+4乘以160次方由0~E表示；

二进制到八进制转换：0000 0100从低位开始，每3位转为八进制，100->4，000->0，000->0，结果04；

八进制转换成二进制：0237从高位开始，每1位转为二进制，2->010,3->011,7->111，结果为0b10011111;

二进制到十六进制转换：0000 0100从低位开始，每4位转为十六进制，0100->4,0000->0，结果为0x4；

十六进制转成二进制：0x396从高位开始，每1位转为二进制，3->0011,9->1001,6->0110，结果为

0b1110010110

&按位与运算，两个都为1结果为1；1&1=1,1&0=0 有0则0

|按位或运算，一个为1结果为1；1|0=1,0|1=1,0|0=0,1|1=1 有1则1

^{按位异或运算：两个相同为0，两个不同为1；1}1=0,0^0=0,10=1,0^1=1，0位异或任何数=任何数，1位异或任何数=任何数取反，任何数位异或任何数=0 相同为0，不同为1

~按位取反操作，各二进制位进行取反操作，为单目运算符 按位取反

：>>右移运算符，相当于除以2 0000 0001右移1位 0000 0000

：<<左移运算符，相当于乘以2 0000 0001左移1位 0000 0010

：>>>无符号位右移

计算机中二进制运算都采用补码进行运算（使用二进制补码进行计算，包含加减乘除，按位与，按位或，按位异或，按位取反），主要是针对负数，其实计算机没有减法，都是加法，如果是减一个数，其实是+（负数）。

注意点：

二进制最高位为符号位，正数符号位为0，负数符号位为1
java中无无符号数，都是有符号数
正数的原码、反码和补码都一样
负数的反码，符号位不变，其余位置取反
负数的补码，反码+1
0的反码和补码都是0
计算机进行计算时使用的是补码
当我们看运行结果时，要看原码

原码：1000 0110

反码：1111 1001 符号位不变，其余位取反，这里的取反和按位取反~不一样，按位取反，全部为都取反

补码：1111 1010 反码+1

/*
比如：2 - 4，计算机：2 + (-4)，使用补码进行计算
2是正数，原码、反码和补码一致
-4为负数，计算其补码
-4原码：1000 0100
-4反码：1111 1011 +1  符号位不变，其余位取反
-4补码：1111 11002补码 0000 0010 +
-4补码 1111 1100
结果： 1111 1110 这个结果是补码，要展示结果需要转为原码
补码：1111 1110 -1
反码：1111 1101 符号位不变，其余位取反得到原码
原码：1000 0010 其结果为-2
*/