黑马程序员技术交流社区

标题: java基础第三天笔记 [打印本页]

---

作者: axiaowenjin    时间: 2016-6-30 20:56
标题: java基础第三天笔记
03.01_Java语言基础(逻辑运算符的基本用法)(掌握)
* A:逻辑运算符有哪些
        * &,|,^,!
        * &&,||
* B:案例演示
* 逻辑运算符的基本用法
       
* 注意事项：
        * a:逻辑运算符一般用于连接boolean类型的表达式或者值。
        * b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
                * 算术表达式：a + b
                * 比较表达式：a == b(条件表达式)
* C:结论：
* &逻辑与:有false则false。
* |逻辑或:有true则true。
* ^逻辑异或:相同为false，不同为true。
* !逻辑非:非false则true，非true则false。
        * 特点：偶数个不改变本身。
案例：
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);
        }
}





###03.02_Java语言基础(逻辑运算符&&和&的区别)(掌握)
* A:案例演示
        * &&和&的区别?
                * a:最终结果一样。
                * b:&&具有短路效果。左边是false，右边不执行。
                *         &是无论左边是false还是true,右边都会执行
*||和|的区别?
      *a:最终结果一样
      *b:||具有短路效果.左边是true,右边不执行
      *      |是无论左边是false还是true,右边都会执行
* B:同理||和|的区别?(学生自学)
* C:开发中常用谁?
        * &&,||,!
案例：
class Demo2_Operator {
        /*
        &&与&的区别
        * a:最终结果一样。
        * b:&&具有短路效果。左边是false，右边不执行。
        ||与|的区别
        a:最终的结果是一样
        b:||具有短路效果,左边为true,右边不执行
        */
        public static void main(String[] args) {
                /*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*/
                int x = 3;
                int y = 4;
                //System.out.println((++x == 3) & (++y == 4));        //false & false = false
                //System.out.println("x = " + x);                                        //x = 4
                //System.out.println("y = " + y);                                        //y = 5
                System.out.println("---------------------------");
                System.out.println((++x == 3) && (++y == 4));        //false & false = false
                System.out.println("x = " + x);                                        //x = 4
                System.out.println("y = " + y);                                        //y = 4
        }
}

###03.03_Java语言基础(位运算符的基本用法1)(了解)
* A:位运算符有哪些
        * &,|,^,~ ,>>,>>>,<<
* B:案例演示
        * 位运算符的基本用法1
       
        * &,|,^,~ 的用法
        * &:有0则0
        * |:有1则1
        * ^:相同则0，不同则1
        * ~:按位取反
案例：
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)
*/


###03.04_Java语言基础(位异或运算符的特点及面试题)(掌握)
* A:案例演示
        * 位异或运算符的特点

        * ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
       
* B:面试题：
        * 请自己实现两个整数变量的交换
        * 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
案例：
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);
        }
}

###03.05_Java语言基础(位运算符的基本用法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);
        }
}


###03.06_Java语言基础(三元运算符的基本用法)(掌握)
* A:三元运算符的格式
*                 (关系表达式) ? 表达式1 : 表达式2;
* B:三元运算符的执行流程
* C:案例演示
        * 获取两个数中的最大值
案例：
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);
        }
}


###03.07_Java语言基础(三元运算符的练习)(掌握)
* A:案例演示
        * 比较两个整数是否相同
* B:案例演示
        * 获取三个整数中的最大值
案例：
class Test1_Operator {
        public static void main(String[] args) {
                /*
                * A:案例演示
                        * 比较两个整数是否相同
                * B:案例演示
                        * 获取三个整数中的最大值
                */
                //比较两个整数是否相同
                /*int x = 10;
                int y = 10;
                //boolean b = (x == y) ? true : false;
                boolean b = (x == y);
                System.out.println("b = " +  b);*/
                //获取三个整数中的最大值
                int a = 10;
                int b = 20;
                int c = 30;
                //先比较任意两个数的值,找出这两个数中的最大值
                int temp = (a > b) ? a : b;
                //用前两个数的最大值与第三个数比较,获取最大值
                int max = (temp > c) ? temp : c;
                System.out.println("max =" + max);
        }
}



###03.08_Java语言基础(键盘录入的基本格式讲解)(掌握)
* A:为什么要使用键盘录入数据
        * a:为了让程序的数据更符合开发的数据
        * b:让程序更灵活一下
* B:如何实现键盘录入呢?
        * 先照格式来。
        * a:导包
                * 格式：
                        * import java.util.Scanner;
                * 位置：
                        * 在class上面。
        * b:创建键盘录入对象
                * 格式：
                        * Scanner sc = new Scanner(System.in);
        * c:通过对象获取数据       
                * 格式：
                        * int x = sc.nextInt();
* C:案例演示
        * 键盘录入1个整数，并输出到控制台。
        * 键盘录入2个整数，并输出到控制台。
案例：
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);
        }
}

###03.09_Java语言基础(键盘录入的练习1)(掌握)
* A:案例演示
        * 键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
* B:案例演示
        * 键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值
案例：
import java.util.Scanner;                                                //导入包中的类Scanner
class Test2_Scanner {       
        public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);        //创建键盘录入对象
               
                //键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
                /*System.out.println("请输入第一个整数:");
                int x = sc.nextInt();                                        //将键盘录入的数据存储在x中
                System.out.println("请输入第二个整数:");
                int y = sc.nextInt();                                        //将键盘录入的数据存储在y中
                int sum = x + y;
                System.out.println(sum);*/
                //键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值
                System.out.println("请输入第一个整数:");
                int x = sc.nextInt();                                        //将键盘录入的数据存储在x中
                System.out.println("请输入第二个整数:");
                int y = sc.nextInt();                                        //将键盘录入的数据存储在y中
                int max = (x > y) ? x : y;                                //获取x和y中的最大值
                System.out.println("max = " + max);
        }
}


###03.10_Java语言基础(键盘录入的练习2)(掌握)
* A:案例演示
        * 键盘录入练习：键盘录入两个数据，比较这两个数据是否相等
* B:案例演示
        * 键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值

案例：
import java.util.Scanner;                                                        //导包
class Test3_Scanner {
        public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);                //创建键盘录入对象
                //键盘录入练习：键盘录入两个数据，比较这两个数据是否相等
                /*System.out.println("请输入第一个整数:");
                int x = sc.nextInt();                                                //将键盘录入的数据存储在x中
                System.out.println("请输入第二个整数:");
                int y = sc.nextInt();                                                //将键盘录入的数据存储在y中
                //boolean b = (x == y)? true : false;
                boolean b = (x == y);
                System.out.println(b);*/
                //键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值
                System.out.println("请输入第一个整数:");
                int x = sc.nextInt();                                                //将键盘录入的数据存储在x中
                System.out.println("请输入第二个整数:");
                int y = sc.nextInt();                                                //将键盘录入的数据存储在y中
                System.out.println("请输入第三个整数:");
                int z = sc.nextInt();                                                //将键盘录入的数据存储在y中
                //定义临时变量记录住比较出前两个变量中的最大值
                int temp = (x > y) ? x : y;
                //将比较后的结果与第三个变量中的值比较,比较出三个数中的最大值
                int max = (temp > z) ? temp : z;
                System.out.println(max);
        }
}

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2