Java 基础语法2

2.8 运算符

计算机的最基本用途之一就是执行数学运算,作为一门计算机语言,Java 也提供了一套丰富的运算符(operator)来操作变量。

2.8.1 算术运算符

算术运算符中 +,-,*,/,% 属于二元运算符,二元运算符指的是需要两个操作数才能完成运算的运算符。其中的 % 是取模运算符,就是我们常说的求余数操作。

符号作用说明
+参看小学一年级
-参看小学一年级
*参看小学二年级,与“×”相同
/参看小学二年级,与“÷”相同
%取余获取的是两个数据做除法的余数

/ 和 % 的区别:两个数据做除法,/ 取结果的商,% 取结果的余数。 整数操作只能得到整数,要想得到小数,必须有浮点数参与运算。

int a = 10;
int b = 3;
System.out.println(a / b); // 输出结果 3
System.out.println(a % b); // 输出结果 1

1. 二元运算符的运算规则

整数运算:

  1. 如果两个操作数有一个为 long,则结果也为 long。
  2. 没有 long 时,结果为 int。即使操作数全为 short 或 byte,结果也是 int。

浮点运算:

  1. 如果两个操作数有一个为 double,则结果为 double。
  2. 只有两个操作数都是 float,则结果才为 float。

取模运算:

  1. 其操作数可以为浮点数,一般使用整数,结果是“余数”,“余数”符号和左边操作数相同,如:7 % 3 = 1,-7 % 3 = -1,7 % -3 = 1。

2. 类型提升规则

算术表达式中包含不同的基本数据类型的值的时候,整个算术表达式的类型会自动进行提升。

提升规则: byte 类型,short 类型和 char 类型将被提升到 int 类型,不管是否有其他类型参与运算。 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型。

等级顺序:byte,short,char --> int --> long --> float --> double

byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; // 该行报错,因为 byte 类型参与算术运算会自动提示为 int,int 赋值给 byte 可能损失精度
int i3 = b1 + b2; // 应该使用 int 接收
byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为 byte 类型
/*-------------------------------*/
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用 double 接收,因为 num1 会自动提升为 double 类型

正是由于上述原因,所以在程序开发中我们很少使用 byte 或者 short 类型定义整数。也很少会使用 char 类型定义字符,而使用字符串类型,更不会使用char 类型做算术运算。

3. 字符的“+”操作

char 类型参与算术运算,使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值:

'a' = 97:a-z 是连续的,所以 'b' 对应的数值是 98,'c' 是 99,依次递加

'A' = 65:A-Z 是连续的,所以 'B' 对应的数值是 66,'C' 是 67,依次递加

'0' = 48:0-9 是连续的,所以 '1' 对应的数值是 49,'2' 是 50,依次递加

// 可以通过使用字符与整数做算术运算,得出字符对应的数值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出 98,97 + 1 = 98

char ch2 = 'A';
System.out.println(ch2 + 1); // 输出 66,65 + 1 = 66

char ch3 = '0';
System.out.println(ch3 + 1); // 输出 49,48 + 1 = 49

4. 字符串的“+”操作

当“+”操作中出现字符串时,这个“+”是字符串连接符,而不是算术运算。

System.out.println("IZJ" + 666); // 输出:IZJ666

在“+”操作中,如果出现了字符串,就是连接运算符,否则就是算术运算。当连续进行“+”操作时,从左到右逐个执行。

System.out.println(1 + 99 + "年"); // 输出:100 年
System.out.println(1 + 2 + "IZJ" + 3 + 4); // 输出:3IZJ34
// 可以使用小括号改变运算的优先级 
System.out.println(1 + 2 + "IZJ" + (3 + 4)); // 输出:3IZJ7

2.8.2 自增自减运算符

算术运算符中 ++,-- 属于一元运算符,该类运算符只需要一个操作数。

符号作用说明
++自增变量的值加1
--自减变量的值减1

注意事项:

  1. ++ 和 -- 既可以放在变量的后边,也可以放在变量的前边。
  2. 单独使用的时候, ++ 和 -- 无论是放在变量的前边还是后边,结果是一样的。
  3. 参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做 ++ 或者 --。
  4. 参与操作的时候,如果放在变量的前边,先拿变量做 ++ 或者 --,后拿变量参与操作。
  5. 最常见的用法:单独使用。
int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11

int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11

int x = 10;
int y = x++; // 赋值运算,++在后边,所以是使用x原来的值赋值给y,x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11,y:10

int m = 10;
int n = ++m; // 赋值运算,++在前边,所以是使用m自增后的值赋值给n,m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11,m:11

练习:

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); // y的值是多少?
/*
解析,三个表达式都是++在后,所以每次使用的都是自增前的值,但程序自左至右执行,所以第一次自增时,使用的是10进行计算,但第二次自增时,x的值已经自增到11了,所以第二次使用的是11,然后再次自增。。。
所以整个式子应该是:int y = 10 + 11 + 12;
输出结果为33。
*/

