Java从入门到起飞之变量与运算符详解

目录

• 1. 关键字
• 2. 标识符
• 3. 变量
• 3.1 初识变量
• 3.2 Java中变量的数据类型
• 3.3 变量的使用
• 3.3.1 步骤1：变量的声明
• 3.3.2 步骤2：变量的赋值
• 4. 基本数据类型介绍
• 4.1 整数类型：byte、short、int、long
• 4.1.1 补充：计算机存储单位
• 4.2 浮点类型：float、double
• 4.2.1 关于浮点型精度的说明
• 4.3 字符类型：char
• 4.4 布尔类型：boolean
• 5. 基本数据类型变量间运算规则
• 5.1 自动类型提升
• 5.2 强制类型转换
• 6 基本数据类型与String的运算
• 6.1 字符串类型：String
• 6.2 运算规则
• 7. 运算符
• 7.1 算术运算符
• 7.1.1 基本语法
• 7.2 赋值运算符
• 7.2.1 基本语法
• 7.3 比较(关系)运算符
• 7.4 逻辑运算符
• 7.4.1 基本语法
• 7.5 位运算符
• 7.5.1 基本语法
• 7.6 条件运算符
• 7.6.1 基本语法
• 7.6.2 与if-else的转换关系
• 7.7 运算符优先级
• 总结 

1. 关键字

• 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（或单词）
  • HelloWorld案例中，出现的关键字有 class、public 、 static 、 void 等，这些单词已经被Java定义好了。
• 特点：全部关键字都是小写字母。
• 关键字比较多，不需要死记硬背，学到哪里记到哪里即可。

  

说明：

关键字一共50个，其中const和goto是保留字(reserved word)。

true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。

2. 标识符

Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。

技巧：凡是自己可以起名字的地方都叫标识符。

标识符的命名规则（必须遵守的硬性规定）：

由26个英文字母大小写，0-9 ，_或 $ 组成

数字不可以开头。

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格。

3. 变量

3.1 初识变量

• 变量的概念：

  • 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化

  • 变量的构成包含三个要素：数据类型、变量名、存储的值

  • Java中变量声明的格式：数据类型 变量名 = 变量值

• 变量的作用：用于在内存中保存数据。

• 使用变量注意：

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

3.2 Java中变量的数据类型

Java中变量的数据类型分为两大类：

• 基本数据类型：包括 整数类型、浮点数类型、字符类型、布尔类型。

• 引用数据类型：包括数组、 类、接口、枚举、注解、记录。

  

3.3 变量的使用

3.3.1 步骤1：变量的声明

格式：数据类型  变量名;

//例如：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

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

3.3.2 步骤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;

3：变量可以反复赋值

//先声明，后初始化
char gender;
gender = '女';

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

举例4：也可以将变量的声明和赋值一并执行

boolean isBeauty = true;
String name = "迪丽热巴";

内存结构如图：

4. 基本数据类型介绍

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

• Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。

• 定义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

• 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

• 浮点型常量有两种表示形式：
  • 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
  • 科学计数法形式。如：5.12e2 512E2 100E-2
• float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
• double：双精度，精度是float的两javascript倍。通常采用此类型。
• 定义float类型的变量，赋值时需要以"f"或"F"作为后缀。
• Java 的浮点型常量默认为double型。

4.2.1 关于浮点型精度的说明

• 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示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);
System.out.println(ff2);
System.out.println(ff1 == ff2);

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’表示换行符

  转义字符	说明	Unicode表示方式
  \n	换行符	\u000a
  \t	制表符	\u0009
  \"	双引号	\u0022
  \'	单引号	\u0027
  \\	反斜线	\u005c
  \b	退格符	\u0008
  \r	回车符	\u000d

• char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

4.4 布尔类型：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版》

• 举例：

boolean isFlag = true;

if(isFlag){
    //true分支
}else{  
    //false分支
}

经验之谈：

Less is More！建议不要这样写：if ( isFlag = = true )，只有新手才如此。关键也很容易写错成if(isFlag = true)，这样就变成赋值isFlag为true而不是判断！老鸟的写法是if (isFlag)或者if ( !isFlag)。

5. 基本数据类型变量间运算规则

在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。

转换的方式有两种：自动类型提升和强制类型转换。

5.1 自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

基本数据类型的转换规则如图所示：

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

int i = lZXlAnquR'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 

5.2 强制类型转换

将3.14 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 3.14; // 编译报错

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。

自动类型提升是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自动类型提升为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;

6 基本数据类型与String的运算

6.1 字符串类型：String

• String不是基本数据类型，属于引用数据类型
• 使用一对""来表示一个字符串，内部可以包含0python个、1个或多个字符。
• 声明方式与基本数据类型类似。例如：String str = “尚硅谷”;

6.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);//正确的，后面才能讲到，借助包装类的方法才能转

7. 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符的分类：

• 按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、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.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.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

		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。
  • ^ ：当符号左右两边布尔值不同时，结果为trujse。当两边布尔值相同时，结果为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。（正数、负数都适用）

【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

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。

• 1 & 1 结果为1

• 1 & 0 结果为0

• 0 & 1 结果为0

• 0 & 0 结果为0

9 & 7 = 1

-9 & 7 = 7

（5）按位或：|

运算规则：对应位只要有1即为1，否则为0。

• 1 | 1 结果为1

• 1 | 0 结果为1

• 0 | 1 结果为1

• 0 & 0 结果为0

9 | 7  //结果： 15

-9 | 7 //结果： -9

（6）按位异或：^

运算规则：对应位一个为1一个为0，才为1，否则为0。

• 1 ^ 1 结果为0

• 1 ^ 0 结果为1

• 0 ^ 1 结果为1

• 0 ^ 0 结果为0

9 ^ 7  //结果为14

-9 ^ 7 //结果为-16

（7）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1。

• ~0就是1

• ~1就是0

~9  //结果：-10

~-9  //结果：8

7.6 条件运算符

7.6.1 基本语法

• 条件运算符格式：

(条件表达式)? 表达式1:表达式2

• 说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2

  

• 如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型

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非正数");
}

7.6.2 与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	条件与	&awww.devze.commp;&
13	条件或	`
14	三元运算符	? :
15	赋值运算符	=、+=、-=、*=、/=、%=
16	位赋值运算符	&=、`

开发建议：

不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用()来控制表达式的执行顺序。

不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。例如：

​ (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

总结 

到此这篇关于Java变量与运算符详解的文章就介绍到这了,更多相关Java变量与运算符内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！