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建议判断区间或范围的时候用

posted on 2017-10-20 23:59  虫儿aqa  阅读(128)  评论(0编辑  收藏  举报

导航