Java 浮点类型：float、double
Java 浮点类型有固定的表数范围，不受具体操作系统的影响。
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| 单精度 float | 4 字节 | -3.403E38 ~ 3.403E38（十进制） |
| 双精度 double | 8 字节 | -1.798E308 ~ 1.798E308（十进制） |
Java 的浮点型常量有两种表示形式：
十进制数的小数点形式。如：5.12、512.0f、.512（必须有小数点）
科学计数法形式。如：5.12e2、512E2、100E-2
float：单精度，小数部分可以精确到 7 位有效数字（十进制）。很多情况下，精度很难满足需求。
double：双精度，精度是 float 的两倍，小数部分可以精确到 7 位有效数字（十进制）。通常采用此类型。
定义 float 类型的变量，赋值时需要以字母 "f" 或 "F" 作为后缀，否则被人为是 double 型变量。
Java 的浮点型常量（浮点型字面量）默认为 double 型。以字母 "d" 或 "D" 作为后缀，后缀可以省略。
关于 Java 浮点型精度的说明
- 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示 0.1、0.01、0.001 这样 10 的负次幂。（10 进制的 0.1 转为二进制，得到的将是一个无限循环的二进制数）
- 浮点类型 float、double 的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用 BigDecimal 类。
- 测试用例：
java
// 测试 1：为什么 0.1 + 0.2 不等于 0.3？因为 10 进制的 0.1 转为二进制，得到的将是一个无限循环的二进制数。
System.out.println(0.1 + 0.2);// 0.30000000000000004
//测试 2：
float ff1 = 123123123f;
// 精度损失。
// float：单精度，小数部分可以精确到 7 位有效数字（十进制）。
float ff2 = ff1 + 1;
// 1.2312312E8
System.out.println(ff1);
// 1.2312312E8
System.out.println(ff2);
// true
System.out.println(ff1 == ff2);练习
案例 1：定义圆周率并赋值为 3.14，现有 3 个圆的半径分别为 1.2、2.5、6，求它们的面积。
java
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 度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。
java
℃ = (℉ - 32) / 1.8java
public class Exercise2 {
public static void main(String[] args) {
double hua = 80;
double she = (hua-32) / 1.8;
System.out.println("华氏度" + hua + "℉转为摄氏度是" + she + "℃");
}
}Java 字符类型：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'表示换行符
- 形式 1：使用单引号 (' ') 括起来的单个字符。 例如：
- char 类型是可以进行运算的。因为它都对应有 Unicode 码，可以看做是一个数值。
Java 布尔类型：boolean
- boolean 类型用来判断逻辑条件，一般用于流程控制语句中：
- if 条件控制语句；
- while 循环控制语句；
- for 循环控制语句；
- do-while 循环控制语句；
- boolean 类型数据只有两个值：true、false，无其它。
- 不可以使用 0 或非 0 的整数替代 false 和 rue，这点和 C 语言不同。
- 拓展：Java 虚拟机中没有任何供 boolean 值专用的字节码指令，Java 语言表达所操作的 boolean 值，在编译之后都使用 java 虚拟机中的 int 数据类型来代替：true 用 1 表示，false 用 0 表示。——《java 虚拟机规范 8 版》
举例：
java
boolean isFlag = true;
if(isFlag){
//true 分支
}else{
//false 分支
}Java 基本数据类型变量间运算规则
在 Java 程序中，不同的基本数据类型变量的值经常需要进行相互转换。(boolean 也是基本数据类型，但是它一般不和其他基本数据类型进行转换)
转换的方式有两种：自动类型提升和强制类型转换。
自动类型提升
规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型。
基本数据类型的转换规则如图所示：
（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时
java
int i = 'A';// char 自动升级为 int，其实就是把字符的编码值赋值给 i 变量了
double d = 10;// int 自动升级为 double（如果 int 型数字非常大，转换为 double 型后有可能精度会损失）
long num = 1234567; // 右边的整数常量值如果在 int 范围呢，编译和运行都可以通过，这里涉及到数据类型转换
//byte bigB = 130; // 错误，右边的整数常量值超过 byte 范围
// 右边的整数常量值如果超过 int 范围，必须加 L，显式表示 long 类型。否则编译不通过
// 为啥？？因为整形字面量被认为是 int 类型。
long bigNum = 12345678912L;（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。
java
int i = 1;
byte b = 1;
double d = 1.0;
double sum = i + b + d; // 混合运算，升级为 double（3）当 byte, short, char 数据类型的变量进行算术运算时，按照 int 类型处理。
java
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 的值类型为：【C】（因为 double 型的变量能表示的数据范围最大）
A. int B. long C. double D. char强制类型转换
将 3.14 赋值到 int 类型变量会发生什么？产生编译失败，肯定无法赋值。
java
int i = 3.14; // 编译报错想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成 int 类型才能赋值。
规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。
自动类型提升是 Java 自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。
转换格式：
java
数据类型1 变量名 = (数据类型1)被强转数据值; // () 中的数据类型必须 <= 变量值的数据类型（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。
java
int i = (int)3.14;//损失精度
double d = 1.2;
int num = (int)d;//损失精度
int i = 200;
byte b = (byte)i;//溢出（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。
java
int i = 1;
int j = 2;
double bigger = (double)(i/j);（3）声明 long 类型变量时，可以出现省略后缀的情况。float 则不同。
java
long l1 = 123L;
long l2 = 123; //如何理解呢？因为整形字面量被认为是 int 类型，然后 int 类型的 123 自动类型提升为 long 类型
//long l3 = 123123123123; // 报错，因为 123123123123 超出了 in t 的范围。
long l4 = 123123123123L;
//float f1 = 12.3; // 报错，因为 12.3 看做是 double，不能自动转换为 float 类型
float f2 = 12.3F;
float f3 = (float)12.3;练习：判断是否能通过编译
java
// s 是 short 类型，下面赋值的时候，s 还是 short 类型，但 s-2 被自动转为了 int 类型
// 1）
short s = 5;
s = s-2; // 判断：no
// 与 1）同理
// 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（byte、short、char 运算，转为 int）问答：为什么标识符的声明规则里要求不能数字开头？
java
//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中 l 的值到底是 123？还是变量 123L 对应的取值 12 呢？出现歧义了。
long l = 123L;Java 基本数据类型与 String 的运算
Java 的字符串类型：String
- String 不是基本数据类型，属于引用数据类型
- 使用一对双引号
""来表示一个字符串，内部可以包含 0 个、1 个或多个字符。 - 声明方式与基本数据类型类似。例如：String str = "尚硅谷";
运算规则
1、任意八种基本数据类型的数据与 String 类型只能进行连接 “+”运算，且结果一定也是 String 类型
java
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 类型不能通过强制类型 () 转换为其他的类型
java
String str = "123";
int num = (int)str; // 错误
int num = Integer.parseInt(str); // 正确的，后面才能讲到，借助包装类的方法才能转案例与练习
案例：公安局身份登记
要求填写自己的姓名、年龄、性别、体重、婚姻状况（已婚用 true 表示，单身用 false 表示）、联系方式等等。
java
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);
}
}练习： String 类型与 char 类型使用 + 号连接运算符，直接将值连接。
练习 1：
java
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); //输出：Hello!34
System.out.println('a'+1+"Hello!"); //输出：97 + 1 + "Hello!" == 97Hello!
System.out.println("Hello"+'a'+1); //输出：Hello651练习 2：
java
System.out.println("* *"); //输出："* *"
System.out.println("*\t*"); //输出："* *"
System.out.println("*" + "\t" + "*"); //输出："* *"
System.out.println('*' + "\t" + "*"); //输出："* *"
System.out.println('*' + '\t' + "*"); //输出：xx*
System.out.println('*' + "\t" + '*'); //输出："* *"
System.out.println("*" + '\t' + '*'); //输出："* *"
System.out.println('*' + '\t' + '*'); //输出：xxxJava 的运算符（Operator）
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
运算符的分类：
- 按照功能分为：算术运算符、赋值运算符、比较（或关系）运算符、逻辑运算符、位运算符、条件运算符、Lambda 运算符
| 分类 | 运算符 |
|---|---|
| 算术运算符（7 个） | +、-、*、/、%、++、-- |
| 赋值运算符（12 个） | =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等 |
| 比较 (或关系) 运算符（6 个） | >、>=、<、<=、==、!= |
| 逻辑运算符（6 个） | &、|、^、!、&&、|| |
| 位运算符（7 个） | &、|、^、~、<<、>>、>>> |
| 条件运算符（1 个） | (条件表达式) ? 结果 1 : 结果 2 |
| Lambda 运算符（1 个） | -> |
- 按照
操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）
| 分类 | 运算符 |
|---|---|
| 一元运算符（单目运算符） | 正号（+）、负号（-）、++、--、!、~ |
| 二元运算符（双目运算符） | 除了一元和三元运算符剩下的都是二元运算符 |
| 三元运算符（三目运算符） | (条件表达式) ? 结果 1 : 结果 2 |
算术运算符
基本语法
举例 1：加减乘除模
java
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：“+”号的两种用法
- 第一种：对于
+两边都是数值的话，+就是加法的意思 - 第二种：对于
+两边至少有一边是字符串的话，+就是拼接的意思
java
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++。
java
public class ArithmeticTest3 {
public static void main(String[] args) {
// 定义一个 int 类型的变量 a
int a = 3;
// ++a;
a++;
// 无论是变量前 ++ 还是变量后 ++，结果都是 4
System.out.println(a);
}
}2、复合使用
- 和
其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
- 变量
前++：变量先自增 1，然后再运算。 - 变量
后++：变量先运算，然后再自增 1。
java
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);
}
}案例与练习
案例 1：
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字 xxx 的情况如下：
个位数：
十位数：
百位数：
例如：
数字 153 的情况如下：
个位数：3
十位数：5
百位数：1java
class ArithmeticExer1 {
public static void main(String[] args) {
int num = 187;
int bai = num / 100;
int shi = num % 100 / 10; // int shi = num / 10 % 10;
int ge = num % 10;
System.out.println("百位为：" + bai);
System.out.println("十位为：" + shi);
System.out.println("个位为：" + ge);
}
}拓展：获取一个四位数的个位，十位，百位，千位
java
public class ArithmeticExer01 {
public static void main (String [] args) {
//1.定义一个变量，赋值为一个四位数整数，例如 1234
int num = 1234;
//2.通过运算操作求出个位，十位，百位，千位
int ge = num % 10;
int shi = num / 10 % 10;
int bai = num /100 % 10;
int qian = num / 1000 % 10;
System.out.println("个位上的数字是：" + ge);
System.out.println("十位上的数字是：" + shi);
System.out.println("百位上的数字是：" + bai);
System.out.println("千位上的数字是：" + qian);
}
}案例 2：为抵抗洪水，战士连续作战 89 小时，编程计算共多少天零多少小时？
java
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：算术运算符：自加、自减
java
public class ArithmeticExer3{
public static void main(String[] args){
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print("i=" + i); // 11
System.out.println("i1=" + i1); // 11
i = ++i1;
System.out.print("i=" + i); //
System.out.println("i1=" + i1); //
i = i2--;
System.out.print("i=" + i); //
System.out.println("i2=" + i2); //
i = --i2;
System.out.print("i=" + i); //
System.out.println("i2=" + i2); //
}
}练习 2：
java
System.out.println("5+5=" + 5 + 5); // 打印结果是？5+5=55 ?练习 3：
java
byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1); // -128练习 4：
java
int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j);练习 5：（企业真题）写出下列程序的输出结果
java
int i = 2;
int j = i++;
System.out.println(j);
int m = 2;
m = m++; // (1) 先取 b 的值“2”放操作数栈 (2) m 再自增，m = 3 (3) 再把操作数栈中的 "2" 赋值给 m，m = 2
System.out.println(m);赋值运算符
基本语法
符号：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持
连续赋值。
扩展赋值运算符： +=、 -=、*=、 /=、%=
赋值运算符 符号解释 +=将符号 左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量-=将符号 左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量*=将符号 左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量/=将符号 左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量%=将符号 左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量
java
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);
}
}练习
练习 1：
java
short s = 3;
s = s + 2; // ① 编译报错
s += 2; // ② 正常执行
// ① 和 ② 有什么区别？
// 第一个 2 被视为 int 类型，(s + 2) 就也被视为 int 类型了。第二个 JVM 会自动转为 short 类型。练习 2：
java
int i = 1;
i *= 0.1;
System.out.println(i); // 0
i++;
System.out.println(i); // 1练习 3：
java
int m = 2;
int n = 3;
n *= m++; // n = n * m++;
System.out.println("m=" + m); // 3
System.out.println("n=" + n); // 6练习 4：
java
int n = 10;
n += (n++) + (++n); //n = n + (n++) + (++n)
System.out.println(n);//32练习 5：你有几种办法实现变量值减 1？变量值减 2 呢？
java
public class MinusTest {
public static void main(String[] args) {
// 练习 ①：变量值减 1
short s = 10;
// 方式 1：
// s = (short)(s - 1);
// 方式 2：推荐
s--; // 或者 --s
// 方式 3：
s -= 1;
// 练习 ②：变量值减 2
short s1 = 10;
// 方式 1：
// s1 = (short)(s1 - 2);
// 方式 2：推荐
s1 -= 2;
}
}比较（关系）运算符
- 比较运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
\><>=<=：只适用于基本数据类型（除基本数据类型 boolean 之外）==!=：适用于基本数据类型和引用数据类型- 比较运算符“
==”不能误写成“=”
举例：
java
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
boolean b1 = false;
boolean b2 = true;
System.out.println(b1 == b2); // false
System.out.println(b1 = b2); // true
}
}思考：
java
boolean b1 = false;
// 区分好 == 和 = 的区别。
if (b1 == true) // if (b1 = true)
System.out.println("结果为真");
else
System.out.println("结果为假");逻辑运算符
基本语法
逻辑运算符，操作的都是 boolean 类型的变量或常量，而且运算得结果也是 boolean 类型的值。
运算符说明：
- & 和 &&：表示"且"关系，当符号左右两边布尔值都是 true 时，结果才能为 true。否则，为 false
- | 和 ||：表示"或"关系，当符号两边布尔值有一边为 true 时，结果为 true。当两边都为 false 时，结果为 false
- !：表示"非"关系，当变量布尔值为 true 时，结果为 false。当变量布尔值为 false 时，结果为 true
- ^：当符号左右两边布尔值不同时，结果为 true。当两边布尔值相同时，结果为 false。（理解：
异或，追求的是“异”！）
逻辑运算符用于连接布尔型表达式，在 Java 中不可以写成 3 < x < 6，应该写成 x > 3 & x < 6。
区分“&”和“&&”：
相同点：如果符号左边是 true，则二者都执行符号右边的操作
不同点：
- & ：如果符号左边是 false，则继续执行符号右边的操作
- && ：如果符号左边是 false，则不再继续执行符号右边的操作
建议：开发中，推荐使用 &&
一句话，不管怎样 & 都会执行符号两边的操作
区分“|”和“||”：
相同点：如果符号左边是 false，则二者都执行符号右边的操作
不同点：
- | ：如果符号左边是 true，则继续执行符号右边的操作
- || ：如果符号左边是 true，则不再继续执行符号右边的操作
建议：开发中，推荐使用 ||
一句话，不管怎样 | 都会执行符号两边的操作
代码举例：
java
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));
System.out.println((a > b) & (a < c));
System.out.println((a < b) & (a > c));
System.out.println((a < b) & (a < c));
System.out.println("===============");
// | 或；有 true 则 true
System.out.println((a > b) | (a > c));
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
System.out.println((a > b) ^ (a > c));
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);
System.out.println(!true);
// & 和 && 的区别
System.out.println((a > b) & (a++ > c));
System.out.println("a = " + a);
System.out.println((a > b) && (a++ > c));
System.out.println("a = " + a);
System.out.println((a == b) && (a++ > c));
System.out.println("a = " + a);
// | 和 || 的区别
System.out.println((a > b) | (a++ > c));
System.out.println("a = " + a);
System.out.println((a > b) || (a++ > c));
System.out.println("a = " + a);
System.out.println((a == b) || (a++ > c));
System.out.println("a = " + a);
}
}案例与练习
案例：
1. 定义类 CompareLogicExer
2. 定义 main 方法
3. 定义一个 int 类型变量 a,变量 b,都赋值为 20
4. 定义 boolean 类型变量 bo1 , 判断 ++a 是否被 3 整除,并且 a++ 是否被 7 整除,将结果赋值给 bo1
5. 输出 a 的值，bo1 的值
6. 定义 boolean 类型变量 bo2 , 判断 b++ 是否被 3 整除,并且 ++b 是否被 7 整除,将结果赋值给 bo2
7. 输出 b 的值，bo2 的值java
public class CompareLogicExer {
public static void main(String[] args){
int a = 20;
int b = 20;
boolean bo1 = ((++a % 3) == 0) && ((a++ % 7) == 0);
System.out.println("bo1 的值：" + bo1);
System.out.println("a 的值：" + a);
System.out.println("----------------------------");
boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0);
System.out.println("bo2 的值：" + bo2);
System.out.println("b 的值：" + b);
}
}练习 1：区分 & 和 &&
java
int x = 1;
int y = 1;
if(x++ == 2 & ++y == 2){
x = 7;
}
System.out.println("x=" + x + ",y=" + y);java
int x = 1,y = 1;
if(x++ == 2 && ++y == 2){
x =7;
}
System.out.println("x="+x+",y="+y);练习 2：区分 | 和 ||
java
int x = 1, y = 1;
if(x++==1 | ++y==1){
x = 7;
}
System.out.println("x="+x+",y="+y);java
int x = 1, y = 1;
if(x++==1 || ++y==1){
x = 7;
}
System.out.println("x="+x+",y="+y);练习 3：程序输出
java
class Test {
public static void main (String [] args) {
boolean x = true;
boolean y = false;
short z = 42;
if ((z++ == 42) && (y = true)) {
z++;
}
if ((x = false) || (++z == 45)) {
z++;
}
System.out.println("z=" + z);
}
}java
//结果为：
//z = 46位运算符
基本语法
- 位运算符的运算过程都是基于二进制的补码运算
（1）左移：<<
运算规则：在一定范围内，数据每向左移动一位，相当于原数据 *2。（正数、负数都适用。但实际情况好像不一样，比如 -3 左移 30 位，得到的数是正数而不是负数）
【注意】当左移的位数 n 超过该数据类型的总位数时，相当于左移（n-总位数）位。
比如十进制 3，二进制转 10 进制为
3 << 4类似于=> => 48
java
-3<<4 类似于 -3*2的4次幂 => -3*16 => -48
（2）右移：>>
运算规则：在一定范围内，数据每向右移动一位，相当于原数据 / 2。（正数、负数都适用）
【注意】如果不能整除，向下取整。
java
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。
1 & 1 结果为 1
1 & 0 结果为 0
0 & 1 结果为 0
0 & 0 结果为 0
java
9 & 7 = 1
java
-9 & 7 = 7
（5）按位或：|
运算规则：对应位只要有 1 即为 1，否则为 0。
1 | 1 结果为 1
1 | 0 结果为 1
0 | 1 结果为 1
0 & 0 结果为 0
java
9 | 7 //结果：15
java
-9 | 7 //结果： -9
（6）按位异或：^ 运算规则：对应位一个为 1 一个为 0，才为 1，否则为 0。
1 ^ 1 结果为 0
1 ^ 0 结果为 1
0 ^ 1 结果为 1
0 ^ 0 结果为 0
java
9 ^ 7 //结果为 14
java
-9 ^ 7 //结果为 -16
（7）按位取反：~
运算规则：对应位为 1，则结果为 0；对应位为 0，则结果为 1。
~0 就是 1
~1 就是 0
java
~9 //结果：-10
java
~-9 //结果：8
举例
举例 1：
举例 2：体会 m = k ^ n = (m ^ n) ^ n
案例
案例 1：高效的方式计算 2 * 8 的值（经典面试题）
答案：2 << 3 、 8 << 1案例 2：如何交换两个 int 型变量的值？String 呢？
java
/**
* @author 尚硅谷 - 宋红康
* @create 16:58
*/
public class BitExer {
public static void main(String[] args) {
int m = 10;
int n = 5;
System.out.println("m = " + m + ", n = " + n);
//（推荐）实现方式 1：优点：容易理解，适用于不同数据类型 缺点：需要额外定义变量
//int temp = m;
//m = n;
//n = temp;
//实现方式 2：优点：没有额外定义变量 缺点：可能超出 int 的范围；只能适用于数值类型
//m = m + n; //15 = 10 + 5
//n = m - n;//10 = 15 - 5
//m = m - n;//5 = 15 - 10
//实现方式 3：优点：没有额外定义变量 缺点：不易理解；只能适用于数值类型
m = m ^ n;
n = m ^ n; //(m ^ n) ^ n
m = m ^ n;
System.out.println("m = " + m + ", n = " + n);
}
}条件运算符
基本语法
- 条件运算符格式：
java
(条件表达式) ? 表达式 1 : 表达式 2- 说明：条件表达式是 boolean 类型的结果，根据 boolean 的值选择表达式 1 或表达式 2
- 如果运算后的结果赋给新的变量，要求表达式 1 和表达式 2 为同种或兼容的类型
java
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 非正数");
}案例
案例 1：获取两个数中的较大值
java
public class ConditionExer1 {
public static void main(String[] args) {
// 获取两个数的较大值
int m1 = 10;
int m2 = 20;
int max1 = (m1 > m2) ? m1 : m2;
System.out.println("m1 和 m2 中的较大值为" + max1);
}
}案例 2：获取三个数中的最大值
java
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"。
java
public class ConditionExer3 {
public static void main(String[] args) {
int week = 2;
week += 10;
week %= 7;
System.out.println("今天是周 2,10 天以后是周" + (week == 0 ? "日" : week));
}
}与 if-else 的转换关系
凡是可以使用条件运算符的地方，都可以改写为 if-else 结构。反之，不成立。
开发中，如果既可以使用条件运算符，又可以使用 if-else，推荐使用条件运算符。因为执行效率稍高。
java
//if-else 实现获取两个数的较大值
int i1 = 10;
int i2 = 20;
int max; // 声明变量 max，用于记录 i1 和 i2 的较大值
if(i1 > i2){
max = i1;
}else{
max = i2;
}
System.out.println(max);运算符优先级
运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。
| 优先级 | 运算符说明 | Java 运算符 |
|---|---|---|
| 1 | 括号 | ()、[]、{} |
| 2 | 正负号 | +、- |
| 3 | 单元运算符 | ++、--、~、！ |
| 4 | 乘法、除法、求余 | *、/、% |
| 5 | 加法、减法 | +、- |
| 6 | 移位运算符 | <<、>>、>>> |
| 7 | 关系运算符 | <、<=、>=、>、instanceof |
| 8 | 等价运算符 | ==、!= |
| 9 | 按位与 | & |
| 10 | 按位异或 | ^ |
| 11 | 按位或 | ` |
| 12 | 条件与 | && |
| 13 | 条件或 | ` |
| 14 | 三元运算符 | ? : |
| 15 | 赋值运算符 | =、+=、-=、*=、/=、%= |
| 16 | 位赋值运算符 | &=、` |
开发建议：
- 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量
使用 () 来控制表达式的执行顺序。- 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它
分成几步来完成。例如： (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;就有点复杂。