java第三天(运算符、键盘录入和控制语句)

1:运算符(掌握)
　　(1)算术运算符
　　　　A:+,-,*,/,%,++,--
　　　　B:+的用法
　　　　　　a:加法
　　　　　　b:正号
　　　　　　c:字符串连接符

class OperatorDemo {
    public static void main(String[] args) {
        //加法
        System.out.println(3+4);
        
        //正号
        System.out.println(+4);
        
        System.out.println('a');
        System.out.println('a'+1);     //这里是加法
        
        //字符串连接符
        System.out.println("hello"+'a'+1);
        System.out.println('a'+1+"hello");    //先加后连接
    }
}

 

　　　　C:/和%的区别
　　　　　　数据做除法操作的时候:

　　　　　　　　/取得是商

　　　　　　　  %取得是余数：（%2，可用于判断数的奇偶性，为“0”为偶，为“1”为奇）

　　　　　　　　（一般组合用于求出一个多位数的每一位数）

//求出312的每一位数

int a = 312;

int ge = a%10;            //求出个位数

int shi = a/10%10;        //求出十位数

int bai = a/100%10;    //求出百位数        

 

　　　　D:++和--的用法
　　　　　　a:他们的作用是自增或者自减
　　　　　　b:使用
　　　　　　　　**单独使用
　　　　　　　　　　放在操作数据的前面和后面效果一样。
　　　　　　　　　　a++或者++a效果一样。
　　　　　　　　**参与操作使用
　　　　　　　　　　放在操作数的前面：先自增或者自减，再参与操作
　　　　　　　　　　放在操作数的后面：先参与操作，再自增或者自减
　　　　　　　　　　

class OperatorDemo {
        public static void main(String[] args) {
            //定义两个变量
            int x = 3;
            int y = 4;
            
            //字符串的拼接
            //System.out.println("x:"+x);
            //System.out.println("y:"+y);
            
            System.out.println("x:"+x+",y:"+y);
            
            //单独使用
            //x++;
            //y--;
            ++x;
            --y;
            //System.out.println(x);
            System.out.println("x:"+x+",y:"+y);
            
            //意外的类型,常量是不可以这样做的
            //System.out.println(10++);
            
            System.out.println("-------------------");
            //参与运算使用
            int a = 3;
            int b = 4;
            
            //int c = a++;
            //int d = b--;
            
            int c = ++a;
            int d = --b;
            
            System.out.println("a:"+a); //4, 4
            System.out.println("b:"+b); //3, 3
            System.out.println("c:"+c); //3, 4
            System.out.println("d:"+d); //4, 3
        }
}　　

　　(2)赋值运算符
　　　　A:=,+=,-=,*=,/=,%=等
　　　　B:=叫做赋值运算符，也是最基本的赋值运算符
　　　　　　int x = 10; 把10赋值给int类型的变量x。
　　　　C:扩展的赋值运算符的特点
　　　　　　隐含了自动强制转换。

　　(3)比较运算符（无论运算符两端简单还是复杂最终结果是boolean类型）
　　　　A:==,!=,>,>=,<,<=
　　　　B:千万不要把==写成了=
　　(4)逻辑运算符
　　　　A:&,|,^,!,&&,||
　　　　B:逻辑运算符用于连接boolean类型的式子
　　　　C:结论
　　　　　　&:有false则false
　　　　　　|:有true则true
　　　　　　^:相同则false，不同则true。
　　　　　　情侣关系。
　　　　　　!:非true则false，非false则true

　　　　　　&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
　　　　　　||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。

