Java笔记day04

一、运算及运算符
1、逻辑运算符
    &,|,^,!,&&,||
    1）、特点：
        逻辑运算符两边一般是boolean类型的数据或者是表达式。
    2）、表达式：
            就是用运算符把常量和变量连接起来并且符合java语法的式子，叫表达式
                算术运算符：a + b
                关系运算符：a == b
                赋值运算符：a = b
    3）、符号的含义
            int a = 3;
            int b = 4;
            int c = 5;
        a、&逻辑与运算
            表达式两边只要有一个false，结果就是false
            只有表达式两边全部都是true,结果才为true
                System.out.println((a>c) & (a>b)); // false & false = false
                (a>b) & (a<c) // false & true = false
                (a<b) & (a>c) // true & false = false
                (a<b) & (a<c) // true & true = true
        b、|逻辑或运算
            表达式两边只要有一个true，结果就是true
            只有表达式两边全部都是false,结果才为false
                System.out.println((a>c) | (a>b)); // false | false = false
                (a>b) | (a<c)) // false | true = true
                ((a<b) | (a>c)) // true | false = true
                (a<b) | (a<c)) // true | true = true
        c、^逻辑异或运算
            表达式两边不一致时，结果是true
            表达式两边一致时，结果是false
                System.out.println((a>c) ^ (a>b)); // false ^ false = false
                (a>b) ^ (a<c)) // false ^ true = true
                (a<b) ^ (a>c)) // true ^ false = true
                (a<b) ^ (a<c)) // true ^ true = false 
        d、!逻辑非运算
            结果反转
                !(true)  //  false
                !(false) //  true
        e、&&短路与运算
            表达式左边为false，结果就是false，且不执行右边的表达式
            单纯从结果上来看，&&与&的结果是一样的
        f、||短路或运算 
            表达式左边为true，结果就是true，且不执行右边的表达式
    4）、总结：
        a、&：有false则false
        b、|：有true则true
        c、^：两边相同为false,不同为true
        d、!：将结果反转，true变成false，false变成true
        f、在Java中不可以写成3<x<6，应该写成x>3 & x<6                
2、位运算符
    &,|,^,~,<<,>>,>>>,（改运算符针对于二进制补码,该部分举例说明运算符含义）
    1）、&,|,^（3和4举例）
                3的补码：00000000 00000000 00000000 00000011
                4的补码：00000000 00000000 00000000 00000100
        &位于运算（3&4）：00000000 00000000 00000000 00000000    ==>     0
        |位或运算（3|4）：00000000 00000000 00000000 00000111    ==>     7
        ^位异或运算（3^4）：00000000 00000000 00000000 00000111    ==>     7
    2)、~位取反运算（以4为例）
            4的补码：00000000 00000000 00000000 00000011
            ~位取反：11111111 11111111 11111111 11111100（补码）
                    11111111 11111111 11111111 11111011（反码）
                    10000000 00000000 00000000 00000100（原码）
            结果为：-4
    3）、<<,>>,>>>
        a、3 << 2 == 12（左移）
            3的原码，反码，补码：00000000 0000000 0000000 00000011
                    左移两位：(00)000000 0000000 0000000 0000001100（补码）
                      结果是：12
        b、24 >> 2（右移）
            24的原码，反码，补码：00000000 00000000 00000000 00011000
                       右移两位：00000000 00000000 00000000 00000110(00)
                         结果是：6
            注：在右移时，如果最高位是1，则最高位移动后左边全用1补齐
                如果最高位是0，则最高位移动后左边全用0补齐
        c、24 >>> 2（无符号右移）
            24的原码，反码，补码：00000000 00000000 00000000 00011000
                       右移两位：00000000 00000000 00000000 00000110(00)
                        结果是：6
            注：右移时最高位全部补0
        d、右移和无符号右移
            -24 >> 2
                -24的原码：10000000 00000000 00000000 00011000
                -24的反码：11111111 11111111 11111111 11100111
                -24的补码：11111111 11111111 11111111 11101000
                                    11111111 11111111 11111111 11111010(00)
                         补码：11111111 11111111 11111111 11111010
                         反码：11111111 11111111 11111111 11111001
                         原码：10000000 00000000 00000000 00000110
                     结果为：-6
            -24 >>> 2
                -24的原码：10000000 00000000 00000000 00011000
                -24的反码：11111111 11111111 11111111 11100111
                -24的补码：11111111 11111111 11111111 11101000
                                    00111111 11111111 11111111 11111010(00)
                原码，反码，补码都一样：00111111 11111111 11111111 11111010
                结果为：1073741818 
