前情提要:
每个人的生活里都有阴影,但是若没这些阴影,又如何能知道我们正站在光里。
作者主页: 追光者♂
个人简介:
[1] 计算机专业硕士研究生
[2] 2022年度博客之星人工智能领域TOP4
[3] 阿里云社区特邀专家博主
[4] CSDN-人工智能领域优质创作者
[5] 预期2023年10月份 · 准CSDN博客专家
- 无限进步,一起追光!!!
感谢大家 点赞 收藏⭐ 留言!!!
在之前的文章中,已经系统介绍了算术运算符,想了解这部分知识的朋友可以翻看之前的内容。本篇开始介绍赋值运算符,从基本语法开始,说明几种赋值运算符的符号及其作用和用法并给出便于理解的示例代码和完整的分析。然后针对赋值运算符,给出几道具有代表性的习题(如复合赋值操作符的使用),也附带较为详细的分析和讲解。
符号:=
连续赋值
。扩展赋值运算符: +=、 -=、*=、 /=、%=
赋值运算符 | 符号解释 |
---|---|
+= |
将符号左边的值 和右边的值 进行相加 操作,最后将结果赋值给左边的变量 |
-= |
将符号左边的值 和右边的值 进行相减 操作,最后将结果赋值给左边的变量 |
*= |
将符号左边的值 和右边的值 进行相乘 操作,最后将结果赋值给左边的变量 |
/= |
将符号左边的值 和右边的值 进行相除 操作,最后将结果赋值给左边的变量 |
%= |
将符号左边的值 和右边的值 进行取余 操作,最后将结果赋值给左边的变量 |
大家在练习时,可以使用注释,合理地选择自己要打印练习的部分。
/*
测试运算符的使用2:赋值运算符
1. = +=、 -=、*=、 /=、%=
2. 说明:
① 当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制类型转换原则进行处理。
② 支持连续赋值。
③ +=、 -=、*=、 /=、%= 操作,不会改变变量本身的数据类型。
*/
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);
}
}
注:该部分对上面代码进行整体的解释,代码为基础示例,有疑问的同学(初学者)可以看这里的解释。
上述代码是一个Java类的示例,主要包含了一些变量赋值和运算操作。我来逐行解释每一部分的含义:
定义了一个名为SetValueTest1
的公共类(public class SetValueTest1)。
在main
方法中,我们开始定义了一些变量并进行赋值和类型转换的操作。
首先,定义了一个整型变量i1
并赋值为10。
紧接着,定义了一个长整型变量l1
,并将i1
的值赋给了l1
。这是一种自动类型转换,因为long
类型可以容纳int
类型的值。这样的转换不会导致数据丢失。
下一行代码是一个强制类型转换的示例,将i1
强制转换为byte
类型,并将结果赋给了bb1
变量。注意,由于byte
类型只能表示-128到127的范围,这种转换可能导致数据丢失。
接下来,将i1
的值赋给了另一个整型变量i2
,这是一种常见的赋值操作。
代码中的注释部分介绍了连续赋值的写法。以前的写法是分别给变量a1
和b1
赋相同的值。而连续赋值的写法是先定义变量a2
和b2
,然后连续赋相同的值给它们。
另外一个示例展示了在变量定义的同时进行赋值的连续赋值写法。这样可以在一行代码中定义和初始化多个变量。
代码中的注释提供了一些关于+=
操作符的说明。a += b
等同于a = a + b
,即将b
的值加到a
上,并将结果赋给a
。类似的运算符有-=
,*=
,/=
,%=
等。
定义了一个整型变量m1
并赋值为10,然后执行了m1 += 5
操作,相当于将5加到m1
上。
下面是一个关于类型转换的练习。首先定义了一个short
类型变量s1
并赋值为10,然后执行s1 += 2
操作。由于+=
操作将得到一个int
类型的结果,因此JVM会自动进行一步强制类型转换,将int
类型的结果转换成short
类型。最后输出结果为12。
代码中的注释提供了另一种实现变量增加的方式,即使用++
运算符。num1++
表示将num1
的值增加1。类似的还有--
运算符,表示将变量的值减1。
最后三行代码展示了另外两种实现变量增加的写法:num2 += 1
和num3 = num3 + 1
。这些写法与num1++
的效果是一样的,都将变量的值增加1。
请看下述代码:
short s = 3;
s = s+2; //① 编译报错
s += 2; //② 正常执行
请问:①和②有什么区别?
解析:
在下述代码中:
① s = s + 2;
这行代码会导致编译报错。
② s += 2;
这行代码可以正常执行。
这两行代码之间的区别在于赋值操作符的不同。让我们逐行解释:
① s = s + 2;
这行代码 尝试将2
加到变量s
上,并将结果赋给s
。然而,由于+
操作符会返回一个int
类型的结果,而s
是一个short
类型的变量,因此在将int
类型的结果赋给short
类型的变量时可能会导致数据丢失。编译器会报错,提醒我们可能发生这种情况。为了解决这个问题,我们需要显式地将结果强制转换为short
类型:s = (short)(s + 2);
② s += 2;
这行代码使用了复合赋值操作符+=
,它首先将2
添加到short
类型的变量s
上,然后将结果赋给s
。由于复合赋值操作符在处理类型转换时更加智能,它会自动进行合适的类型转换。在这种情况下,编译器会自动将int
类型的结果转换为short
类型,并将其赋值给s
。因此,这行代码可以正常执行而不会引发编译错误。
也就是说,区别在于
+
操作符返回的结果类型不同,+=
操作符会自动处理类型转换,因此可以安全地将结果赋给short
类型的变量。
下述代码的输出结果是什么?
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1
对于上述代码,输出结果是:
0
1
这是因为代码中的操作按顺序执行,我们来逐行解释下:
首先,定义一个整型变量i
并赋值为1。
然后,执行 i *= 0.1;
操作,它将i
乘以0.1并将结果赋给i
。由于乘法操作符返回的是double
类型的值,而i
是一个整型变量,因此0.1
会被截断为0,并将结果赋给i
。所以,i
的值变成了0。
接下来,执行 i++;
操作,它将i
的值增加1。由于此时i
的值是0,所以i++
将i
的值变为1。
最后,分别使用 System.out.println(i);
输出了i
的值。第一次输出为0,第二次输出为1。
因此,代码执行后的输出结果是 0 和 1。
下述代码的输出结果什么?
int m = 2;
int n = 3;
n *= m++; //n = n * m++;
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6
对于下述代码,输出的结果是:
m=3
n=6
我们来逐行解释代码的执行过程:
首先,定义两个整型变量 m
和 n
,并分别赋值为 2 和 3。
执行 n *= m++;
操作,这是一个复合赋值操作符。在这个操作中,n
乘以 m
并将结果赋给 n
,同时将 m
的值增加 1。由于后缀递增运算符 ++
的特性,m++
返回的是 m
的原值,然后再将 m
的值增加 1。因此,此行代码相当于 n = n * m;
,即 n
的值乘以 m
的值,并将结果赋给 n
。此时 n
的值为 6。
接下来,使用 System.out.println("m=" + m);
输出变量 m
的值,并在结果字符串中添加了一些文本。由于 m
在前面的操作中被递增了一次,所以此时 m
的值为 3。因此输出为 m=3
。
最后,使用 System.out.println("n=" + n);
输出变量 n
的值,并在结果字符串中添加了一些文本。根据前面的操作,n
的值为 6,因此输出为 n=6
。
因此,代码执行后的输出结果为
m=3
和n=6
。
下述代码的输出结果是什么?
int n = 10;
n += (n++) + (++n); //n = n + (n++) + (++n)
System.out.println(n);//32
对于下述代码,输出的结果是:
32
我们来逐行解释代码的执行过程:
首先,定义一个整型变量 n
并赋值为 10。
执行 n += (n++) + (++n);
操作,这是一个复合赋值操作符。在这个操作中,计算的顺序如下:
n++
是一个后缀递增运算符,它返回 n
的原值,然后再将 n
的值增加 1。所以,在计算 (n++)
时,n
的原值为 10,并将 n
的值增加 1,此时 n
的值为 11。 (n++先使用n,然后 n自加1)
++n
是一个前缀递增运算符,它将 n
的值增加 1,并返回增加后的值。所以,在计算 (++n)
时,n
的值为 12。
(n++) + (++n)
将 (n++)
和 (++n)
的结果相加,即 10 + 12,等于 22。
最后,将 n
的值(n最开始的值)与 22 相加,并将结果赋给 n
。此时 n
原本的值为 10,加上 22 的结果是 32,所以 n
的值被更新为 32。
使用 System.out.println(n);
输出变量 n
的值。根据前面的操作,n
的值为 32,因此输出为 32
。
因此,代码执行后的输出结果为
32
。
这里给出另外一种解释,本意与上述解释是一样的:首先,我们需要了解在 Java 中,后缀运算符(如 ++n)会比前置运算符(如 n++)具有更高的优先级。然而,在执行 n++ 时,它会首先返回 n 的当前值(即 n 的原始值),然后再将 n 的值加 1。而 ++n 则会直接返回 n 的新值。
,表达式 (n++) + (++n) 会首先将 n 的值增加 2,然后将其与 n 的原始值相加,结果为 22。
接下来,将这个结果与 n 本身相加,得到 32。
所以,最终的输出结果为 32。
这类问题有许多种解决方法,这里给出一种方案。
/**
* @author CSDN@追光者♂
* @create 2023年7月17日
*/
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;
}
}
热门专栏推荐:
持续创作优质好文ing…✍✍✍
记得一键三连哦!!!
求关注!求点赞!求个收藏啦!