新手小白逆袭大神之路04----带你学好Java

一、逻辑运算符

&与 &&短路与

|或 ||短路或

^异或

!非

public class Test{
 public static void main(String[] args){
     //&与：前后两侧皆boolean值，两者都为true，结果才为true
     System.out.println(true&true);//true
     System.out.println(false&true);//false
     System.out.println(true&false);//false
     System.out.println(false&false);//false
     
     //&&短路与：一假全假
     System.out.println(true&&true);//true
     System.out.println(false&&true);//false
     System.out.println(true&&false);//false
     System.out.println(false&&false);//false
     
     //&与：两者都为true，结果才为true；即使前者为false，还会判断后者
     //&&短路与：一假全假，判断前者为false后，不会再判断后者，效率更高
     //ArithmeticException---算数异常
     System.out.println(false&&10/0>5);//false
     
     //|或：前后两侧皆boolean值，一真即真
     System.out.println(true|true);//true
     System.out.println(true|false);//true
     System.out.println(false|true);//true
     System.out.println(false|false);//false
     
     //|或：判断完前者为true后，还会判断后者
     //||短路或：判断前者为true后 ，不会判断后者
     System.out.println(true|10/0>5);//ArithmeticException
     System.out.println(true||10/0>5);//true
     
     //^异或:前后两侧皆boolean值，两者不同 为true，两者相同 为false
     System.out.println(true^true);//false
     System.out.println(true^false);//true
     System.out.println(false^true); //true
     System.out.println(false^false);//false
     
     //!非:置反
     boolean bool1=true;
     System.out.println(!bool1);//false
     boolean bool2=false;
     System.out.println(!bool2);//true

  }
}

注意：

1. 逻辑运算符、关系运算符 运行结果都是boolean类型

2. &、&&、|、||、^两侧都是boolean类型

3. !为非，就是置反，true变false,false变true

二、字符串拼接

       //+：当+两侧都是数值时，此符号是算术运算符
        //+两侧有一侧是数值或字符串时，此符号是字符串拼接符
        System.out.println(1+2+"abcd"+"def"+3+4);//3abcddef34

三、三元运算符

1、语法规则

变量=（表达式）？值1：值2；

理解：

表达式的值为true时，执行值1；表达式的值为false时，执行值2；

public class Test{
    public static void main(String[] args){
		//需求一：输入两个数字，判断最大值
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数字");
        int a= sc.nextInt();
        System.out.println("请输入第二个数字");
        int b= sc.nextInt();

        //判断数字，输出最大值
        int max=(a>b)?a:b;
        System.out.println("最大的数是："+max);
        
        
      }
}

package com.qf.mgr;

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        int a=sc.nextInt();
        System.out.println("请输入第二个数字：");
        int b=sc.nextInt();
        System.out.println("请输入第三个数字：");
        int c= sc.nextInt();
        int min=(a<b)?a:b;
        min=(min<c)?min:c;
        System.out.println("最小的是:"+min);
    }
}

package com.qf.mgr;
//在控制台输入三个数，由小到大输出
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        int a=sc.nextInt();
        System.out.println("请输入第二个数字：");
        int b=sc.nextInt();
        System.out.println("请输入第三个数字：");
        int c= sc.nextInt();

        int max=(a>b)?a:b;
        max=(max>c)?max:c;

        int min=(a<b)?a:b;
        min=(min<c)?min:c;

        int mid=a+b+c-max-min;
        System.out.println("由小到大的顺序是:"+min+"<"+mid+"<"+max);
    }
}

//经典题：
package com.qf.mgr;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int e=5;
        System.out.println((e<5)?10.9:9);//9.0  因为10.9是double类型，9是int类型，向高看齐，所以是9.0
        
        
        char x='x';
        int i=10;
        System.out.println((false?i:x));//120
        
        char x='x';
        System.out.println((false?100:x));//x
        System.out.println((false?100000:x));//120
    }
}

注意:

常量：

程序执行过程中不能发生改变的量 数字字面量就是常量的一种

三目运算符的返回规则：

1. 值1和值2都是常量的情况下，按照取值范围大的类型返回数据

2. 值1和值2都是变量的情况下，按照取值范围大的类型返回数据

3. 值1和值2一个是常量一个是变量的情况下，判断常量是否在变量所属的取值范围内，在 按变量的类型返回数据 不在，按常量的取值范围返回数据

四、位运算符

1、理解：将十进制的数转换为二进制在做运算

符号：&与 |或 ^ 异或 <<左移 >>右移 >>>无符号位右移

package com.qf.mgr;
public class Test {
    public static void main(String[] args) {
        //&同位比较  两者都为1，结果才为1
        byte b1=23;//0001 0111
        byte b2=27;//0001 1011
        byte result=(byte)(b1&b2);
        System.out.println(result);//0001 0011---->19
        
        // |同位比较  两者一个为1，结果就为1
        byte b1=23;//0001 0111
        byte b2=27;//0001 1011
        byte result=(byte)(b1|b2);
        System.out.println(result);//0001 1111---->31
        
        // ^同位比较  两者相同为0，不同为1
        byte b1=23;//0001 0111
        byte b2=27;//0001 1011
        byte result=(byte)(b1^b2);
        System.out.println(result);//0000 1100---->12
        
        
        //<< 左移  整体向左移动n位，就用n个0补位（补到最低位）
        int num=128;//0000 0000 0000 0000 0000 0000 1000 0000
                  //0000  0000  0000  0000  0000  0010  0000   0000
        System.out.println(num<<2);//512
        
        //>> 右移 整体向右移动n位，就用n个0补位（补到最高位）
        int num=128;//0000 0000 0000 0000 0000 0000 1000 0000
                    //0000   0000  0000  0000  0000  0000  0010 0000
        System.out.println(num>>2);//32
        
        //>>> 无符号位右移  体向右移动n位，就用n个0补位（补到最高位）
    }
}

注意：

1. & | ^ 前后两侧都是数值，此符号为位运算符

2. & | ^ 前后两侧都是boolean值，此符号为逻辑运算符

3. 左移1位，相当于乘2

4. 右移1位，相当于除以2

2、运算符的优先级别

()>!>算术运算符>关系运算符>逻辑运算符>赋值运算符