java基础（三）

逻辑运算符的基本用法

　　A:逻辑运算符有哪些
　　 　　&,|,^,!
　　　　 &&,||

class Demo1_Operator {
    public static void main(String[] args) {
        //&,|,^,!
        //int x = 10;
        //5 < x < 15
        //x > 5 & x < 15
        //逻辑与 & 并且and 遇false则false
        int a = 10;
        int b = 20;
        int c = 30;
        /*System.out.println(a < b & b < c);              //true & true = true
        System.out.println(a < b & b > c);                //true & false = false
        System.out.println(a > b & b < c);                //false & true = false
        System.out.println(a > b & b > c);                //false & false = false*/

        //逻辑或 或or 遇true则true
        /*System.out.println(a < b | b < c);              //true | true = true
        System.out.println(a < b | b > c);                //true | false = true
        System.out.println(a > b | b < c);                //false | true = true
        System.out.println(a > b | b > c);                //false | flase = false*/

        //逻辑异或 ^ 两边相同为false,两边不同为true
        /*System.out.println(a < b ^ b < c);                //true | true = false
        System.out.println(a < b ^ b > c);                //true | false = true
        System.out.println(a > b ^ b < c);                //false | true = true
        System.out.println(a > b ^ b > c);                //false | flase = false*/

        //逻辑非!
        System.out.println(!true);
        System.out.println(!!true);
    }
}

　　注意事项：　　
　　　　 a:逻辑运算符一般用于连接boolean类型的表达式或者值。
　　　　 b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
　　　　　　算术表达式：a + b
　　　　　　比较表达式：a == b(条件表达式)
 　　C:结论：
　　　　&逻辑与:有false则false。
　　　　|逻辑或:有true则true。
　   　　 ^逻辑异或:相同为false，不同为true。
　　　　!逻辑非:非false则true，非true则false。
　　　　　　特点：偶数个不改变本身。

逻辑运算符&&和&的区别

　　&&和&的区别?
　　　　 a:最终结果一样。
　　　　 b:&&具有短路效果。左边是false，右边不执行。
　　&是无论左边是false还是true,右边都会执行

位运算符的基本用法1

　　A:位运算符有哪些
　　　　&,|,^,~ ,>>,>>>,<<

class Demo1_Operator {
    public static void main(String[] args) {
        /*
        * &,|,^,~ 的用法
        * &:有0则0
        * |:有1则1
        * ^:相同则0，不同则1
        * ~:按位取反
        */

        System.out.println(6 & 3);                //2
        System.out.println(6 | 3);                //7
        System.out.println(6 ^ 3);                //5    
        System.out.println(~6);                    //-7?                    
    }
}
/*
    110
&   011
-----------
    010

    110
|    011
-----------
    111

    110
^    011
-----------
    101

    00000000 00000000 00000000 00000110        6的原码反码补码都是本身
    11111111 11111111 11111111 11111001        对6取反
-    00000000 00000000 00000000 00000001
---------------------------------------
    11111111 11111111 11111111 11111000        反码
    10000000 00000000 00000000 00000111        原码(-7)
*/

位异或运算符的特点及面试题

　　A:案例演示
　　　　位异或运算符的特点

　　　　^的特点：一个数据对另一个数据位异或两次，该数本身不变。

class Demo2_Operator {
    public static void main(String[] args) {
        /*
        * 位异或运算符的特点

        * ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
        */

        //System.out.println(5 ^ 10 ^ 10);
        //System.out.println(5 ^ 10 ^ 5);

        /*
        * 请自己实现两个整数变量的交换(不需要定义第三方变量)
        * 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
        */

        int x = 10;
        int y = 5;

        //需要第三方变量,开发推荐用这种
        /*int temp;
        temp = x;
        x = y;
        y = temp;*/

        //不需要定义第三方变量,有弊端,有可能会超出int的取值范围
        /*x = x + y;                //10 + 5 = 15
        y = x - y;                //15 - 5 = 10
        x = x - y;                //15 - 10 = 5*/

        //不需要第三方变量,通过^来做
        x = x ^ y;                // 10 ^ 5 
        y = x ^ y;                // 10 ^ 5 ^ 5    y = 10
        x = x ^ y;                // 10 ^ 5 ^ 10  x = 5

        System.out.println("x = " + x + ",y = " + y);
    }
}

位运算符的基本用法2及面试题

A:案例演示 >>,>>>,<<的用法:
　　<<:左移 左边最高位丢弃，右边补齐0
　　>>:右移 最高位是0，左边补齐0;最高为是1，左边补齐1
　　>>>:无符号右移 无论最高位是0还是1，左边补齐0
 　　最有效率的算出2 * 8的结果

class Demo3_Operator {
    public static void main(String[] args) {
        /*
        *  <<:左移    左边最高位丢弃，右边补齐0
        *  >>:右移    最高位是0，左边补齐0;最高为是1，左边补齐1
        *  >>>:无符号右移 无论最高位是0还是1，左边补齐0
        *  最有效率的算出2 * 8的结果
        */

        //左移,向左移动几位就是乘以2的几次幂
        //System.out.println(12 << 1);        //24
        //System.out.println(12 << 2);        //48

        /*
        00000000 00000000 00000000 00001100        12的补码
     (0)0000000 00000000 00000000 000011000        24的补码
    (00)000000 00000000 00000000 0000110000        48的补码
        */

        //右移,向右移动几位就是除以2的几次幂
        //System.out.println(12 >> 1);
        //System.out.println(12 >> 2);

        /*
        00000000 00000000 00000000 00001100        12的补码
        000000000 00000000 00000000 0000110(0)    6
        0000000000 00000000 00000000 000011(00) 3
        */

        //最有效率的算出2 * 8的结果
        System.out.println(2 << 3);
    }
}