　　　　　int a = 3;
        int b = 4;
        int c = 5;

 4         //^逻辑异或
        System.out.println((a > b) ^ (a > c));             //false ^ false = false
        System.out.println((a > b) ^ (a < c));             //false ^ true = true
        System.out.println((a < b) ^ (a > c));             //true ^ false = true
        System.out.println((a < b) ^ (a < c));             //true ^ true = false
        System.out.println("---------------");
        
        //!逻辑非
        System.out.println(!(a > b)); 　　　　　　　　       //!false = true
        System.out.println(!(a < b)); 　　　　　　　　　　    //!true = false
        System.out.println(!!(a > b)); 　　　　　　　　　　　 //!!false = false
        System.out.println(!!!(a > b));                   //!!false = true

 

 

　　(5)位运算符(了解)
　　　　A:^的特殊用法
　　　　　　一个数据针对另一个数据位异或两次，该数不变

int a = 10;
int b = 20;

System.out.println(a ^ b ^ b); //10
System.out.println(a ^ b ^ a); //20

 

　　　　B:面试题
　　　　　　a:请实现两个变量的交换
　　　　　　　　

class OperatorTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        System.out.println("a:"+a+",b:"+b);
        
        //方式1：使用第三方变量(开发中用的)
        
        int c = a;
        a = b;
        b = c;
        System.out.println("a:"+a+",b:"+b);
        System.out.println("------------");
        
        
        //方式2：用位异或实现(面试用)
        //左边：a,b,a
        //右边：a ^ b
        
        a = a ^ b;
        b = a ^ b; //a ^ b ^ b = a
        a = a ^ b; //a ^ b ^ a = b
        System.out.println("a:"+a+",b:"+b);
        
        
        //方式3：用变量相加的做法
        
        a = a + b; //a=30
        b = a - b; //b=10
        a = a - b; //a=20
        System.out.println("a:"+a+",b:"+b);
        
        
        //方式4：一句话搞定
        b = (a+b) - (a=b); //b=30-20=10,a=20
        System.out.println("a:"+a+",b:"+b);
    }
}

 

　　　　　　b:请用最有效率的方式计算出2乘以8的结果
　　　　　　　　2<<3

/*
    <<:左移    左边最高位丢弃，右边补齐0
    >>:右移    最高位是0，左边补齐0；最高为是1，左边补齐1
    >>>:无符号右移 无论最高位是0还是1，左边补齐0
    
    面试题：
        请用最有效率的方式写出计算2乘以8的结果?
            2 * 8
            
            2 << 3

*/
class OperatorDemo3 {
    public static void main(String[] args) {
        //<< 把<<左边的数据乘以2的移动次幂
        System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
    
        //>> 把>>左边的数据除以2的移动次幂
        System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
        System.out.println(24 >>> 2);
        
        System.out.println(-24 >> 2); 
        System.out.println(-24 >>> 2);
    }
}
/*
    计算出3的二进制：11
        00000000 00000000 00000000 00000011
    (00)000000 00000000 00000000 0000001100
        
    >>的移动：    
    计算出24的二进制：11000
        原码：10000000 00000000 00000000 00011000
        反码：11111111 11111111 11111111 11100111
        补码：11111111 11111111 11111111 11101000
        
        11111111 11111111 11111111 11101000
        1111111111 11111111 11111111 111010(00) 补码
        
        补码：1111111111 11111111 11111111 111010
        反码：1111111111 11111111 11111111 111001
        原码：1000000000 00000000 00000000 000110
        
        结果：-6
        
    >>>的移动：
        计算出24的二进制：11000
        原码：10000000 00000000 00000000 00011000
        反码：11111111 11111111 11111111 11100111
        补码：11111111 11111111 11111111 11101000
        
        11111111 11111111 11111111 11101000
        0011111111 11111111 11111111 111010(00)
        
        结果：
*/

 

　　　　*位运算补充：

