精华内容
下载资源
问答
  • 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.算术运算符

    自增自减运算符
    在这里插入图片描述
    代码分析一:
    一元运算符
    运算规则:
    ++ : 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语言运算符优先级

    千次阅读 2015-11-30 13:49:56
    运算符优先级-C语言运算符优先级
  • 运算符优先级-PHP运算符优先级
  • 运算符优先级-C++运算符优先级

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,191
精华内容 28,076
关键字:

关系运算符逻辑运算符的优先级