java学习第三天

运算符
就是对常量和变量进行操作的符号
    算术运算符
        +,-,*,/,%,++,--
        注意事项:
        A:整数相除只能得到整数。如果想得到小数,必须把数据变化为浮点数
        B:++,--运算符,单独使用放在前面后面一样
        C:++,--运算符参与运算
            C.1:放在前面结果+1或-1,先自增或者自减,然后再参与运算
            C.2:放在后面结果不变,但值变化了,先参与运算再自增自减
        D:+的用法:加法,正号,字符串连接符
            D.1:'a'+1  结果为98
            D.2:"HELLO"+'a'+1   结果为HELLOa1
            D.3:'a'+1+"HELLO"   结果为98HELLO

    赋值运算符
        =,+=,-=,*=,/=,%=
        面试题:
        short s=1,s=s+1;    //有问题,s+1是int型,赋值给short型会损失精度
        short s=1,s+=1;     //没有问题,因为扩展的赋值运算符其实隐含了一个强制类型转换,等价于s=(s的数据类型)(s+1)
        这两个代码有没有问题,如果有,哪里有问题?        
        
    比较运算符
        A:==,!=,>,>=,<,<=
        B:无论运算符两端简单还是复杂最终结果是boolean类型。
            如:int x=1,y=2,z=1;
                System.out.println(x==y);    //结果false
                System.out.println(x==z);   //结果true
        C:千万不要把==写成了=
        
    逻辑运算符
        A:&,|,^,!,&&,||
        B:逻辑运算符用于连接boolean类型的式子
        C:结论
            &:有false则false
            |:有true则true
            ^:相同则false,不同则true。
                情侣关系。
            !:非true则false,非false则true            
            &&:结果和&是一样的,只不过有短路效果。左边是false,右边不执行。
                如:
                int x=3,y=4;
                boolean b1 = (++x == 3 && y++ ==4);
                System.out.println("x:"+x);        //4
                System.out.println("y:"+y);        //4,因为左边是false,右边不执行
                System.out.println(b1);         //false
            ||:结果和|是一样的,只不过有短路效果。左边是true,右边不执行。
                如:
                int x=3,y=4;
                boolean b1 = (x++ == 3 || y++ ==4);
                System.out.println("x:"+x);        //4
                System.out.println("y:"+y);        //4,因为左边是true,右边不执行
                System.out.println(b1);         //true
            注:开发中常用的逻辑运算符:&&,||,!
            
    位运算符(了解)
        要做位运算,首先将数据转化为二进制
        A:&,|,^,~(位异或)        
        注:&,|,^,两边是数字则进行位运算,两边是boolean类型则进行逻辑运算
        System.out.println(3&4);//结果为0
        System.out.println(3|4);//结果为7
        System.out.println(3^4);//结果为7
        System.out.println(~3); //结果为-4(负数的补码-1再取反,获得的数转化为十进制为最后结果)
        &运算:有0则0
        |运算:有1则1
        ^运算:相同为0,不同为1,一个数与另一个数异或两次,该数本身不变
        ~运算:0变1,1变0
        面试题:
        请自己实现两个整数变量的交换
        方式一:使用第三方变量(开发中常用)
        方式二:用位异或实现,左边a,b,a,右边a^b
                a = a ^ b;    
                b = a ^ b;    //b=a^b^b=a
                a = a ^ b;    //a=a^a^b=b
        方式三:用变量相加的做法
                a = a + b;
                b = a - b;
                a = a - b;
        方式四:一句话搞定
                b = (a+b) - (a=b);
                    
        B:<<,>>,>>>位移运算符
            <<:左边最高位丢弃,右边补齐0            把<<左边的数据*2的移动次幂
            >>:最高位是0,左边补齐0;最高位是1,左边补齐1      把>>左边的数据/2的移动次幂
            >>>:无符号右移,无论最高位是0还是1,左边补齐0
        3 << 2       //结果为12
            00000000 00000000 00000000 00000011
        (00)000000 00000000 00000000 00000011 00
        -24 >> 2      //结果为6
            原码:10000000 00000000 00000000 00011000
            反码:11111111 11111111 11111111 11100111
            补码:11111111 11111111 11111111 11101000
            右移两位     1111111111 11111111 11111111 111010(00)
                反码:   1111111111 11111111 11111111 111001
                原码:   1000000000 00000000 00000000 000110      //结果为-6
        -24 >>> 2   //结果为1073741818        
            面试题:计算2 * 8----------------2 << 3
            
    三目运算符
        A:格式
            比较表达式?表达式1:表达式2;
        B:执行流程:
            首先计算比较表达式的值,看是true还是false。
            如果是true,表达式1就是结果。
            如果是false,表达式2就是结果。
        C:案例:
            a:比较两个数据是否相等
                boolean flag = (x==y)?true:false;
                或者 boolean flag = (x = y);
            b:获取两个数据中的最大值
                max = x>y?x:y
            c:获取三个数据中的最大值
                temp = (a>b)?a:b;
                max = (temp>c)?temp:b;   //或者int max = (a>b)?((a>c)?a:c):((b>c)?b:c);
    
    键盘录入数据
        (1)实际开发中,数据是变化的,为了提高程序的灵活性,我们加入键盘录入数据。
        (2)如何实现呢?目前就记住
         A:导包
            import java.util.Scanner;
            位置:在class的上边
         B:创建对象
            Scanner sc = new Scanner(System.in);
         C:获取数据
            int x = sc.nextInt();
        (3)把三元运算符的案例加入键盘录入改进。                            
        