3、三目运算符
    1）、格式
        (关系表达式)?表达式1：表达式2；
        如果条件为true，运算后的结果是表达式1；
        如果条件为false，运算后的结果是表达式2；
    2）、执行流程
        1、首先判断关系表达式中的结果，
        2、如果说判断关系表达式的结果为true,执行冒号前面的表达式1
        3、如果说判断关系表达式的结果为false，执行冒号后面的表达式2
    3）、注意事项
        1、关系表达式的小括号不能省略
        2、如果后面的表达式只是一个值或者一个变量，小括号可以省略
        3、如果后面的表达式需要进行一些运算，小括号不能省略
    4）、举例
        boolean b = (1>3)?(true):(false);   ==>     false
        
        int x = 10;
        int i = (x++ == 11)?(x++):x;        ==>     i=11,x=11

        int x1 = 13;
        double i2 = (x1++ == 12)?x1:((x1*1.0)/2);       ==>     i2=7.0,x1=14
        注：三目运算表达式的结果数据类型由表达式中最高的数据类型接收
    5)、三目运算符求最大值
        需求1：获取两个数中较大的数据
        需求2：获取三个数中较大的数
        需求3：比较两个整数是否相同
            public class OptTest1 {
            public static void main(String[] args) {
                int a = 10;
                int b = 20;
                int c = 40;
    
                int result = (a > b) ? a : b;   //三目运算符 需求1
                System.out.println(result);
                
                int max = (result > c) ? result : c;    //三目运算符 需求2
                System.out.println("三个数中最大值为：" + max);

                int x = 11;
                int y = 12;
                boolean res2 = (x == y) ? true : false;
                System.out.println("x与y进行比较：" + res2);    //三目运算符 需求3
                }
            }

二、键盘录入信息
1、键盘录入
    使用键盘录入的原因：前面的代码中数值都是固定的，但实际开发中，数值是不断变化的，需要手动输入
2、使用步骤：
    1）、导包
        import java.util.Scanner;
    2）、创建Scanner对象
        Scanner sc = new Scanner(System.in);
    3）、调用对象中的方法，接收键盘录入的信息
        sc.nextInt()
3、注意事项：
    1）、调用的方法接收的数据是什么类型，就用对应方法类型的变量接收
    2）、键盘录入的数据必须和调用方法的类型一致，不然会报错
        java.util.InputMismatchException 输入不匹配异常
4、简单举例
    import java.util.Scanner;   //导包
    public class ScannerDemo1 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);    //创建对象
            int i = sc.nextInt();   //使用对象sc的nextInt()方法让i接受一个键盘输入的int类型的数据，等待键盘录入数据
            System.out.println("键盘录入的数据为：" + i);   //输出刚才输入的数据i
        }
    }

三、程序的三大结构（顺序结构、选择结构、循环结构）
1、顺序结构
    按照代码的顺序，程序自上而下的执行
2、选择结构
    1）if语句
        a、if语句的第一种格式
            if(关系表达式){
                语句体
            }
            执行流程：
                首先判断关系表达式看其结果是true还是false，
                如果是true就执行语句体，如果是false就不执行语句体
            注：
                1、如果在关系表达式小括号后面加上了一个分号，说明if语句结束，默认存在一个空语句体
                2、括号都是成双成对出现的
                3、小括号中的结果必须是布尔类型（boolean类型）
        b、if语句的第二种格式
            if(关系表达式){
                语句体1;
            }else{
                语句体2;
            }
            执行流程：
                首先判断关系表达式看其结果是true还是false
                如果是true就执行语句体1，如果是false就执行语句体2
            注：
                三目运算符有时可以与这一种if语句转换，有时不行
        c、if语句的第三种格式
            if(关系表达式1){
                语句体1;
            }else if(关系表达式2){
                语句体2;
            }else if(关系表达式3){
                语句体3;
            }
            ...
            else{
                语句体n;
            }
        d、举例
            x和y的关系满足如下：
                    x>=3     y = 2x + 1;
                    -1<=x<3     y = 2x;
                    x<=-1     y = 2x - 1;
                键盘录入x的值，判断x的范围，执行不同的公式
            分析：
                1、导包
                2、创建键盘录入对象
                3、用变量x接收键盘录入的int类型的数据
                4、if语句判断执行不同的路径
                5、输出
           
            import java.util.Scanner;   //导包
            public class IfTest1 {
                public static void main(String[] args) {               
                    Scanner sc = new Scanner(System.in);    //创建键盘录入对象         
                    System.out.println("请输入x的值：");    //键盘录入数据
                    int x = sc.nextInt();   //键盘输入x的值
                    int y = 0;
                    if (x >= 3) {
                        y = 2 * x + 1;
                    } else if (x >= -1 & x < 3) {
                        y = 2 * x;
                    } else if (x <= -1) {
                        y = 2 * x - 1;
                    } else {
                        System.out.println("输入的数据有误");
                    }   //if选择结构完成需求
                    System.out.println("y的值为：" + y);    //输出y的值
                }
            }

                明天继续