三元运算符的基本用法

　　A:三元运算符的格式
　　　　(关系表达式) ? 表达式1 : 表达式2;
　　 B:三元运算符的执行流程

class Demo1_Operator {
    public static void main(String[] args) {
        //(关系表达式) ? 表达式1 : 表达式2;
        int x = 10;
        int y = 5;
        int z;
        z = (x > y) ? x : y;

        System.out.println("z = " + z);
    }
}

键盘录入的基本格式讲解

/*
* a:导包
        * 格式：
            * import java.util.Scanner; 
        * 位置：
            * 在class上面。
    * b:创建键盘录入对象
        * 格式：
            * Scanner sc = new Scanner(System.in);
    * c:通过对象获取数据    
        * 格式：
            * int x = sc.nextInt();
*/
import java.util.Scanner;
class Demo2_Scanner {
    public static void main(String[] args) {
        /*Scanner sc = new Scanner(System.in);            //创建键盘录入对象
        System.out.println("请输入一个整数:");
        int x = sc.nextInt();                            //将键盘录入的数据存储在x中
        System.out.println(x);*/

        //录入两个整数
        Scanner sc = new Scanner(System.in);            //创建键盘录入对象
        System.out.println("请输入第一个整数:");
        int x = sc.nextInt();                            //将键盘录入的数据存储在x中
        System.out.println(x);

        System.out.println("请输入第二个整数:");
        int y = sc.nextInt();                            //将键盘录入的数据存储在y中
        System.out.println(y);
    }
}

顺序结构语句

　　A:什么是流程控制语句
　　　　流程控制语句：可以控制程序的执行流程。
　　 B:流程控制语句的分类
　　　　 顺序结构
　　　　 选择结构
　　　　 循环结构
　　C:执行流程：
　　　　 从上往下，依次执行。

class Demo1_Sequence {                            //sequence 顺序
    public static void main(String[] args) {
        System.out.println("Hello World!11111");
        System.out.println("Hello World!3333");
        System.out.println("Hello World!22222");
        System.out.println("Hello World!44444");
    }
}

选择结构if语句格式1及其使用

　　A:选择结构的分类
　　　　 if语句
　　　　 switch语句

if(比较表达式) {
            语句体;
        }

if(比较表达式) {
            语句体1;
        }else {
            语句体2;
        }

if(比较表达式1) {
            语句体1;
        }else if(比较表达式2) {
            语句体2;
        }else if(比较表达式3) {
            语句体3;
        }
        ...
        else {
            语句体n+1;
        }

选择结构switch语句的格式及其解释

switch(表达式) {
              case 值1：
                语句体1;
                break;
                case 值2：
                语句体2;
                break;
                …
                default：    
                语句体n+1;
                break;
        }

class Demo1_Switch {
    public static void main(String[] args) {
        /*
        * A:switch语句的格式
        *        int x = 10;
                switch(表达式) {        //基本数据类型可以接收byte,short,char,int
                      case 值1：        //引用数据类型可以接收枚举(JDK1.5)String字符串(JDK1.7)
                        语句体1;
                        break;
                        case 值2：
                        语句体2;
                        break;
                        …
                        default：    
                        语句体n+1;
                        break;
                }
         
        * B:switch语句的格式解释
        * C:面试题
            * byte可以作为switch的表达式吗?
            * long可以作为switch的表达式吗?
            * String可以作为switch的表达式吗?
        * C:执行流程
            * 先计算表达式的值
            * 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句
        */

        String name = "rose";
        String gender = "妖";
        switch (gender) {
        case "男士":
            System.out.println(name + "是一位" + gender + "喜欢吃饭睡觉打dota");
        break;
        case "女士":
            System.out.println(name + "是一位" + gender + "喜欢逛街购物美容");
        break;
        default:
            System.out.println(name + "是一位" + gender + "打雌性激素维持美貌容颜");
        break;
        }
    }
}

选择结构switch语句的注意事项

　　default可以省略吗?
　　　　 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
　　　　 特殊情况：
　　 　　　　case就可以把值固定。
　　　　　　 A,B,C,D
　　 c:break可以省略吗?
　　　　 最后一个可以省略,其他最好不要省略
　　　　 会出现一个现象：case穿透。
　　 　　最终我们建议不要省略
　　 d:default一定要在最后吗?
　　　　 不是，可以在任意位置。但是建议在最后。
　　 e:switch语句的结束条件
　　　　 a:遇到break就结束了
　　　　 b:执行到switch的右大括号就结束了

class Test1_Switch {
    public static void main(String[] args) {
        //* A:整数(给定一个值,输出对应星期几)
        int week = 1;
        switch (week) {
        case 1:
            System.out.println("星期一");
        break;
        case 2:
            System.out.println("星期二");
        break;
        case 3:
            System.out.println("星期三");
        break;
        case 4:
            System.out.println("星期四");
        break;
        case 5:
            System.out.println("星期五");
        break;
        case 6:
            System.out.println("星期六");
        break;
        case 7:
            System.out.println("星期日");
        break;
        default:
            System.out.println("对不起没有对应的星期");
        break;
        }
    }
}

选择结构if语句和switch语句的区别

　　A:总结switch语句和if语句的各自使用场景
　　　　switch建议判断固定值的时候用
　　　　 if建议判断区间或范围的时候用