• Which operator takes precedence in 4 > 5 or 3 < 4 and 9 > 8? Would this be evaluated to true or false?I know that the statement 3 > 4 or (2 < 3 and 9 > 10) should obviously evaluate ...
Which operator takes precedence in 4 > 5 or 3 < 4 and 9 > 8? Would this be evaluated to true or false?I know that the statement 3 > 4 or (2 < 3 and 9 > 10) should obviously evaluate to false but I am not quite sure how python would read 4 > 5 or 3 < 4 and 9 > 8解决方案Comparisons are executed before and, which in turn comes before or. You can look up the precedence of each operator in the expressions documentation.So your expression is parsed as:(4 > 5) or ((3 < 4) and (9 > 8))Which comes down to:False or (True and True)which is True.
展开全文
• 逻辑运算符4.扩展赋值运算符5.条件运算符6.位运算符7.运算符优先级8.控制台输入9.流程控制语句分类9.1分类9.2 流程图10.分支结构语句10.1 单分支10.2 双分支11.编程：1.两个数字比较大小 2.三个数字求最大数12.编程...
文章目录1.算术运算符2.关系运算符3.逻辑运算符4.扩展赋值运算符5.条件运算符6.位运算符7.运算符优先级8.控制台输入9.流程控制语句分类9.1分类9.2 流程图10.分支结构语句10.1 单分支10.2 双分支11.编程：1.两个数字比较大小 2.三个数字求最大数12.编程：三种方法实现，两个变量互换。13.编程：1.输入两个数字，计算加减乘除 2.输入一个数字，判断奇偶14.编程：1.判断闰年 2.有4位学号筛选出百位是6的 3.判断是否为3位数15.注意：
1.算术运算符
自增自减运算符

代码分析一：
一元运算符
运算规则：
++        ：  n ++  ->  n = n + 1;
–           :     n –  ->   n = n - 1;
总结:
后缀:  赋值运算或输出语句中，先赋值运算或输出，后自增或自减；
前缀：  赋值运算或输出语句中，先自增或自减， 后赋值运算或输出。
            int n = 5;
n ++; n = n + 1;
-- n ;  n = n - 1;
System.out.println(n);//5
//---------------------------------
int n = 5;
int m = n ++;  m = n; m = 5; n = n + 1; n = 5 + 1;
System .out.println(n + "," + m);// 6,5
System .out.println(n ++);//5 先输出，再自增
System .out.println(n);//6
//-------------------------------------
int n = 5;
int m = ++ n; n = n + 1; n = 5 + 1; m = 6;
System .out.println(n + "," + m);//6,6
System .out.println(++ n); n = n + 1; n = 5 + 1;  6

2.关系运算符
运算的结果：boolean 类型  ：true  成立 ，false 不成立的。

   		int n1 = 5;
int n2 = 6;
System .out.println(n1 > n2);//false
System .out.println(n1 == n2);// false
System .out.println(n1 < n2); // true
System .out.println(n1 <= n2);// true

3.逻辑运算符

&& ：与
|| :或
！ ：非

运算规则： && ：一假 （false) ,为 假(false);
|| : 一真（true),为 真(true);
!  :取反
 		System .out.println(true && false);  // false
boolean n1 = true;
boolean n2 = true;
System .out.println(n1 && n2);// true
false && false  -> false
System .out.println( (5 > 6) && (7 == 8));
System .out.println(!((5 > 6) && (7 == 8)));//!false -> true

&& ，|| 和 & ，|区别：
&& ，|| ：短路与，短路或；
&  ， | ：（位运算符），非短路与 ，非短路或
        int n = 5;
boolean r = false && ++ n > 6 && false && true;
System .out.println(r);//false
System .out.println(n);// 5
//---------------------------------------------
int n = 5;
boolean r = false & ++ n > 6 & false & true;
System .out.println(r);//false
System .out.println(n);// 6

4.扩展赋值运算符

代码分析二：
运算规则： a += 5;  ->  a = a + 5;
  int n = 5;
n += 5; n = n + 5；n = 5 + 5; n = 10;
System.out.println(n);// 10

