java基础学习之变量与运算符
一，关键字
1，定义：被java语言赋予了特殊含义，用作专门用途的字符串或单词。
2，特点：关键字全都是小写字母。
3，关键字一共50个，其中const和goto是保留字。
4，true，false，null不是关键字，它们是字面量。
二，标识符
1，Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。(技巧：凡是自己可以起名字的地方都叫标识符 )。
2，命名规则
> 由26个英文字母大小写，0-9 ，_或 $ 组成
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。
3，命名规范
> 包名：多单词组成时所有字母都小写：xxxyyyzzz。
例如：java.lang、com.atguigu.bean
> 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
例如：HelloWorld，String，System等
> 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
例如：age,name,bookName,main,binarySearch,getName
> 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
例如：MAX_VALUE,PI,DEFAULT_CAPACITY
注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
三，变量
1，变量的概念
- 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化。
- 变量构成的三要素：数据类型、变量名、存储的值
- 变量声明的格式：数据类型 变量名=变量值
- 作用：用于在内存中保存数据
2，注意事项
- java中的变量必须先声明，后使用
- 变量作用域：其定义所在的一对{}内
- 变量只在其作用域内有效，出了作用域不可被调用。
- 同一个作用域内，不能定义重名的变量
3，举例
//变量声明：
//存储一个整数类型的年龄
int age;
//存储一个小数类型的体重
double weight;
//存储一个单字符类型的性别
char gender;
//存储一个布尔类型的婚姻状态
boolean marry;
//存储一个字符串类型的姓名
String name;
//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。
//变了赋值：
//可以使用合适类型的`常量值`给已经声明的变量赋值
age = 18;
weight = 109;
gender = '女';
//可以使用其他`变量`或者`表达式`给变量赋值
int m = 1;
int n = m;
//变量可以反复赋值
//先声明，后初始化
char gender;
gender = '女';
//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男
//声明赋值一并执行
boolean isBeauty = true;
String name = "迪丽热巴";四，基本数据类型
1，java中数据类型分为两大类
- 基本数据类型：整数类型、浮点类型、字符类型、布尔类型
- 引用数据类型：数组、类、接口、枚举、记录、注解
2,整数类型
- 定义long类型变量，赋值时要以‘l’或者‘L’作为后缀结尾。
- 通常声明为int类型，除非数值特别大采用long
- java整形常亮 默认为int类型
Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。
3，浮点类型
float：单精度，尾数可以精确到7位有效数字，很多情况下很难满足需求
double：双精度，精度是float的两倍，通常采用此类型
定义float类型的变量，赋值时需要以"
f"或"F"作为后缀。Java 的浮点型
常量默认为double型。浮点型常量有两种表示形式：
十进制数形式。如：5.12 512.0f .512 (必须有小数点）
科学计数法形式。如：5.12e2 512E2 100E-2
4，计算机存储单位
字节（Byte）：是计算机用于
计量存储容量的基本单位，一个字节等于8 bit。位（bit）：是数据存储的
最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。- 转换关系
8 bit = 1 Byte
1024 Byte = 1 KB
1024 KB = 1 MB
1024 MB = 1 GB
1024 GB = 1 TB
5，关于浮点数精度说名
并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。
浮点类型float、double的数据不适合在
不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。
//测试1：（解释见章末企业真题：为什么0.1 + 0.2不等于0.3）
System.out.println(0.1 + 0.2);//0.30000000000000004
//测试2：
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);//1.2312312E8
System.out.println(ff2);//1.2312312E8
System.out.println(ff1 == ff2);//true6,字符类型：char
char 型数据用来表示通常意义上“
字符”（占2字节）Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式：
形式1：使用单引号(' ')括起来的
单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
形式2：直接使用
Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。例如：\u0023 表示 '#'。
形式3：Java中还允许使用
转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = '\n'; // '\n'表示换行符
char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。
| 转义字符 | 说明 | Unicode表示方式 |
|---|---|---|
\n |
换行符 | \u000a |
\t |
制表符 | \u0009 |
\" |
双引号 | \u0022 |
\' |
单引号 | \u0027 |
\\ |
反斜线 | \u005c |
\b |
退格符 | \u0008 |
\r |
回车符 | \u000d |
7，布尔类型：boolean
boolean 类型用来判断逻辑条件，一般用于流程控制语句中：
if条件控制语句；
while循环控制语句；
for循环控制语句；
do-while循环控制语句；
boolean类型数据只有两个值：true、false，无其它。
不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
拓展：Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。——《java虚拟机规范 8版》
五，基本数据类型变量间的运算规则
在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。
转换的方式有两种：
自动类型提升和强制类型转换。
1，自动类型提升
规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。
如图：
举例：
//1,当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时
int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过
//2,当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。
int i = 1;
byte b = 1;
double d = 1.0;
double sum = i + b + d;//混合运算，升级为double
//3,当byte,short,char数据类型的变量进行算术运算时，按照int类型处理。
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int
char c1 = '0';//ASCII码 48
char c2 = 'A';//65
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113 2，强制类型转换
- 规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。
- 自动类型提升是Java自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。
- 转换格式：数据类型1 变量名=（数据类型1）被强转数据值。
举例：
//1，当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会`损失精度`或`溢出`。
int i = (int)3.14;//3，损失精度
double d = 1.2;
int num = (int)d;//1，损失精度
int i = 200;
byte b = (byte)i;//-56 溢出,参考二进制章节即可得到结果
//2，当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是`没有风险`的，通常省略
int i = 1;
int j = 2;
double bigger = (double)(i/j);
//3，声明long类型变量时，可以出现省略后缀的情况。float则不同。
long l1 = 123L;
long l2 = 123;//如何理解呢？ 此时可以看做是int类型的123自动类型提升为long类型
//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
long l4 = 123123123123L;
//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;
//问答：为什么标识符的声明规则里要求不能数字开头？
//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;3，基本数据类型与String的运算
String不是基本数据类型，属于引用数据类型
使用一对
""来表示一个字符串，内部可以包含0个、1个或多个字符。声明方式与基本数据类型类似。例如：String str = “Hello World”。
举例：
//1,任意八种基本数据类型的数据与String类型只能进行连接“+”运算，且结果一定也是String类型
System.out.println("" + 1 + 2);//12
int num = 10;
boolean b1 = true;
String s1 = "abc";
String s2 = s1 + num + b1;
System.out.println(s2);//abc10true
//String s3 = num + b1 + s1;//编译不通过，因为int类型不能与boolean运算
String s4 = num + (b1 + s1);//编译通过
//2,String类型不能通过强制类型()转换，转为其他的类型
String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转六，计算机底层如何存储数据
计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等
1，进制的分类
十进制（decimal）
数字组成：0-9
进位规则：满十进一
二进制（binary）
数字组成：0-1
进位规则：满二进一，以
0b或0B开头八进制（octal）：很少使用
数字组成：0-7
进位规则：满八进一，以数字
0开头表示十六进制
数字组成：0-9，a-f
进位规则：满十六进一，以
0x或0X开头表示。此处的 a-f 不区分大小写
举例：
int num1 = 123; //十进制
int num2 = 0b101; //二进制
int num3 = 0127; //八进制
int num4 = 0x12aF; //十六进制2，二进制如何表示整数？
- 计算机数据的存储使用二进制
补码形式存储，并且最高位是符号位。
正数：
最高位是0负数：
最高位是1- 规定
正数的补码与反码、原码一样，称为
三码合一负数的补码与反码、原码不一样：
负数的
原码：把十进制转为二进制，然后最高位设置为1负数的
反码：在原码的基础上，最高位不变，其余位取反（0变1,1变0）负数的
补码：反码+1
举例：
整数：
正数：25 00000000 00000000 000000000 00011001（原码）
正数：25 00000000 00000000 000000000 00011001（反码）
正数：25 00000000 00000000 000000000 00011001（补码）负数：-25 10000000 00000000 000000000 00011001（原码）
负数：-25 11111111 11111111 111111111 11100110（反码）
负数：-25 11111111 11111111 111111111 11100111（补码）
3，二进制转十进制：权相加法
byte数据举例说明：
4，十进制转二进制：除2取余的逆
5，二进制与八进制，十六进制的转换
注意：八进制，十六进制通过先转为二进制，然后再转为十进制。
七，运算符
1，运算符的分类
按照
功能分为：
分类 运算符 算术运算符（7个） +、-、*、/、%、++、-- 赋值运算符（12个） =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等 比较(或关系)运算符（6个） >、>=、<、<=、==、!= 逻辑运算符（6个） &、|、^、!、&&、|| 位运算符（7个） &、|、^、~、<<、>>、>>> 条件运算符（1个） (条件表达式)?结果1:结果2 Lambda运算符（1个） ->（第18章时讲解）
按照
操作数个数分为：
分类 运算符 一元运算符（单目运算符） 正号（+）、负号（-）、++、--、!、~ 二元运算符（双目运算符） 除了一元和三元运算符剩下的都是二元运算符 三元运算符 （三目运算符） (条件表达式)?结果1:结果2
2，算数运算符
举例：
int a = 3;
int b = 4;
System.out.println(a + b);// 7
System.out.println(a - b);// -1
System.out.println(a * b);// 12
System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
System.out.println(a % b);// 3
//结果与被模数符号相同
System.out.println(5%2);//1
System.out.println(5%-2);//1
System.out.println(-5%2);//-1
System.out.println(-5%-2);//-1
//商*除数 + 余数 = 被除数
//5%-2 ==>商是-2，余数时1 (-2)*(-2)+1 = 5
//-5%2 ==>商是-2，余数是-1 (-2)*2+(-1) = -4-1=-5 加号的两种用法
第一种：对于
+两边都是数值的话，+就是加法的意思第二种：对于
+两边至少有一边是字符串的话，+就是拼接的意思
举例：
// 字符串类型的变量基本使用
// 数据类型 变量名称 = 数据值;
String str1 = "Hello";
System.out.println(str1); // Hello
System.out.println("Hello" + "World"); // HelloWorld
String str2 = "Java";
// String + int --> String
System.out.println(str2 + 520); // Java520
// String + int + int
// String + int
// String
System.out.println(5 + 20+str2); // 25Java自加自减运算:
- 理解：
++运算，表示自增1。同理，--运算，表示自减1，用法与++ 一致。变量在单独运算的时候，变量
前++和变量后++，是没有区别的和
其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
变量
前++：变量先自增1，然后再运算。变量
后++：变量先运算，然后再自增1。
举例：
// 其他变量放在一起使用
int x = 3;
//int y = ++x; // y的值是4，x的值是4，
int y = x++; // y的值是3，x的值是4
System.out.println(x);
System.out.println(y);
System.out.println("==========");
// 和输出语句一起
int z = 5;
//System.out.println(++z);// 输出结果是6，z的值也是6
System.out.println(z++);// 输出结果是5，z的值是6
System.out.println(z);3，赋值运算符
符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
支持
连续赋值。扩展赋值运算符： +=、 -=、*=、 /=、%=
+=将符号 左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量-=将符号 左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量*=将符号 左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量赋值运算符 符号解释 /=将符号 左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量%=将符号 左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量
举例说明，+= -= *= /= %=
int m1 = 10;
m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。
System.out.println(m1);//15自动类型转换和强制类型转换:
int i1 = 10; long l1 = i1; //自动类型转换 byte bb1 = (byte)i1; //强制类型转换
连续赋值：
int a2,b2; a2 = b2 = 10;
练习1：开发中，如何实现一个变量+2的操作呢？
注：+= 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
//写法1：推荐 short s1 = 10; s1 += 2; //编译通过，在得到int类型结果后，JVM自动完成一步强制类型转换，将int强转成short System.out.println(s1);//12 //写法2： short s2 = 10; s2 = (short)(s2 + 2); System.out.println(s2);
练习2： 开发中，如何实现一个变量+1的操作呢？
//写法1：推荐
int num1 = 10;
num1++;
System.out.println(num1);
//写法2：
int num2 = 10;
num2 += 1;
System.out.println(num2);
//写法3：
int num3 = 10;
num3 = num3 + 1;
System.out.println(num3); 练习3：
int m = 2;
int n = 3;
n *= m++; //n = n * m++;
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6练习4：
int n = 10;
n += (n++) + (++n); //n = n + (n++) + (++n)
System.out.println(n);//324，比较运算符
- 比较运算符的结果都是boolean型
- > < >= <= ：只适用于基本数据类型（除boolean类型之外）
- == != ：适用于基本数据类型和引用数据类型
举例：
int m = 10;
int n = 20;
System.out.println(m == n);//false
System.out.println(m = n);//20，这是赋值
boolean b1 = false;
boolean b2 = true;
System.out.println(b1 == b2);//false
System.out.println(b1 = b2);//true 这是赋值5，逻辑运算符
- 逻辑运算符，操作的都是boolean类型的变量或常量，运算得结果也是boolean类型的值
& 和 &&：表示"且"关系，当符号左右两边都是true时，结果才能为true。否则为false。
- & ： 如果符号左边是false,则继续执行符号右边的操作
- && ：如果符号左边是false,则不再继续执行符号右边的操作
| 和 || ：表示"或"关系，符号两边有一边为true时，结果为true。两边都为false时，结果为false
| ： 如果符号左边是true，则继续执行符号右边的操作
|| ：如果符号左边是true，则不再继续执行符号右边的操作
! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
^ ：表示‘异或’，符号两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
练习1：区分 & 和 &&
int a = 3;
int b = 4;
System.out.println((a > b) & (a++ > c));//false
System.out.println("a = " + a);//4
System.out.println((a > b) && (a++ > c));//false
System.out.println("a = " + a);//4
练习2：区分 | 和 ||
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=2
int m = 1,n = 1;
if(m++==1 || ++n==1){
m =7;
}
System.out.println("m="+m+",n="+n);//m=7,n=16,位运算符（非重点，难点）
（1）左移：<<
- 运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）
3<<4 类似于 3*2的4次幂 => 3*16 => 48
-3<<4 类似于 -3*2的4次幂 => -3*16 => -48
（2）右移：>>
- 运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用），如果不能整除，
向下取整。- 69>>4 类似于 69/2的4次 = 69/16 =4
- -69>>4 类似于 -69/2的4次 = -69/16 = -5
（3）无符号右移：>>>
- 运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）
- 69>>>4 类似于 69/2的4次 = 69/16 =4
- -69>>>4 结果：268435451
（4）按位与：&
- 运算规则：对应位都是1才为1，否则为0。
- 9 & 7 = 1
- -9 & 7 = 7
（5）按位或：|
- 运算规则：对应位只要有1即为1，否则为0。
- 9 | 7 //结果： 15
- -9 | 7 //结果： -9
（6）按位异或：^
- 运算规则：对应位一个为1一个为0，才为1，否则为0。
- 9 ^ 7 //结果为14
- -9 ^ 7 //结果为-16
（7）按位取反：~
- 运算规则：对应位为1，则结果为0；对应位为0，则结果为1。
- ~9 //结果：-10
- ~-9 //结果：8
练习1：高效的方式计算2 * 8的值（经典面试题）
答案：2 << 3 、 8 << 1
练习2，交互两个int类型变量的值
int m = 10;
int n = 5;
m = m ^ n;
n = m ^ n; //(m ^ n) ^ n
m = m ^ n;7，条件运算符
- 条件运算符格式：(条件表达式)? 表达式1:表达式2
- 条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2
如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型
凡是可以使用条件运算符的地方，都可以改写为if-else结构。反之，不成立
开发中，如果既可以使用条件运算符，又可以使用if-else，推荐使用条件运算符。因为执行效率稍高。
举例：获取两个数中的最大值
int m1 = 10;
int m2 = 20;
int max1 = (m1 > m2)? m1 : m2;8，运算符优先级
- 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量
使用()来控制表达式的执行顺序- 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它
分成几步来完成- 下表中上一行的运算符总是优先于下一行的。
| 优先级 | 运算符说明 | Java运算符 |
|---|---|---|
| 1 | 括号 | ()、[]、{} |
| 2 | 正负号 | +、- |
| 3 | 单元运算符 | ++、--、~、！ |
| 4 | 乘法、除法、求余 | *、/、% |
| 5 | 加法、减法 | +、- |
| 6 | 移位运算符 | <<、>>、>>> |
| 7 | 关系运算符 | <、<=、>=、>、instanceof |
| 8 | 等价运算符 | ==、!= |
| 9 | 按位与 | & |
| 10 | 按位异或 | ^ |
| 11 | 按位或 | | |
| 12 | 条件与 | && |
| 13 | 条件或 | || |
| 14 | 三元运算符 | ? : |
| 15 | 赋值运算符 | =、+=、-=、*=、/=、%= |
| 16 | 位赋值运算符 | &=、|=、<<=、>>=、>>>= |