注意:通过此练习深刻理解自增和自减的规律,但实际开发中强烈建议不要写这样的代码!小心挨打!

2.8.3 赋值及其扩展赋值运算符

运算符用法举例等效的表达式
+=a += ba = a+b
-=a -= ba = a-b
*=a *= ba = a*b
/=a *= ba = a/b
%=a *= ba = a%b
int a = 3;
int b = 4;
a += b; // 相当于a = a + b;
System.out.println("a=" + a + "\nb=" + b);
a = 3;
a *= b + 3; // 相当于a = a * (b + 3)
System.out.println("a=" + a + "\nb=" + b);

**注意:**扩展的赋值运算符隐含了强制类型转换。

short s = 10;
s = s + 10; // 此行代码报出,因为运算中 s 提升为 int 类型,运算结果 int 赋值给 short 可能损失精度
s += 10; // 此行代码没有问题,隐含了强制类型转换,相当于 s = (short) (s + 10);

2.8.4 关系运算符

关系运算符用来进行比较运算。关系运算的结果是布尔值:true/false。

运算符含义示例
==等于a==b
!=不等于a!=b
>大于a>b
<小于a<b
>=大于或等于a>=b
<=小于或等于a<=b

注意事项

  • 关系运算符的结果都是 boolean 类型,要么是 true,要么是 false。
  • 千万不要把==误写成 ===是判断是否相等的关系,= 是赋值。
  • ==!= 是所有(基本和引用)数据类型都可以使用
  • >、>=、 <、 <= 仅针对数值类型(byte/short/int/long, float/double,以及 char)

2.8.5 逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式,以判断程序中的表达式是否成立,判断的结果是 true 或 false。

符号作用说明
&逻辑与a & b,a 和 b都是 true,结果为 true,否则为 false
|逻辑或a | b,a 和 b都是 false,结果为 false,否则为 true
^逻辑异或a ^ b,a 和 b结果不同为 true,相同为 false
!逻辑非!a,结果和 a 的结果正好相反
&&短路与作用和 & 相同,但是有短路效果
||短路或作用和 | 相同,但是有短路效果

短路与和短路或采用短路的方式。从左到右计算,如果只通过运算符左边的操作数就能够确定该逻辑表达式的值,则不会继续计算运算符右边的操作数,提高效率。

// 定义变量
int i = 10;
int j = 20;
int k = 30;

// & “与”,并且的关系,只要表达式中有一个值为 false,结果即为 false
System.out.println((i > j) & (i > k)); // false & false,输出 false
System.out.println((i < j) & (i > k)); // true & false,输出 false
System.out.println((i > j) & (i < k)); // false & true,输出 false
System.out.println((i < j) & (i < k)); // true & true,输出 true
System.out.println("--------");

// | “或”,或者的关系,只要表达式中有一个值为 true,结果即为 true
System.out.println((i > j) | (i > k)); // false | false,输出 false
System.out.println((i < j) | (i > k)); // true | false,输出 true
System.out.println((i > j) | (i < k)); // false | true,输出 true
System.out.println((i < j) | (i < k)); // true | true,输出 true
System.out.println("--------");

// ^ “异或”,相同为 false,不同为 true
System.out.println((i > j) ^ (i > k)); // false ^ false,输出 false
System.out.println((i < j) ^ (i > k)); // true ^ false,输出 true
System.out.println((i > j) ^ (i < k)); // false ^ true,输出 true
System.out.println((i < j) ^ (i < k)); // true ^ true,输出 false
System.out.println("--------");

// ! “非”,取反
System.out.println((i > j)); // false
System.out.println(!(i > j)); // !false,,输出 true

短路与和逻辑与

// 1>2 的结果为 false,那么整个表达式的结果即为 false,将不再计算 2>(3/0)
boolean c = 1>2 && 2>(3/0);
System.out.println(c);
// 1>2 的结果为 false,那么整个表达式的结果即为 false,还要计算 2>(3/0),0 不能做除数,// 会输出异常信息
boolean d = 1>2 & 2>(3/0);
System.out.println(d);

2.8.6 位运算符

位运算指的是进行二进制位的运算。

位运算符说明
~取反
&按位与
|按位或
^按位异或
<<左移运算符,左移1位相当于乘2
>>右移运算符,右移1位相当于除2取商
>>>无符号的右移,负数直接转正,其他与>>相当

左移运算和右移运算

int a = 3 * 2 * 2;
int b = 3 << 2; //相当于:3 * 2 * 2;
int c = 12 / 2 / 2;
int d = 12 >> 2; //相当于 12 / 2 / 2;