注意：扩展赋值运算符 可以 自动的隐式的 强制转换，会更安全。
    short n3 = 5;
int  ->short
int
int + int
short + int
n3 = n3 + 5;//出错：方式(short)
System .out.println(n3);
----------------------------

short n3 = 5;
//   自动的隐式 强转
n3 += 5; n3 =(short) (n3 + 5)
System .out.println(n3);

5.条件运算符

？：  三元。
运算规则: 表达式 一 必须是boolean类型
当 表达式一 运算的结果 是true ,那么取 表达式二的值；
false,那么取表达式三的值。
  //            false
String str = 5 < 3 ? "5大于3" : "5不大于3";
System .out.println(str);

6.位运算符

& ： 与
规则： 两个 运算的位 都为 1 ，结果才能 为  1， 一个为0 ，结果就为0.
| : 或
规则： 两个运算的位 只要 有一个 为  1，结果就为 1.
^ :异或
规则： 两个运算的位  相同 为 0 ，不同为1
0 ， 0     1， 1  相同
0 ，1    1， 0  不同
~ :取反，非
1  取反 是 0 ， 0 取反 是 1
<< :左移
规则：向左 移动 n 位  ，右边 低位  用 0 补位。
重点规律:正数 ，移出去的都是0 ，那么 相等于 这个数 乘以  2的移动位数次方。num * 2 ^n
右移:>>
规则： 向右 移动 n  位 ，左边 高位 是什么用什么补位 ，是0用0补位，
是  1  用  1 补位。
规律： 相当于   这个数 除以  2的移动位数次方。 num / 2 ^n
无符号右移:>>>***
规则:  向右 移动 n  位 ，左边 高位 用 0 补位。
EG：
+5
-5
原码：
+ 5： 00000000-00000000-00000000-00000101
-5：  10000000-00000000-00000000-00000101
反码：
+5 ： 00000000-00000000-00000000-00000101
- 5：   11111111-11111111-11111111-11111010
补码：
+5：00000000-00000000-00000000-00000101
-5：  11111111-11111111-11111111-11111011 原码取反+1

  		System.out.println(5 & 2);\\0
System .out.println(5 | 2);\\7
System .out.println(5 ^ 2);\\7
System .out.println(~5);\\-6
System .out.println(5 << 2);\\20
System .out.println(5 >> 2);\\1
System .out.println(5 >>> 2);\\1
System .out.println(-6 >>> 2);\\1073741822
System .out.println(Integer.valueOf("111111111111111111111111111110",2));\\1073741822

7.运算符优先级
代码分析三：

8.控制台输入
语法：
import java.util.Scanner; //import java.util.*;
Scanner input = new Scanner(System.in);
input.nextInt(); //获得整数 int
input.nextDouble();// 获得小数  double
input.next();// 获得字符串

控制台输入 代码实例：
//导入 父包名.子包名.类型；
import java.util.Scanner;
//导入 Scanner类型  1.请超人
public class Demo11 {
public static void main(String[] args) {
//  2. 创建了一个超人
//类型    对象名 = 创建  调用构造器（类.流对象）
Scanner superman = new Scanner(System.in);
System .out.print("请输入一个整数：");
// 3.    对象名.方法名()    超人 工作 ，超人获得一个 整数
int n = superman.nextInt();//11
double n = superman.nextDouble();//11.11
String n = superman.next();// n = "hello"字符
char n = superma.next().charAt(0);// n = +/*-（char类型）
System .out.println(n);

}
}


9.流程控制语句分类
9.1分类
顺序：从上而下顺序执行。
分支：根据条件不同，执行不同的语句。
循环：重复执行某些操作
9.2 流程图

10.分支结构语句
10.1 单分支
语法：

注意：
1.条件必须是 boolean数据类型
2.if只带 一行 代码 可以省略 大括号.
 Scanner superman = new Scanner(System.in);
int score;
System .out.println("输入成绩：");
score = superman.nextInt();
if (score >= 60){
System .out.println("给吃饱饭");
System .out.println("给买一瓶可乐");
}
System .out.println("其他代码");

10.2 双分支
注意：
1.else不能带条件的；
2. if,else只带 一行 代码 可以省略 大括号。
  Scanner superman = new Scanner(System.in);
