java中if分支语句_Java运算符-if分支语句

运算符

// 除号：/

int num1 = 12;

int num2 = 5;

int result1 = num1 / num2;

System.out.println(result1); //2

double result2 = num1 / num2;

System.out.println(result2); //2.0

double result3 = num1 / num2 + 0.0;

System.out.println(result3); //2.0

double result4 = num1 / (num2+0.0);

System.out.println(result4); //2.4

double result5 = (double)num1 / num2;

System.out.println(result5); //2.4

// 取模(取余)：%

// 结果的符号与被模数的符号相同(m % n 中的m就是被模数)

int m1 = 12;

int n1 = 5;

System.out.println("m1 % n1 = " + m1 % n1);

int m2 = -12;

int n2 = 5;

System.out.println("m2 % n2 = " + m2 % n2);

int m3 = 12;

int n3 = -5;

System.out.println("m3 % n3 = " + m3 % n3);

int m4 = -12;

int n4 = -5;

System.out.println("m4 % n4 = " + m4 % n4);

/* 结果

m1 % n1 = 2

m2 % n2 = -2

m3 % n3 = 2

m4 % n4 = -2

*/

// 负负得正

int num1 = -1;

System.out.println(-num1); //1

自增自减补充

++：对于自增变量本身来说，都会+1

​但是++在前还是在后，对于整个表达式的计算来说是不一样的。

​++在前，先自增，然后取自增后的变量值。

​++在后，先取变量的值，然后变量自增。

public static void main(String[] args) {

int m = 1;

int n = ++m;

System.out.println(m);//2

System.out.println(n);//2

//m先自增，然后把m的值取出来赋值给n

System.out.println("-----------");

int a = 1;

int b = a++;

System.out.println(a);//2

System.out.println(b);//1

//(1)先取出a的值“1”，先放到一个“操作数栈”(2)然后a变量完成自增(3)把刚才放在“操作数栈中的值赋值给b”

System.out.println("-----------");

int z = 1;

z = z++;

System.out.println(z);//1

//(1)先取出z的值“1”，先放到一个“操作数栈”(2)然后z自增，变为2(3)把刚才放在“操作数栈”中的值赋值给z

}

小坑(注意点)

自增1不会改变本身变量的数据类型

short s1 = 10;

// s1 = s1 + 1; // 报错 编译失败

s1 += 1 // 不会改变变量本身的数据类型

// 因为1是int类型，short和int运算之后是int类型，但是你赋给的s1还是short类型

s1 = (short)(s1 + 1); // 这样等他们运算完了吧他强转成short类型就好了

s1++; // 这样也可以，自增1不会改变本身变量的数据类型

System.out.println(s1);

//---------------------------

byte b1 = 127;

b1++;

System.out.println(b1); // -128

// 127的二进制是 0111 1111 加1之后二进制变成 1000 0000 就是-128

逻辑运算符

逻辑运算符操作的都是布尔类型的变量

&:逻辑与对应python中的 and

|:逻辑或对应python中的 or

^:逻辑非对应python中的 not

&& -- || -- 的意思也是与和或，只不过这样写是 遵循 短路原则

^:逻辑异或这个的意思就是 异 不同的

例子：如果a和b 同为true或false 那么 a^b 就是false

如果a和b 一个是true一个是false 那么a^b 就是true

(异嘛，就是a和b不同时为true)

位运算符

位运算符操作的都是整型的数据

左移：<<

运算规则：<

System.out.println(4 << 3);//等于4乘以2的3次方，结果是32

//0000 0100这个二进制表示的是4

//左移三位是0010 0000，这个二进制表示的是32

右移：>>

运算规则：>>几位，就是除以2的几次方

System.out.println(32 >> 4);//等于32除以2的4次方，结果是2

//0010 0000右移4位就是0000 0010等于2

System.out.println(-32 >> 4);//-2

/*

-32的二进制：

原码1010 0000

反码1101 1111

补码1110 0000

右移四位是 1111 1110(负数前面补1)(符号位是1就补1，符号位是0就补0)

补码1111 1110

反码1111 1101

原码1000 0010(到这就是完事了是-2)

*/

无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0，不看符号位(不管符号位是1还是0，都补0)

按为与：&

二进制位进行 & 运算，只有1&1时的结果是1，否则是0

按位或：|

二进制位进行 | 运算，只有0|0时结果是0，否则是1

按位异或：^

相同二进制位进行^运算，结果是0： 1^1=0 0^0=0

不同二进制位^运算，结果是1： 1^0=1 0^1=1

按位取反：~

正数取反，各二进制码按补码 各位取反

负数取反，各二进制码按补码 各位取反

练习题：写出2 * 8最高效的实现方式。答：2 << 3 或 8 << 1

三元运算符

int max = x > y ? x:y; // 这是三元运算符

System.out.println(max);

/*等价于

if(x > y) {

max = x;

}else {

max = y;

}

*/

交换两个变量的值

通用的方案：使用与任意的数据类型

​借助于第三个同样类型的临时变量

int x = 1;

int y = 2;

int temp = x;

x = y;

y = temp;

System.out.println(x);

System.out.println(y);

方法二：(只适用于int等整数类型)

int x = 1;

int y = 2;

x = x ^ y;

y = x ^ y;

x = x ^ y;

System.out.println(x);

System.out.println(y);

方法三：(只适用于int等整数类型)

有风险，可能会溢出，有局限性，只能用于数值类型

x = x + y;

y = x - y;//(新的x)-原来的y=(原来的x + 原来的y) - 原来的y = 原来的x

x = x - y;//(新的x) -新的y = (原来的x + 原来的y)-原来的x =原来的y

分支结构

条件判断：if..else(if()表达式结果必须是boolean的结果)

条件判断

语法格式

if(条件表达式){

当该条件表达式成立时，需要执行的语句;

}else{

当该条件表达式不成立时，执行的语句;

}

if(条件表达式){

当该条件表达式成立时，需要执行的语句;

}

if(条件表达式){

当该条件表达式成立时，需要执行的语句;

}else if(条件表达式2){

}else if(条件表达式3){

}else{

}

java.util.Scanner input = new java.util.Scanner(System.in);

System.out.print("请输入你的分数：");

double Fraction = input.nextDouble();

if(Fraction >= 90){

System.out.println("A");

}else if(Fraction >= 80){

System.out.println("B");

}else if(Fraction >= 70){

System.out.println("C");

}else if(Fraction >= 60){

System.out.println("D");

}else{

System.out.println("不合格");

}