注意:

  1. & 和 | 既是逻辑运算符,也是位运算符。如果两侧操作数都是 boolean 类型,就作为逻辑运算符。如果两侧的操作数是整数类型,就是位运算符。
  2. 不要把“^”当做数学运算“乘方”,是“位的异或”操作。

2.8.7 条件运算符

条件运算符,又称三元运算符。语法格式:

关系表达式 ? 表达式1 : 表达式2;

解释:问号前面的位置是判断的条件,判断结果为 boolean 型,为 true 时调用表达式1,为 false 时调用表达式2。其逻辑为:如果条件表达式成立或者满足则执行表达式 1,否则执行表达式 2。

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a>b 是否为真,如果为真取 a 的值,如果为假,取 b 的值
int score = 80;
int x = -100;
String type = score<60 ? "不及格" : "及格"; // 及格
int flag = x > 0 ? 1 : (x == 0 ? 0 : -1); // -1
System.out.println("type= " + type);
System.out.println("flag= "+ flag);

2.8.8 运算符优先级的问题

优先级运算符结合性
1()括号运算符由左至右
2!、+(正号)、-(负号)一元运算符由左至右
2~位逻辑运算符由右至左
2++、--递增与递减运算符由右至左
3*、/、%算术运算符由左至右
4+、-算术运算符由左至右
5<<、>>位左移、右移运算符由左至右
6>、>=、<、<=关系运算符由左至右
7==、!=关系运算符由左至右
8&位运算符、逻辑运算符由左至右
9^位运算符、逻辑运算符由左至右
10|位运算符、逻辑运算符由左至右
11&&逻辑运算符由左至右
12||逻辑运算符由左至右
13? :条件运算符由右至左
14=、+=、-=、*=、/=、%=赋值运算符、扩展运算符由右至左
  • 不需要刻意的记这些优先级,表达式里面优先使用小括号来组织!!
  • 逻辑与、逻辑或、逻辑非的优先级一定要熟悉!(逻辑非 > 逻辑与 > 逻辑或)。如:a || b && c的运算结果是:a || (b && c),而不是(a || b) && c

2.8.9 类型转换

1. 自动类型转换

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。如图所示,黑色的实线表示无数据丢失的自动类型转换,而虚线表示在转换时可能会有精度的损失。

可以将整型常量直接赋值给 byte、 short、 char 等类型变量,而不需要进行强制类型转换,只要不超出其表数范围即可。

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的,直接书写即可。例如:

double num = 10; // 将 int 类型的 10 直接赋值给 double 类型
System.out.println(num); // 输出 10.0

自动类型转换特例

short b = 12; // 合法
short b = 1234567; // 非法,1234567 超出了 short 的表示范围

2. 强制类型转换

强制类型转换,又被称为造型,用于显式的转换一个数值的类型。在有可能丢失信息的情况下进行的转换是通过造型来完成的,但可能造成精度降低或溢出。

格式:(type) var

type 表示将值 var 想要转换成的目标数据类型。

double x  = 3.14; 
int nx = (int) x;   // 值为3
char c = 'a';
int d = c + 1;
System.out.println(nx);
System.out.println(d);
System.out.println((char) d);

当将一种类型强制转换成另一种类型,而又超出了目标类型的表数范围,就会被截断成为一个完全不同的值。

int x = 300;
byte bx = (byte) x;    // 值为 44

**注意:**不能在布尔类型和任何数值类型之间做强制类型转换

3. 基本类型转化时常见错误和问题

操作比较大的数时,要留意是否溢出,尤其是整数操作时。

int money = 1000000000; // 10 亿
int years = 20;
// 返回的 total 是负数,超过了 int 的范围
int total = money * years;
System.out.println("total=" + total); // -1474836480

// 返回的 total 仍然是负数。默认是 int,因此结果会转成 int 值,再转成 long。但是已经发生了数据丢失
long total1 = money * years; 
System.out.println("total1=" + total1); // -1474836480

// 返回的 total2 正确:先将一个因子变成 long,整个表达式发生提升。全部用 long 来计算。
long total2 = money * ((long) years); 
System.out.println("total2=" + total2); // 20000000000

2.9 简单的数据输入

为了我们能写出更加复杂的程序,可以让我们的程序和用户可以通过键盘交互,我们先学习一下简单的键盘输入和输出。

  • 使用步骤如下:

    1. 导包。Scanner 类在 java.util 包下,所以需要将该类导入。导包的语句需要定义在类的上面。

      import java.util.Scanner; 
      
    2. 创建Scanner对象。

      Scanner sc = new Scanner(System.in);// 创建 Scanner 对象,sc 表示变量名,其他均不可变
      
    3. 接收数据

      int i = sc.nextInt(); // 表示将键盘录入的值作为 int 数返回。
      

示例:

import java.util.Scanner;
/**
 * 测试键盘输入
 * @author IZJ
 *
 */
public class TestScanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        System.out.println(a);
    }
}