1. 关键字
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（或单词） 特点：全部关键字都是`小写字母`。 说明： ①关键字一共50个，其中const和goto是保留字(reserved word)。 //②true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。
2. 标识符( identifier)
定义：Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。凡是自己可以起名字的地方都叫标识符。 命名规则（硬性规定）： ①由26个英文字母大小写，0-9，_或$组成 ②数字不可以开头。 ③不可以使用关键字和保留字，但能包含关键字和保留字。 ④区分大小写，长度无限制。 ⑤标识符不能包含空格。 命名规范（建议遵守，不遵守编译和执行都能正常运行）（见名知意） ①包名：多单词组成所有字母小写 java.long ②类名，接口名：多单词组成所有首字母大写 HelloWorld ③变量名，方法名：多单词组成，第一个字母小写，第二个开始首字母大写 bookName ④常量名：所有字母大写，多单词每个单词用下划线连接 MAX_VALUE*/
3. 变量
3.1 初识变量
概念：内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化，包含三个要素：数据类型、变量名、存储的值。变量声明的格式：数据类型 变量名 = 变量值
作用：用于在内存中保存数据。
使用变量注意：
①Java中每个变量必须先声明，后使用。
②使用变量名来访问这块区域的数据。
③变量的作用域：其定义所在的一对{ }内。
④变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。
⑤同一个作用域内，不能定义重名的变量。
3.2 Java中变量的数据类型
分类： 基本数据类型：整数类型、浮点数类型、字符类型、布尔类型。 引用数据类型：数组array 、 类class 、接口interferace 、枚举、注解、记录。
3.3 变量的使用
步骤：①变量的声明 格式：数据类型 变量名;
注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。
②变量的赋值 给变量赋值，就是把“值”存到该变量代表的内存空间中。同时，给变量赋的值类型必须与变量声明的类型一致或兼容。
4. 基本数据类型介绍 ： 整数 浮点 字符 布尔
4.1 整数类型：byte、short、int、long
定义long类型的变量，赋值时需要以l或L作为后缀。 Java的整型常量默认为 int 型。
4.1.1 补充：计算机存储单位
字节（Byte）：是计算机用于计量存储容量的基本单位，一个字节等于8 bit。 位（bit）：是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。 转换关系： 8 bit = 1 Byte 1024 Byte = 1KB 1024 KB = 1MB 1024 MB = 1GB 1024 GB = 1TB
4.2 浮点类型：float、double
float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。定义float类型的变量，赋值需要以f或F作为后缀。 double：双精度，精度是float的两倍。(默认类型) 案例1：定义圆周率并赋值为3.14，现有3个圆的半径分别为1.2、2.5、6，求它们的面积。
public class Exercise1 {
public static void main(String[] args) {
double PI = 3.14; //圆周率
double radius1 = 1.2;
double radius2 = 2.5;
int radius3 = 6;
System.out.println("第1个圆的面积：" + PI * radius1 * radius1);
System.out.println("第2个圆的面积：" + PI * radius2 * radius2);
System.out.println("第3个圆的面积：" + PI * radius3 * radius3);
}
}案例2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。 //它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。（℃ = (℉ - 32) / 1.8）
public class Exercise2 {
public static void main(String[] args) {
double hua = 80;
double she = (hua-32)/1.8;
System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃");
}
}4.3 字符类型：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 |
4.4 布尔类型：boolean
boolean 类型用来判断逻辑条件，一般用于流程控制语句中： ①if条件控制语句； ②while for do-while循环控制语句； boolean类型数据只有两个值：true、false，无其它。不可以使用0或非 0 的整数替代false和true，这点和C语言不同。 举例
boolean isFlag = true;
if(isFlag){
//true分支
}else{
//false分支
}5. 基本数据类型变量间运算规则 自动类型提升和强制类型转换
5.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';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113 练习
设 x 为float型变量，y为double型变量，a为int型变量，b为long型变量，c为char型变量，则表达式
x + y * a / x + b / y + c的值类型为：
A. int B. long C. double D. char
//c5.2 强制类型转换
将3.14 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。
int i = 3.14; // 编译报错想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。
转换格式 ：数据类型1 变量名 = (数据类型1)被强转数据值;
()中的数据类型必须<=变量值的数据类型
（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。
int i = (int)3.14;//损失精度
double d = 1.2;
int num = (int)d;//损失精度
int i = 200;
byte b = (byte)i;//溢出（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;练习：判断是否能通过编译
1）short s = 5;
s = s-2; //判断：no
2） byte b = 3;
b = b + 4; //判断：no
b = (byte)(b+4); //判断：yes
3）char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断：yes
4） byte b = 5;
short s = 3;
short t = s + b; //判断：no问答：为什么标识符的声明规则里要求不能数字开头？
//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;5.3 基本数据类型与String的运算
5.3.1 字符串类型：String
-
String不是基本数据类型，属于引用数据类型
-
使用一对
""来表示一个字符串，内部可以包含0个、1个或多个字符。 -
声明方式与基本数据类型类似。例如：String str = “尚硅谷”;
-
5.3.2 运算规则
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);//正确的，后面才能讲到，借助包装类的方法才能转5.3.3 案例与练习
-
案例：公安局身份登记
要求填写自己的姓名、年龄、性别、体重、婚姻状况（已婚用true表示，单身用false表示）、联系方式等等。
public class Info { public static void main(String[] args) { String name = "康师傅"; int age = 37; char gender = '男'; double weight = 145.6; boolean isMarried = true; String phoneNumber = "13112341234"; System.out.println("姓名：" + name); System.out.println("年龄：" + age); System.out.println("性别：" + gender); System.out.println("体重：" + weight); System.out.println("婚否：" + isMarried); System.out.println("电话：" + phoneNumber); //或者 System.out.println("name = " + name + ",age = " + age + "，gender = " + gender + ",weight = " + weight + ",isMarried = " + isMarried + ",phoneNumber = " + phoneNumber); } }练习：
练习1：
-
String str1 = 4; //判断对错：错 String str2 = 3.5f + ""; //判断str2对错：对 System.out.println(str2); //输出：3.5 System.out .println(3+4+"Hello!"); //输出：7Hello！ System.out.println("Hello!"+3+4); //输出：Hello34 System.out.println('a'+1+"Hello!"); //输出：98Hello！ System.out.println("Hello"+'a'+1); //输出：Helloa16. 计算机底层如何存储数据
- 计算机世界中只有二进制，所有计算机中存储和运算的
所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。 -
6.1 进制的分类
-
十进制（decimal）
-
数字组成：0-9
-
进位规则：满十进一
-
-
二进制（binary）
-
数字组成：0-1
-
进位规则：满二进一，以
0b或0B开头
-
-
八进制（octal）：很少使用
-
数字组成：0-7
-
进位规则：满八进一，以数字
0开头表示
-
-
十六进制
-
数字组成：0-9，a-f
-
进位规则：满十六进一，以
0x或0X开头表示。此处的 a-f 不区分大小写
-
-
class BinaryTest { public static void main(String[] args) { int num1 = 123; //十进制 int num2 = 0b101; //二进制 int num3 = 0127; //八进制 int num4 = 0x12aF; //十六进制 System.out.println(num1); System.out.println(num2); System.out.println(num3); System.out.println(num4); } }6.2 二进制转十进制
-
二进制如何表示整数？
-
计算机数据的存储使用二进制
补码形式存储，并且最高位是符号位。-
正数：
最高位是0 -
负数：
最高位是1
-
-
规 定
-
正数的补码与反码、原码一样，称为
三码合一 -
负数的补码与反码、原码不一样：
-
负数的
原码：把十进制转为二进制，然后最高位设置为1 -
负数的
反码：在原码的基础上，最高位不变，其余位取反（0变1,1变0） -
负数的
补码：反码（末位）+1 -
二进制转十进制：权相加法
-
例如：byte类型（1个字节，8位）
-
25 ==> 原码 0001 1001 ==> 反码 0001 1001 -->补码 0001 1001
-
-25 ==>原码 1001 1001 ==> 反码1110 0110 ==>补码 1110 0111
-
整数： 正数：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（补码）6.3 十进制转二进制
十进制转二进制：
除2取余的逆 一直除以2 从下往上书写 -
6.4 二进制与八进制、十六进制间的转换
- 二进制转八进制
三个为一组，每组算法和二进制转十进制相同
- 八进制转二进制
拆回到三个一组 计算
- 二进制转十六进制
拆成四个一组
-
7. 运算符（Operator）（掌握）
- 运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等
- 按照
功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符 -
分类 运算符 算术运算符（7个） +、-、*、/、%、++、-- 赋值运算符（12个） =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等 比较(或关系)运算符（6个） >、>=、<、<=、==、!= 逻辑运算符（6个） &、|、^、!、&&、|| 位运算符（7个）（不常用） &、|、^、~、<<、>>、>>> 条件运算符（1个） (条件表达式)?结果1:结果2 Lambda运算符（1个） ->（第18章时讲解） -
按照
操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符） -
分类 运算符 一元运算符（单目运算符） 正号（+）、负号（-）、++、--、!、~ 二元运算符（双目运算符） 除了一元和三元运算符剩下的都是二元运算符 三元运算符 （三目运算符） (条件表达式)?结果1:结果2 -
7.1 算术运算符
7.1.1 基本语法
举例1：加减乘除模 -
public class ArithmeticTest1 { public static void main(String[] args) { 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 } }举例2：“+”号的两种用法
-
第一种：对于
+两边都是数值的话，+就是加法的意思 -
第二种：对于
+两边至少有一边是字符串的话，+就是拼接的意思 -
public class ArithmeticTest2 { public static void main(String[] args) { // 字符串类型的变量基本使用 // 数据类型 变量名称 = 数据值; 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(str2 + 5 + 20); // Java520 } }举例3：自加自减运算
理解：
++运算，表示自增1。同理，--运算，表示自减1，用法与++ 一致。1、单独使用
-
变量在单独运算的时候，变量
前++和变量后++，是没有区别的。 -
变量
前++：例如++a。 -
变量
后++：例如a++。 -
public class ArithmeticTest3 { public static void main(String[] args) { // 定义一个int类型的变量a int a = 3; //++a; a++; // 无论是变量前++还是变量后++，结果都是4 System.out.println(a); } }2、复合使用
-
和
其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。 -
变量
前++：变量先自增1，然后再运算。（先加后用） -
变量
后++：变量先运算，然后再自增1。（先用后加） -
public class ArithmeticTest4 { public static void main(String[] args) { // 其他变量放在一起使用 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); } }7.1.2 案例与练习
案例1：
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。class ArithmeticExer1 { public static void main(String[] args) { int num = 187; int bai = num / 100%10; int shi = num / 10 % 10; int ge = num % 10; System.out.println("百位为：" + bai); System.out.println("十位为：" + shi); System.out.println("个位为：" + ge); } }案例2：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？
-
public class ArithmeticExer2 { public static void main(String[] args){ int hours = 89; int day = hours / 24; int hour = hours % 24; System.out.println("为抵抗洪水，战士连续作战89小时："); System.out.println(hours + "是" + day + "天" + hour +"小时"); } }练习1：算术运算符：自加、自减
-
public class ArithmeticExer3{ public static void main(String[] args){ int i1 = 10; int i2 = 20; int i = i1++; System.out.print("i="+i); //10 System.out.println("i1="+i1);//11 i = ++i1; System.out.print("i="+i);//12 System.out.println("i1="+i1);//12 i = i2--; System.out.print("i="+i);//20 System.out.println("i2="+i2);//19 i = --i2; System.out.print("i="+i);//18 System.out.println("i2="+i2);//18 } }练习2：
System.out.println("5+5=" + 5 + 5); //打印结果是？ 5+5=55 System.out.println("5+5=" +（ 5 + 5）); //打印结果是5+5=10练习3：
byte bb1 = 127; bb1++; //再往上加1，加到最高位，即为-128 System.out.println("bb1 = " + bb1);//-128练习4：
-
int i = 1;//i=4 int j = i++ + ++i * i++; // 1 + 3 * 3 System.out.println("j = " + j);//10练习5：（企业真题）写出下列程序的输出结果
int i = 2; int j = i++; System.out.println(j);//j=2 int m = 2; m = m++; //(1)先取b的值“2”放操作数栈 (2)m再自增,m=3 (3)再把操作数栈中的"2"赋值给m,m=2 System.out.println(m);//m=27.2 赋值运算符
-
7.2.1 基本语法
-
符号：=
-
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
-
支持
连续赋值。
-
-
扩展赋值运算符： +=、 -=、*=、 /=、%=
-
赋值运算符 符号解释 +=将符号 左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量-=将符号 左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量*=将符号 左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量/=将符号 左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量%=将符号 左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量public class SetValueTest1 { public static void main(String[] args) { int i1 = 10; long l1 = i1; //自动类型转换 byte bb1 = (byte)i1; //强制类型转换 int i2 = i1; //连续赋值的测试 //以前的写法 int a1 = 10; int b1 = 10; //连续赋值的写法 int a2,b2; a2 = b2 = 10; int a3 = 10,b3 = 20; //举例说明+= -= *= /= %= int m1 = 10; m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。 System.out.println(m1);//15 //练习1：开发中，如何实现一个变量+2的操作呢？ // += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。 //写法1：推荐 short s1 = 10; s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short System.out.println(s1);//12 //写法2： short s2 = 10; //s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度 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); } }7.2.2 练习
练习1：
-
short s = 3; s = s+2; //① 编译报错 s=(short)(s+2) s += 2; //② 正常执行 //①和②有什么区别？ - 练习2：
-
int i = 1; i *= 0.1; System.out.println(i);//0 i++; System.out.println(i);//1练习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);//327.3 比较(关系)运算符
- 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
- > < >= <= ：只适用于基本数据类型（除boolean类型之外）
- == != ：适用于基本数据类型和引用数据类型
- 比较运算符“
==”不能误写成“=” -
class CompareTest { public static void main(String[] args) { int i1 = 10; int i2 = 20; System.out.println(i1 == i2);//false System.out.println(i1 != i2);//true System.out.println(i1 >= i2);//false int m = 10; int n = 20; System.out.println(m == n);//false System.out.println(m = n);//20 将n赋值给m boolean b1 = false; boolean b2 = true; System.out.println(b1 == b2);//false System.out.println(b1 = b2);//true } }7.4 逻辑运算符
-
7.4.1 基本语法
逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。 -
运算符说明：
-
& 和 &&：表示"且"关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false。
-
| 和 || ：表示"或"关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
-
! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
-
^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
-
理解：
异或，追求的是“异”！ -
区分“&”和“&&”：
-
相同点：如果符号左边是true，则二者都执行符号右边的操作
-
不同点：& ： 如果符号左边是false,则继续执行符号右边的操作
-
&& ：如果符号左边是false,则不再继续执行符号右边的操作
-
建议：开发中，推荐使用 &&
-
区分“|”和“||”：
-
相同点：如果符号左边是false，则二者都执行符号右边的操作
-
不同点：| ： 如果符号左边是true，则继续执行符号右边的操作
|| ：如果符号左边是true，则不再继续执行符号右边的操作
-
建议：开发中，推荐使用 ||
-
public class LoginTest { public static void main(String[] args) { int a = 3; int b = 4; int c = 5; // & 与，且；有false则false System.out.println((a > b) & (a > c)); //false System.out.println((a > b) & (a < c)); //f System.out.println((a < b) & (a > c)); //f System.out.println((a < b) & (a < c)); //t System.out.println("==============="); // | 或；有true则true System.out.println((a > b) | (a > c)); //f System.out.println((a > b) | (a < c)); //t System.out.println((a < b) | (a > c));// System.out.println((a < b) | (a < c));// System.out.println("==============="); // ^ 异或；相同为false，不同为true System.out.println((a > b) ^ (a > c));//t System.out.println((a > b) ^ (a < c)); // System.out.println((a < b) ^ (a > c)); // System.out.println((a < b) ^ (a < c)); // System.out.println("==============="); // ! 非；非false则true，非true则false System.out.println(!false);//t System.out.println(!true);//f //&和&&的区别 System.out.println((a > b) & (a++ > c)); System.out.println("a = " + a);//4 System.out.println((a > b) && (a++ > c)); System.out.println("a = " + a);//4 System.out.println((a == b) && (a++ > c)); System.out.println("a = " + a);//5 //|和||的区别 System.out.println((a > b) | (a++ > c)); System.out.println("a = " + a);//4 System.out.println((a > b) || (a++ > c)); System.out.println("a = " + a);// System.out.println((a == b) || (a++ > c)); System.out.println("a = " + a);//4 } }练习1：区分 & 和 &&
int x = 1;//2 int y = 1;//2 if(x++ == 2 & ++y == 2){ x = 7; } System.out.println("x=" + x + ",y=" + y);int x = 1,y = 1;//2 1 if(x++ == 2 && ++y == 2){ x =7; } System.out.println("x="+x+",y="+y);练习2：区分 | 和 ||
-
int x = 1,y = 1;//2 2 if(x++==1 | ++y==1){ x =7; } System.out.println("x="+x+",y="+y);int x = 1,y = 1;//2 1 if(x++==1 || ++y==1){ x =7; } System.out.println("x="+x+",y="+y);7.5 位运算符（难点、非重点）
-
7.5.1 基本语法
位运算符的运算过程都是基于二进制的补码运算 -
（1）左移：<<
运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）
-
3<<4 类似于 3*2的4次幂 => 3*16 => 48
-
-3<<4 类似于 -3*2的4次幂 => -3*16 => -48
-
面试题：高效计算2*8 2<<3或8<<1
-
（2）右移：>>
运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）
【注意】如果不能整除，
69>>4 类似于 69/2的4次 = 69/16 =4向下取整。 -
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）
-
（4）按位与：&
运算规则：对应位都是1才为1，否则为0。
-
（5）按位或：|
运算规则：对应位只要有1即为1，否则为0。
-
（6）按位异或：^
运算规则：对应位一个为1一个为0，才为1，否则为0。
-
（7）按位取反：~
运算规则：对应位为1，则结果为0；对应位为0，则结果为1。
-
7.6 条件运算符
7.6.1 基本语法
-
条件运算符格式：
-
(条件表达式)? 表达式1:表达式2
-
说明：条件表达式是boolean类型的结果，若表达式结果为true则执行表达式1否则执行表达式2
-
如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型
-
开发中凡是可以使用条件运算符的位置都可以改写为if-else。反之不一定。
-
建议：在二者都能使用的情况下，推荐使用条件运算符，执行效率稍高
public static void main(String[] args) { int i = (1==2 ? 100 : 200); System.out.println(i);//200 boolean marry = false; System.out.println(marry ? "已婚" : "未婚" ); double d1 = (m1 > m2)? 1 : 2.0; System.out.println(d1);//数值类型根据后边选型定 int num = 12; System.out.println(num > 0? true : "num非正数"); }案例2：获取三个数中的最大值
-
public class ConditionExer2 { public static void main(String[] args) { int n1 = 23; int n2 = 13; int n3 = 33; //写法1： int tempMax = (n1 > n2)? n1:n2; int finalMax = (tempMax > n3)? tempMax : n3; System.out.println("三个数中最大值为：" + finalMax); //写法2：不推荐，可读性差 int finalMax1 = (((n1 > n2)? n1:n2) > n3)? ((n1 > n2)? n1:n2) : n3; System.out.println("三个数中最大值为：" + finalMax1); } }案例3：今天是周2，10天以后是周几？
要求：控制台输出"今天是周2，10天以后是周x"。
public class ConditionExer3 { public static void main(String[] args) { int week = 2; week += 10; week %= 7; System.out.println("今天是周2,10天以后是周" + (week == 0 ? "日" : week)); } }7.7 运算符优先级
-
开发建议：
-
不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量
使用()来控制表达式的执行顺序。 -
不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它
分成几步来完成。例如： (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;
-
-
1280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