int score;
System .out.println("输入成绩：");
score = superman.nextInt();
if (score >= 60)
System .out.println("给吃饱饭");
else
System .out.println("抄写代码100遍");

11.编程：1.两个数字比较大小 2.三个数字求最大数
public class Demo8_exam {
public static void main(String[] args) {
//1.两个数字比较大小----------------------------------------------
int n1 = 5;
int n2 = 5;
String str = n1 > n2 ? "n1大于n2" : n1 == n2 ? "n1等于n2":"n1小于n2";
System.out.println(str);

//2.三个数字求最大数------------------------------------------------
int num1 = 5;
int num2 = 6;
int num3 = 7;
int max = num1;
max = max < num2 ? num2 : max;
max = max < num3 ? num3 : max;
System .out.println(max);
}
}

12.编程：三种方法实现，两个变量互换。
/**
练习:
两个变量互换。
*/
public class Demo10_exam {
public static void main(String[] args) {
//1. 定义第三个变量-----定义法------------------------------
int a = 5;
int b = 2;
int temp ;
temp = a;
a = b;
b = temp;
System.out.println( a + "," + b);
//2 .算术方法-----------------------------------------------
int a = 5;
int b = 2;
a = a + b;// 5 + 2
b = a - b;// 5 + 2 - 2 -》 5
a = a - b;// 5 + 2 - 5 -》2
System .out.println(a + "," + b);

//3 .位方法----------------------------------------------------
int a = 5;
int b = 2;
a = a ^ b;// a = a ^ b
b = a ^ b;// b = a ^ b ^ b;  b ->  a
a = a ^ b;// a = a ^ b ^ a;  a ->  b
System .out.println(a + "," + b);
}
}

13.编程：1.输入两个数字，计算加减乘除 2.输入一个数字，判断奇偶
/**
练习：
控制台输入
*/
import java.util.Scanner;
public class Demo13_exam{
public static void main(String[] args) {
//1.输入两个数字，计算加减乘除的结果--------------------------------
Scanner superman = new Scanner(System.in);
int n1,n2;
System .out.println("--输入数字1：");
n1 = superman.nextInt();
System .out.println("--输入数字2：");
n2 = superman.nextInt();
System .out.println(n1 + "+" + n2 + "=" + (n1 + n2));
System .out.println(n1 + "-" + n2 + "=" + (n1 - n2));
System .out.println(n1 + "*" + n2 + "=" + (n1 * n2));
System .out.println(n1 + "/" + n2 + "=" + (n1 / n2));
//2.输入一个数字，判断奇数和偶数.-----------------------------------
int num;
System .out.println("--输入一个数字：");
num = superman.nextInt();
String str = num % 2 == 0 ? "偶数" : "奇数";
System .out.println(str);
}
}


14.编程：1.判断闰年 2.有4位学号筛选出百位是6的 3.判断是否为3位数
import java.util.Scanner;
/**
练习：分支语句
*/
public class Demo16_exam {
public static void main(String[] args) {
Scanner superman = new Scanner(System.in);
//1.判断闰年：---------------------------------
//能被4整除但是不能被100整除，或者能被400整除
int year;
System .out.println("输入一个年：");
year = superman.nextInt();
if ((year%4 == 0 &&  year % 100 != 0) || year% 400 == 0){
System .out.println("是闰年");
}else{
System .out.println("是平年");
}
//2.百位 是6 ---------------------------------------------
int num;
System .out.println("--输入数字");
num = superman.nextInt();//1234
int n = num / 10 /10 % 10;
if (n == 6){
System .out.println("是幸运的");
}else{
System .out.println("谢谢参与");
}
//3.判断3位数 100 - 999
int number ;
System .out.println("输入数字：");
number = superman.nextInt();
if (number >= 100 && number <= 999){
System .out.println("是三位数");
}else{
System .out.println("不是");
}
}
}