/*
    位运算符：
        &,|,^,~
        <<,>>,>>>
        
    注意：
        要做位运算，首先要把数据转换为二进制。
*/
class OperatorDemo {
    public static void main(String[] args) {
        //&,|,^,~
        
        int a = 3;
        int b = 4;
        
        System.out.println(3 & 4);
        System.out.println(3 | 4);
        System.out.println(3 ^ 4);
        System.out.println(~3);
    }
}
/*
    分析：因为是位运算，所以我们必须先把数据换算成二进制。
    
    3的二进制：11
        00000000 00000000 00000000 00000011
    4的二进制：100
        00000000 00000000 00000000 00000100
    
    &位与运算：有0则0。
        00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000000
        结果是：0
        
    |位或运算：有1则1。
        00000000 00000000 00000000 00000011
       |00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000111
        结果是：7
        
    ^位异或运算：相同则0，不同则1。
        00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000111
        结果是：7
        
    ~按位取反运算符：0变1，1变0
        00000000 00000000 00000000 00000011
       ~11111111 11111111 11111111 11111100 (补码)
       
       补码：11111111 11111111 11111111 11111100
       反码：11111111 11111111 11111111 11111011
       原码：10000000 00000000 00000000 00000100
        结果是：-4
*/

 

　　(6)三元运算符
　　　　A:格式
　　　　　　比较表达式?表达式1:表达式2;
　　　　B:执行流程：
　　　　　　首先计算比较表达式的值，看是true还是false。
　　　　　　如果是true，表达式1就是结果。
　　　　　　如果是false，表达式2就是结果。
　　　　C:案例：
　　　　　　a:比较两个数据是否相等　　　　　　boolean flag = (x == y) ? true : false;
　　　　　　b:获取两个数据中的最大值              int max = (x > y? x: y);
　　　　　　c:获取三个数据中的最大值：　　　　int max = (a > b)?((a > c)? a: c):((b > c)? b: c);

2:键盘录入(掌握)
　　(1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。
　　(2)如何实现呢?目前就记住
　　　　A:导包
　　　　　　import java.util.Scanner;
　　　　　　位置：在class的上边
　　　　B:创建对象
　　　　　　Scanner sc = new Scanner(System.in);
　　　　C:获取数据
　　　　　　int x = sc.nextInt();
　　(3)把三元运算符的案例加入键盘录入改进。

3:流程控制语句
　　(1)顺序结构 从上往下，依次执行
　　(2)选择结构 按照不同的选择，执行不同的代码
　　(3)循环结构 做一些重复的代码

4:if语句(掌握)
　　(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:一般来说，有左大括号，就没有分号，有分号，就没有左大括号。
　　　　D:else后面如果没有if，是不会出现比较表达式的。
　　　　E:三种if语句其实都是一个语句，只要有一个执行，其他的就不再执行。
　　(3)案例：
　　　　A:比较两个数是否相等
　　　　B:获取两个数中的最大值
　　　　C:获取三个数中的最大值(if语句的嵌套)
　　　　D:根据成绩输出对应的等级
　　　　E:根据月份，输出对应的季节
　　　　F:根据x计算对应y的值并输出
　　(4)三元运算符和if语句第二种格式的关系
　　　　所有的三元运算符能够实现的，if语句的第二种格式都能实现。
　　　　反之不成立。

　　　　如果if语句第二种格式控制的语句体是输出语句，就不可以。
　　　　因为三元运算符是一个运算符，必须要有一个结果返回，不能是一个输出语句。

/*
    获取三个数据中的最大值
    
    由此案例主要是为了讲解if语句是可以嵌套使用的。而且是可以任意的嵌套。
*/
class IfTest4 {
    public static void main(String[] args) {
        int a = 10;
        int b = 30;
        int c = 20;
        
        //三元实现
        int max = (a>b)?(a>c?a:c):(b>c?b:c);
        System.out.println("max:"+max);
        System.out.println("--------");
        
        //用if语句实现
        int max;
        if(a > b) {
            if(a > c) {
                max = a;
            }else {
                max = c;
            }
        }else {
            if(b > c) {
                max = b;
            }else {
                max = c;
            }
        }
        System.out.println("max:"+max);
    }
}