语句
    顺序结构
    按顺序,从上往下依次执行
    
    选择结构(也叫分支结构)
    按照不同的选择,执行不同的代码
        (1)三种格式
        A:格式1
            if(比较表达式) {
                语句体;
            }        
            执行流程:
                判断比较表达式的值,看是true还是false
                如果是true,就执行语句体
                如果是false,就不执行语句体
        B:格式2
            if(比较表达式) {
                语句体1;
            }else {
                语句体2;
            }            
            执行流程:
                判断比较表达式的值,看是true还是false
                如果是true,就执行语句体1
                如果是false,就执行语句体2                
        C:格式3
            if(比较表达式1) {
                语句体1;
            }else if(比较表达式2){
                语句体2;
            }
            ...
            else {
                语句体n+1;
            }            
            执行流程:
                判断比较表达式1的值,看是true还是false
                如果是true,就执行语句体1
                如果是false,就继续判断比较表达式2的值,看是true还是false
                如果是true,就执行语句体2
                如果是false,就继续判断比较表达式3的值,看是true还是false
                ...
                如果都不满足,就执行语句体n+1
    
        (2)注意事项
        A:比较表达式无论简单还是复杂,结果是boolean类型
        B:if语句控制的语句体如果是一条语句,是可以省略大括号的;如果是多条,不能省略。
            建议:永远不要省略。
        C:一般来说,有左大括号,就没有分号,有分号,就没有左大括号。
            如:if(b!=10);    //这里其实是有语句体的,只不过是空语句
        D:else后面如果没有if,是不会出现比较表达式的。
        E:三种if语句其实都是一个语句,只要有一个执行,其他的就不再执行。
        (3)三元运算符和if语句第二种格式的关系
        所有的三元运算符能够实现的,if语句的第二种格式都能实现。
        反之不成立。
        如果if语句第二种格式控制的语句体是输出语句,就不可以。
        因为三元运算符是一个运算符,必须要有一个结果返回,不能是一个输出语句。
        
    switch语句(掌握)
    (1)格式:
        switch(表达式) {
            case 值1:
                语句体1;
                break;
            case 值2:
                语句体2;
                break;
            ...
            default:
                语句体n+1;
                break;
        }        
        格式解释说明:
            switch:说明这是switch语句。
            表达式:可以是byte,short,int,char
                JDK5以后可以是枚举
                JDK7以后可以是字符串
            case:后面的值就是要和表达式进行比较的值
            break:表示程序到这里中断,跳出switch语句
            default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else
    (2)面试题
        switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?
            可以,不可以,JDK7以后可以
    (3)执行流程:
        A:首先计算表达式的值
        B:和每一个case进行匹配,如果有就执行对应的语句体,看到break就结束。
        C:如果没有匹配,就执行default的语句体n+1。
    (4)注意事项:
        A:case后面只能是常量,不能是变量,而且,多个case后面的值不能出现相同的
        B:default可以省略吗?
            可以省略,但是不建议,因为它的作用是对不正确的情况给出提示。
            特殊情况:
                case就可以把值固定。
                A,B,C,D
        C:break可以省略吗?
            可以省略,但是结果可能不是我们想要的。
            会出现一个现象:case穿透。
            最终我们建议不要省略
        D:default一定要在最后吗?
            不是,可以在任意位置。但是建议在最后。
        E:switch语句的结束条件
            a:遇到break就结束了
            b:执行到末尾就结束了
    (5)案例:
        A:键盘录入一个数字(1-7),输出对应的星期几。
        B:单项选择题
        C:键盘录入一个字符串的问题
            String s = sc.nextLine();
        D:根据给定的月份,输出对应的季节
    (6)if语句和switch语句各自的场景
        A:if
            针对boolean类型的判断
            针对一个范围的判断
            针对几个常量的判断
        B:switch
            针对几个常量的判断
原文地址:https://www.cnblogs.com/zhuzhutest/p/5543445.html