第二章基本语法_运算符
运算符
分类
- 算数运算符
- 赋值运算符
- 比较运算符（关系运算符）
- 逻辑运算符
- 位运算符
- 三元运算符
算数运算符
- +正号
- -负号
- +加
- -减
- *乘
- /初
- % 取模
- ++ 自增：前++，先自增1，在运算，自增操作不会改变原本的数据类型。
- ++ 自增：后++，先运算，后自增1，自增操作不会改变原本的数据类型。
- -- 自减：前--，先自减1，在运算，自减操作不会改变原本的数据类型。
- -- 自减：后--，先运算，在自减1，自减操作不会改变原本的数据类型。
- +连接符
public class AriTest{
public static void main(String[] args){
//正、负、加、减、乘，不需要操作
//除
int a = 12;
int b = 5;
int result = a / b ;
System.out.println(result);//2
double result2 = a/b;
System.out.println(result2);//2.0
double result3 = a/(b+0.0);
System.out.println(result3);//2.4
double result4 = (double)a/b;
System.out.println(result4);//2.4
double result5 = (double)(a/b);
System.out.println(result5);//2.0
System.out.println("```````````````````````````````");
//取余
int m1 = 12;
int m2 = 5;
System.out.println(m1 % m2);//2
int m11 = -12;
int m22 = 5;
System.out.println(m11 % m22);//-2
int m111 = 12;
int m222 = -5;
System.out.println(m111 % m222);//2
int m1111 = -12;
int m2222 = -5;
System.out.println(m1111 % m2222);//-2
//总结，结果的符号与被模数的符号相同
//前++
int q1 = 10;
int q2 = ++q1;
System.out.println("q1 = " + q1 + ",q2 = " + q2);// 11 11
//后++
int h1 = 10;
int h2 = h1++;
System.out.println("h1 = " + h1 + ",h2 = " + h2);// 11 10
//注意点：
short s1 = 10;
//s1 = s1 + 1;编译错误，不符合自动提升规则
s1 = (short)(s1 +1);
s1++;//正确，自增操作不会改变原本的数据类型。
//小的问题
byte b1 = 127;
b1++;
System.out.println(b1);//等于-128，原因是二进制截取后八位
//--同理
}
}
练习
练习：随意给一个整数，打印显示个位数、十位数、百位数
public class AriExer{
public static void main(String[] args){
int data = 267;
int i0 = data%10;
int i1 = data %100 /10;
int i2 = data / 100;
System.out.println("个位数："+i0);
System.out.println("十位数："+i1);
System.out.println("百位数："+i2);
}
}
赋值运算符
符号：=
扩展符号：+=、-=、*=、/=、%=
扩展符号不会改变变量本身的数据类型。
public class SetValues{
public static void main(String[] args){
//赋值运算
int i = 10;
//连续赋值
int i1 = 1;
int i2 = 2;
i1 = i2 = 10;
System.out.println(i1);
System.out.println(i2);
//另类写法
int a = 10, b = 20;
//+=
int ss = 10;
ss += 20;
System.out.println(ss);
//注意：
short sah = 20;
sah += 2;//发现可以编译通过，所以说扩展符号不会改变变量本身的数据类型
System.out.println(sah);
byte b1 = 127;
b1 += 1;
System.out.println(b1);// -128
}
}
比较运算符
| 运算符 | 运算 |
|---|---|
| == | 相等于 |
| != | 不等于 |
| < | 小于 |
| > | 大于 |
| <= | 小于等于 |
| >= | 大于等于 |
| instanceof | 检查是否是类的对象 |
结果都是boolean类型
public class CompareTest{
public static void main(String[] args){
int i = 10;
int j = 20;
System.out.println(i == j);//false
System.out.println(i = j);//20
boolean b1 = true;
boolean b2 = false;
System.out.println(b1 == b2);
System.out.println(b1 = b2);
}
}
逻辑运算符
| 运算符号 | 示意 | 运算符号 | 示意 |
|---|---|---|---|
| & | 逻辑与 | && | 短路与 |
| 丨 | 逻辑或 | 丨丨 | 短路或 |
| ! | 逻辑非 | ^ | 逻辑异或 |
只能适用于boolean类型的变量
结论：
- 逻辑与，只要有一个false，就是false。
- 逻辑或，只要有一个true，就是true。
- 逻辑非：取反
- 异或：两个值不一样true，一个样就是false
public class LogicTest{
public static void main(String[] args){
//逻辑与 & &&
/**
相同点1：& &&运行结果都是相同的。
相同点2：运算符左边都是true时，都会执行右边的内容。
不同点：运算符左边是false是，&会执行右边，&&不会执行右边。
推荐使用&&
**/
int m1 = 10;
boolean b1 = false;
if(b1 & (m1++ >0)){
System.out.println("我在济南");
}else{
System.out.println("我在杭州");
}
System.out.println("m1 = " + m1);//11
int m2 = 10;
boolean b2 = false;
if(b2 && (m2++ >0)){
System.out.println("我在济南");
}else{
System.out.println("我在杭州");
}
System.out.println("m2 = " + m2);//10
//逻辑或 | ||
/**
相同点1：| ||运算结果是相同的。
相同点2：当运算符左边是false时，右边都会执行。
不同点：当运算符左边是true是，|会执行右边，||不会执行右边。
推荐使用||
**/
int m3 = 10;
boolean b3 = true;
if(b3 | (m3++ >0)){
System.out.println("我在济南");
}else{
System.out.println("我在杭州");
}
System.out.println("m3 = " + m3);
int m4 = 10;
boolean b4 = true;
if(b4 || (m4++ >0)){
System.out.println("我在济南");
}else{
System.out.println("我在杭州");
}
System.out.println("m4 = " + m4);
}
}
位运算符（了解）
| 运算符 | 运算 | 含义 |
|---|---|---|
| << | 左移 | 空位补0，被移除的高位丢弃，空位补0 |
| >> | 右移 | 被移位的最高位是0，右移后补0；最高位是1，空位补1 |
| >>> | 无符号右移 | 被移位二进制最高位无论是1还是0，控缺位都补0 |
| & | 与运算 | 二进制位进行&运算 |
| 丨 | 或运算 | 二进制位进行|运算 |
| ^ | 异或运算 | 二进制位进行^运算 |
| ~ | 取反运算 | 二进制位进行取反运算 |
结论：
- 位运算符操作的都是整形的数据
- << ：在一定范围内，每向左移动一位，相当与 * 2；
- >> : 在一定范围内，每向右移动一位，相当与 / 2；
public class BitTest{
public static void main(String[] args){
System.out.println("21<<2："+(21<<2));//84
System.out.println("21<<3："+(21<<3));//168
System.out.println("21<<26："+(21<<26));
System.out.println("21<<27："+(21<<27));//负的
}
}
- 面试题：高效的计算2 * 8；2<<3或8<<1
练习
交换两个变量的值
int n = 10;
int m = 20;
/*
位运算符题目
*/
public class BitExer{
public static void main(String[] args){
int n = 10;
int m = 20;
System.out.println("n = " + n + "，m = " + m);
//方式1，临时存储
//推荐使用方法一
int temp = n;
n = m;
m = temp;
System.out.println("n = " + n + "，m = " + m);
//方式二，弊端：可能两数相加超出int值范围，局限性：只能用于数值类型
n = n + m;
m = n - m;
n = n - m;
System.out.println("n = " + n + "，m = " + m);
//方式三，位运算符
n = n ^ m;
m = n ^ m;
n = n ^ m;
System.out.println("n = " + n + "，m = " + m);
}
}
三元运算符
- 格式：(条件表达式)？表达式1:表达式2
- 条件表达式为true：执行表达式1
- 条件表达式为false：执行表达式2
- 条件表达式的结果要是boolean类型；
- 表达式1和表达式2必须是一样的类型。
- 三元运算符可以嵌套使用
public class SanYuanTest{
public static void main(String[] args){
String a = 5<2?"1":"2";
System.out.println(a);
}
}
- 凡是可以使用三元运算符的地方，都可以改写成if-else；反之不成立。
如果程序既可以使用三元运算符，又可以使用if-else，那么优先选择三元运算符，简介、执行高效。
运算符的优先级
先运算的加小括号（）
DAY03问题
- & 和 && 的异同点。
- 相同点1：程序输出的结果都是一样的。
- 相同点2：当表达式左边结果都是true时，表达式右边都会执行。
- 不同点：当表达式左边的结果都是false时，&的右边会执行，&&的右边不会执行。
-
程序输出。
-
定义三个int类型变量并赋值，使用三元运算符或者if-else获取这个三个数中的较大数的实现。
public class LxTest{
public static void main(String[] args){
int n = 10;
int m = 19;
int s = 12;
int max = (n>m)?((n>s)?n:s):((m>s)?m:s);
System.out.println("较大的数为："+ max);
}
}
- 编写程序，声明2个double行变量并赋值，判断第一个数大于10.0，且第二个数小于20.0，打印两数之和。否则打印两数的乘积。
public class LxTest2{
public static void main(String[] args){
double d1 = 5.3;
double d2 = 10.3;
if(d1>10.0 && d2 < 20.0){
System.out.println("两数之和："+(d1 + d2));
}else{
System.out.println("两数之积："+(d1 * d2));
}
}
}
- 交换两个值的代码的实现
public class LxTest3{
public static void main(String[] args){
int a = 10;
int b = 20;
//方式1
int temp = a;
a = b;
b = temp;
System.out.println("a="+a+",b="+b);
//方式2
a = a + b;
b = a - b;
a = a - b;
System.out.println("a="+a+",b="+b);
//方式3
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a="+a+",b="+b);
}
}
本文由 Gorrywang 创作，严禁转载与复制！
最后编辑时间为: Jul 25,2020