15.注意：
1.短路的第一个被短路了，后面的都不需要运算了
例如好几个&&，第一个False了，则后面的都不用算的，直接输出false
||的第一个true，直接输出true，反之都运算。
2.扩展赋值运算符有着自动的隐式强转类型。
3.负数转正数，减一取反
正数转负数：取反加一
4.一个数字被另一个数字异或（^）两次，就会得到其本身
5.Import java.util .*;
这段代码表示util的所有包都导入，自然包括Scanner包
6.if，else如果只带一行代码，则可以省了｛｝


展开全文
• 1.关系运算符 返回值是boolean 一般用于判断语句中 ...2 逻辑运算符 & 逻辑与 | 逻辑或 ！ 逻辑非 &&逻辑与 ||短路或 与 运算符：所有条件都为真 结果才为真 或 运算符： 所有条件都为假 结果...
1.关系运算符

返回值是boolean 一般用于判断语句中

==   ！=   > <  >=  <=

2 逻辑运算符

& 逻辑与      | 逻辑或   ！ 逻辑非    &&逻辑与      ||短路或

与 运算符：所有条件都为真 结果才为真

或  运算符： 所有条件都为假  结果才为假

boolean b;

b=condition 1&condition 2;//首先求得1,2的值，然后进行判断

b=condition 1&condition 2；//首先对condition1进行判断，如果为真，再判断condition2,如果condition1为假，则不再对condition2进行判断

