【天天Java系列】02_变量与运算符

lanbabela

已于 2023-02-27 20:22:46 修改

阅读量407

点赞数 1

分类专栏： Java 文章标签： java jvm 开发语言

于 2023-02-20 22:04:42 首次发布

本文链接：https://blog.csdn.net/m0_53612936/article/details/129129418

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

1.关键字（keyword）
2.标识符
3.变量
4.基本数据类型
5.基本数据类型变量间运算规则
6. 计算机底层如何存储数据
7. 运算符（Operator）（掌握）

1.关键字（keyword）

定义：被Java语言赋予特殊含义、用做专门用途的字符串（或单词），例如class、public、static、void等，这些单词已经被Java定义好了。
特点：全部关键字都是小写字母。
在这里插入图片描述

2.标识符

Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。凡是自己可以起名字的地方都叫标识符。
标识符命名规则：

由26个英文字母大小写，数字，_或$组成
数字不可以开头
不可以使用关键字和保留字，但能包含关键字和保留字
Java中严格区分大小写，长度无限制
标识符不能包含空格

练习：

class
int
public
12x
Apple

标识符的命名规范：(“见名知意”)

包名：多单词组成时所有字母都小写：xxyyzz。例如：java.lang
类名、接口名：多单词组成时，所有单词的首字母大写：XxYyZz。例如：HelloWorld，String，System等
变量名、方法名：多单词组成时，第一个单词手写字母，第二个单词开始每个单词首字母大写：xxxYyyZzz。例如：age，name，getName，setName
常量名：所有字母都大写。多单词时每个单词下划线连接：XXX_YYY_ZZZ。例如：MAX_VALUEM、PI

3.变量

3.1为什么需要变量？

变量是程序中不可或缺的组成单位，最基本的存储单元

3.2初识变量

变量的概念

内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化
变量的构成包含三个要素：数据类型、变量名、存储的值
Java中变量声明的格式：数据类型变量名 = 变量值

变量的作用：用于在内存中保存数据
注意：

Java中每个变量必须先声明，后使用
使用变量名来访问这块区域的数据
变量的作用域：其定义所在的一队{}内
变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。
同一个作用域内，不能定义重名的变量

3.3Java中变量的数据类型

Java中数据类型分为两大类：

基本数据类型：包括整数类型、浮点数类型、字符型类型、布尔类型
引用数据类型：包括数组、类、接口、枚举、注解、记录

在这里插入图片描述

3.4 变量的使用

3.4.1 变量的声明

//存储一个整数类型的年龄
int age;
//存储一个小数类型的体重
double weight;
//存储一个单字符类型的性别
char gender;
//存储一个布尔类型的婚姻状态
boolean marry;
//存储一个字符串类型的姓名
String name;
//声明多个同类型的变量
int a,b,c; //表示 a,b,c 三个变量都是 int 类型。

注意：变量的数据类型可以是基本数据类型，也可以是引用数据数据类型。

3.4.2 变量的赋值

给变量赋值，就是把“值”存到该变量代表的内存空间中。同时，给变量赋的值类型必须与变量声明的类型一致或兼容。
变量赋值的语法格式：

变量名 = 值;


 举例 1：可以使用合适类型的常量值给已经声明的变量赋值
age = 18;
weight = 109;
gender = '女';
举例 2：可以使用其他变量或者表达式给变量赋值
int m = 1;
int n = m;
 
int x = 1;
int y = 2;
int z = 2 * x + y;

变量可以反复赋值

//先声明，后初始化
char gender;
gender = '女';
//给变量重新赋值，修改 gender 变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男```

举例 4：也可以将变量的声明和赋值一并执行
boolean isBeauty = true;
String name = "迪丽热巴";

内存结构图

4.基本数据类型

4.1 整数类型：byte、short、int、long

在这里插入图片描述

定义 long 类型的变量，赋值时需要以"l"或"L"作为后缀。
Java 程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用 long。
Java 的整型常量默认为 int 型。

4.1.1 补充：计算机存储单位

字节（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

4.2 浮点类型：float、double

在这里插入图片描述
float：单精度，尾数可以精确到 7 位有效数字。很多情况下，精度很难满足需求。
double：双精度，精度是 float 的两倍。通常采用此类型。
定义 float 类型的变量，赋值时需要以"f"或"F"作为后缀。
Java 的浮点型常量默认为 double 型

4.2.1 应用案例

案例 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 radius = 6;
	System.out.println("第一个圆的面积：" + PI * radius1 * radius2);
	}
}

案例 2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。它需
要一个程序将华氏温度（80 度）转换为摄氏度，并以华氏度和摄氏度为单位分
别显示该温度

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编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式：

使用单引号（’ '）括起来的单个字符。例如：char c1 = ‘a’;char c2 = ‘中’;char c3 = ‘9’;
直接使用Unicode值来表示字符型常量：‘\uXXXX’ 。其中，XXXX代表一个十六进制整数。例如：\u0023 表示’#'。
Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如:char c3 = ‘\n’; // '\n’表示换行符

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.基本数据类型变量间运算规则

在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。
转换的方式有两种：自动类型提升和强制类型转换。

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