//调用该方法时返回true
public static boolean returntrue() {
System.out.println("returntrue");
return true;
}
//调用该方法时返回false
public static boolean returnfalse() {
System.out.println("returnfalse");
return false;
}
public static void main(String[] args){
boolean b1;
System.out.println("逻辑语运算returntrue()&returnfalse()");
b1=returntrue()&returnfalse();
System.out.println(b1);

System.out.println("短路与运算returntrue()&&returnfalse()");
boolean b2=returntrue()&&returnfalse();
System.out.println(b2);

System.out.println("短路与运算returnfalse()&&returntrue()");
boolean b3=returnfalse()&&returntrue();
System.out.println(b3);

System.out.println("逻辑或运算returnfalse()|returntrue()");
boolean b4=returnfalse()|returntrue();
System.out.println(b4);

System.out.println("逻辑或运算returntrue()|returnfalse()");
boolean b5=returntrue()|returnfalse();
System.out.println(b5);

3 三元运算符

int i,d ,k;
i=5;
d=10;
k=i>=d?i:d;
System.out.println(k);

4 运算符优先级

i=k++  ++为先运算 后赋值

展开全文
• 四种运算符优先级关系： 算术运算符>关系运算符>逻辑运算符>赋值运算符 一、算术运算符 public static void main(String[] args){ //除号： / int q = 12; int w = 5; double result1 = q / w;// ...
算术运算符、关系运算符、逻辑运算符、赋值运算符代码详解与优先级关系一、算术运算符二、关系运算符三、逻辑运算符四、赋值运算符

四种运算符优先级关系：

算术运算符>关系运算符>逻辑运算符>赋值运算符

一、算术运算符

代码举例：
public static void main(String[] args){
//除号： /
int q = 12;
int w = 5;
double result1 = q / w;// 2.0
double result3 = q / (w + 0.0);// 2.4
double result4 = (double)q / w;// 2.4
double result5 = (double)(q / w);// 2.0

//取余运算： %
//结果的符号与被模数的符号相同
int m1 = -12;
int n1 = 5;
System.out.println(m1 % n1);// -12
int m2 = 12;
int n2 = -5;
System.out.println(m2 % n2);// 12

//(前)++ ：先自增1，后运算
//(后)++ ：先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1= " + a1 + ",b1= " + b1);//a1= 11,b1= 11
int a2 = 10;
int b2 = a2++;
System.out.println("a2= " + a2 + ",b2= " + b2);//a2= 11,b2= 10
int a3 = 10;
a3++;
int b3 = a3;
System.out.println("b3= " + b3);//b3= 11，无论a3++还是++a3，结果单欧式11，因为没有运算，所以只自增
//注意：==================================================
short s1 = 10;
s1 = s1 + 1;//错误
s1++;//正确，自增1不会改变变量本身的数据类型
byte b4 = 127;
b4++;
System.out.println("b4 = "+b4);// b4 = -128
}

二、关系运算符

代码举例：
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 b5 = false;
//区分好==和=的区别。
if(b5=true)
System.out.println("结果为真");//输出"结果为真"
else
System.out.println("结果为假");
}

三、逻辑运算符

名称
符号
说明

逻辑与
&
两边都为true，结果才为true

逻辑或
|
只要一边为true，结果就为true

逻辑非
!
相反

逻辑异或
^
异或，追求的是“异”，两边都不同，结果才为true，否则为false

短路与
&&
两边都为true，结果才为true

短路或
||
只要一边为true，结果就为true

注意1：“&”和“&&”的区别：
&时，左边无论真假，右边都进行运算；
&&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算 。
注意2：“|”和“||”的区别：
|时，左边无论真假，右边都进行运算；
||时，如果左边为假，右边参与运算，如果左边为真，那么右边不参与运算 。

代码举例：
public static void main(String[] args){
//“&”和“&&”的区别
boolean q1 = true;
q1 = false;
int num1 = 10;
if (q1 & (num1++ > 0)){
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");//执行这条语句
}
System.out.println(num1);//输出11

boolean q2 = true;
q2 = false;
int num2 = 10;
if (q2 && (num2++ > 0)){
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");//执行这条语句
}
//“|”和“||”的区别同理

//面试题===========================================================================
boolean x=true;
boolean y=false;
short z=42;
//if(y == true)
if((z++==42)&&(y=true))z++;//z==44
if((x=false) || (++z==45)) z++;

System.out.println("z"+z);//z==46
}

四、赋值运算符

符号： =

当“=”两侧数据类型不一致时， 可以使用自动类型转换或使用强制
类型转换原则进行处理。
支持连续赋值

扩展赋值运算符： +=, -=, *=, /=, %=

注意：不会改变变量本身的数据类型
代码举例：
public static void main(String[] args){
//1)
short s = 3;
s = s + 2;//报错
s += 2;//不会改变变量本身的数据类型

//2)
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1

//3)
int m = 2;
int n = 3;
n *= m++;// n = n * (m++);
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6

//4)
int n = 10;
n += (n++) + (++n);
System.out.println(n);// 输出：32
}



展开全文
• 一、算数运算符 二、关系运算符 三、逻辑运算符 四、位运算符 五、赋值运算符 六、其他运算符 七、运算符优先级
• 运算符的优先级是学编程语言最最基础的，就像加减乘除运算一样，先乘除后加减不同类型运算符...2 这里面就有优先级的关系了，看你怎么算啦同一类型运算符之间也有优先级关系，比如逻辑去处符的优先级 NOT AND OR...
• 相关问题中国大学MOOC: 柏拉图在《理想国》中说有四门艺术“能把灵魂引导到真理”。...: 古代 希腊 七艺 教育 中 艺术 算术 天文学 文法 修辞各种运算符的执行优先级为: 算术运算符 > 字符运算符...
• JavaScript运算符算术运算符赋值运算符关系(比较)运算符逻辑运算符运算符的优先级 算术运算符 算术运算符用在数学表达式中, 它的使用方式和数学中也是一致的. 算术运算符是对数据进行计算的符号 可以直接对数据进行...
• 1.关系运算符 返回值类型：Boolean（布尔值） 符号：== != > >= 例1 package ddouble; public class ddouble { public static void main(String[] args){ int a=2; int b=3; boolean f; ...
• CSS布局HTML小编今天和大家分享c语言中关系运算符，逻辑运算符等等各种运算符的c语言运算符号 1级优先级 左结合 () 圆括号 [] 下标运算符 -> 指向结构体成员运算符 . 结构体成员运算符 2级优先级 右结合 。 逻辑...
• ++i 和 i++的区别，算术运算符、关系运算符、逻辑运算符优先级前言一、++i 和 i++的区别二、算术运算符、关系运算符、逻辑运算符优先级结果显示 前言 C语言复习： ++i 和 i++的区别 算术运算符、关系运算符、...
• 运算符优先级-C语言运算符优先级
• 运算符优先级-PHP运算符优先级
• 运算符优先级-C++运算符优先级

...