5.2 强制类型转换

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）
的类型。
自动类型提升是 Java 自动执行的，而强制类型转换是自动类型提升的
逆运算，需要我们自己手动执行。
转换格式：
数据类型 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 自动类型提升为 l
ong 类型
//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 + "，gen
der = " +
 gender + ",weight = " + weight + ",isMarried
= " + isMarried +
 ",phoneNumber = " + phoneNumber);
 } }
练习：
练习 1：
String str1 = 4; //判断对错：
String str2 = 3.5f + ""; //判断 str2 对错：
System.out.println(str2); //输出：
System.out .println(3+4+"Hello!"); //输出：
System.out.println("Hello!"+3+4); //输出：
System.out.println('a'+1+"Hello!"); //输出：
System.out.println("Hello"+'a'+1); //输出：
练习 2：
System.out.println("* *"); //输出：
System.out.println("*\t*"); //输出：
System.out.println("*" + "\t" + "*"); //输出：
System.out.println('*' + "\t" + "*"); //输出：
System.out.println('*' + '\t' + "*"); //输出：
System.out.println('*' + "\t" + '*'); //输出：
System.out.println("*" + '\t' + '*'); //输出：
System.out.println('*' + '\t' + '*'); //输出：

6. 计算机底层如何存储数据

计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进
制。包括数字、字符、图片、声音、视频等

6.1 进制的分类

十进制（decimal） – 数字组成：0-9 – 进位规则：满十进一
二进制（binary）
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.3 二进制的由来

二进制，是计算技术中广泛采用的一种数制，由德国数理哲学大师莱布尼茨于
1679 年发明。
二进制数据是用 0 和 1 两个数码来表示的数。它的基数为 2，进位规则是“逢二
进一”。
二进制广泛应用于我们生活的方方面面。比如，广泛使用的摩尔斯电码
（Morse Code），它由两种基本信号组成：短促的点信号“·”，读“滴”；保持一
定时间的长信号“—”，读“嗒”。然后，组成了 26 个字母，从而拼写出相应的单
词。

6.4 二进制转十进制

二进制如何表示整数？
计算机数据的存储使用二进制补码形式存储，并且最高位是符号位。 – 正数：最高位是 0 – 负数：最高位是 1 规定 – 正数的补码与反码、原码一样，称为三码合一
– 负数的补码与反码、原码不一样：
负数的原码：把十进制转为二进制，然后最高位设置为 1
负数的反码：在原码的基础上，最高位不变，其余位取反（0 变 1,1 变 0）
负数的补码：反码+1
二进制转十进制：权相加法

7. 运算符（Operator）（掌握）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
运算符的分类：
按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算
符、条件运算符、Lambda 运算符

分类 运算符
算术运算符（7 个） +、-、*、/、%、++、--
赋值运算符（12 个） =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、
&=、|=、^=等
比较(或关系)运算符
（6 个）
>、>=、<、<=、==、!=
逻辑运算符（6 个） &、|、^、!、&&、||
位运算符（7 个） &、|、^、~、<<、>>、>>>
条件运算符（1 个） (条件表达式)?结果 1:结果 2
Lambda 运算符（1
个）

按照操作个数分为：
一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）

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.2 赋值运算符
###  7.2.1 基本语法

```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);
} }```
## 7.3 比较运算符
![在这里插入图片描述](https://img-blog.csdnimg.cn/3912b42b0954423690fe7b32b9d65443.png)

```java
 比较运算符的结果都是 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
boolean b1 = false;
boolean b2 = true;
System.out.println(b1 == b2);//false
System.out.println(b1 = b2);//true
} }
思考：
boolean b1 = false;
//区分好==和=的区别。
if(b1 == true) //if(b1 = true)
System.out.println("结果为真");
else
System.out.println("结果为假");

7.4 逻辑运算符

7.4.1 基本语法

在这里插入图片描述

逻辑运算符，操作的都是 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，则不再继续执行符号右边的操作
建议：开发中，推荐使用 ||
代码举例：
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);
}
}

7.5 条件运算符

7.5.1 基本语法

条件运算符格式：
(条件表达式)? 表达式 1:表达式 2
说明：条件表达式是 boolean 类型的结果，根据 boolean 的值选择表达式 1 或表达式 2
在这里插入图片描述
如果运算后的结果赋给新的变量，要求表达式 1 和表达式 2 为同种或兼容的类型

 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 非正数");
}
7.6.2 案例 
案例 1：获取两个数中的较大值
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：获取三个数中的最大值
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.6.3 与 if-else 的转换关系

凡是可以使用条件运算符的地方，都可以改写为 if-else 结构。反之，不成立。
开发中，如果既可以使用条件运算符，又可以使用 if-else，推荐使用条件运算符。因为
执行效率稍高

//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);

7.7 运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。

优先级 运算符说明 Java 运算符
1 括号 ()、[]、{}
2 正负号 +、- 3 单元运算符 ++、--、~、！ 4 乘法、除法、求余 *、/、% 5 加法、减法 +、- 6 移位运算符 <<、>>、>>>
7 关系运算符 <、<=、>=、>、instanceof
8 等价运算符 ==、!=
9 按位与 &
10 按位异或 ^
11 按位或 |
12 条件与 &&
13 条件或 ||
14 三元运算符 ? :
15 赋值运算符 =、+=、-=、*=、/=、%=
16 位赋值运算符 &=、|=、<<=、>>=、>>>=