【原】Java学习笔记004

package cn.temptation;

public class Sample01 {
    public static void main(String[] args) {
        // 运算符：对常量 或是 变量进行操作的符号
        // 分为：算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符
        
        // 1、算术运算符：+、-、*、/、%、++、--
        int i = 7;
        int j = 2;
        
        System.out.println(i + j);        // 9
        System.out.println(i - j);        // 5
        System.out.println(i * j);        // 14
        // int类型的变量 和 int类型的变量做除法，得到的结果是int类型
        System.out.println(i / j);        // 3
        
        // 要求：就想得到3.5的结果，怎么办？
        // 下面的写法不会得到3.5的结果，只会得到3.0的结果，因为只是声明了一个double类型的变量来接收int类型变量和int类型变量相除的结果
        // 对于相除的结果没有内容上的影响
        double result = i / j;
        System.out.println(result);                // 3.0
        System.out.println((double)(i / j));    // 3.0
        
        // 做一个尝试：使用double类型的字面量常量 和 int类型的字面量常量做除法，会得到double类型的字面量常量
        //                 即int类型的字面量常量在做除法时进行了类型提升
        System.out.println(7.0 / 2);            // 3.5
        
        // 类型的提升：把int类型的变量先和double类型的字面量常量1.0做乘法，让结果为double类型，再除以int类型的变量，得到的是double类型的结果
        System.out.println(i * 1.0 / j);        // 3.5
        
        System.out.println(i % j);                // 1
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // 减号 - 还可以做负号
        byte i = 1;
        // Type mismatch: cannot convert from int to byte
        // byte j = -i;
        byte j = (byte) -i;
        System.out.println(i);
        System.out.println(j);
        
        byte x = -128;
        byte y = (byte) -x;
        System.out.println(x);        //    -128
        System.out.println(y);        //  -128
        
        /*
         * x：        -128（没有超出byte范围）
         * -x：        128（int类型）：0000 0000 0000 0000 0000 0000 1000 0000
         * 因为强制类型转换为byte类型的变量y，所以要做截取
         * 
         * 补码：    1000 0000        符号位的1表明是负数
         * 反码：    1111 1111
         * 原码：    1000 0000
         */
        
        // 产生异常：java.lang.ArithmeticException: / by zero
//        int k = 123 / 0;
//        System.out.println(k);
        
        // 产生异常：java.lang.ArithmeticException: / by zero
//        int k = 0 / 0;
//        System.out.println(k);
        
//        double k = 123.45 / 2;
//        System.out.println(k);        // 61.725
//        
//        double m = 123.45 / 0;
//        System.out.println(m);        // Infinity（正无穷大）
//        
//        double n = -123.45 / 0;
//        System.out.println(n);        // -Infinity（负无穷大）
//        
//        double result1 = 0.0 / 0;
//        System.out.println(result1);        // NaN（Not a Number  不是一个数）
//        
//        double result2 = -0.0 / 0;
//        System.out.println(result2);        // NaN（Not a Number  不是一个数）
        
//        float k = 123.45F / 2;
//        System.out.println(k);        // 61.725
//        
//        float m = 123.45F / 0;
//        System.out.println(m);        // Infinity（正无穷大）
//        
//        float n = -123.45F / 0;
//        System.out.println(n);        // -Infinity（负无穷大）
//        
//        float result1 = 0.0F / 0;
//        System.out.println(result1);        // NaN（Not a Number  不是一个数）
//        
//        float result2 = -0.0F / 0;
//        System.out.println(result2);        // NaN（Not a Number  不是一个数）
        
        int result1 = 11 % 4;
        System.out.println(result1);        // 3
        
        double result2 = 11.0 % 3;
        System.out.println(result2);        // 2.0
        
        double result3 = 11.0 % 3.5;
        System.out.println(result3);        // 0.5
        
        // 产生异常：java.lang.ArithmeticException: / by zero
//        int result4 = 11 % 0;
//        System.out.println(result4);
        
        double result5 = 11.0 % 0;
        System.out.println(result5);        // NaN（Not a Number  不是一个数）
    }
}

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
        // ++ 自增运算符                  -- 自减运算符
        int i = 2;
        System.out.println(i);        // 2
        
        // 1、单独使用自增运算符：不论++放在需要自增的变量的后面还是前面，都会在操作后让变量的值自增1
        // 自增运算符放在需要自增的变量的后面
        // i++;
        // 自增运算符放在需要自增的变量的前面
//        ++i;
        
//        System.out.println(i);        // 3
        
        // 2、非单独使用自增运算符
        // 下句语句一上来先把i的值赋值给j，然后i自己做自增（先赋值再自增）
//        int j = i++;        // j = 2, i = 3
        // 下句语句一上来先i自己做自增，然后把i的值（自增后的值）赋值给j（先自增再赋值）
        int j = ++i;        // j = 3, i = 3
        
        System.out.println("j的值为：" + j);
        System.out.println("i的值为：" + i);
    }
}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
        // 关于自增的一道题
        int i = 2;
        int j = 3;
        
        j = i++;
        
        System.out.println("i的值为：" + i);    // 3
        System.out.println("j的值为：" + j); // 2
        
//        j = i++ + ++i+i*4;
        // 上句等价于
        j = (i++) + (++i) + (i * 4);
        /*
         * 计算过程：
         * i++这个表达式，此时i为3，首先是赋值，再让i自增，所以这个表达式(i++)的结果为3，i操作后的值为4
         * ++i这个表达式，此时i为4，首先让i自增，再赋值，所以i操作后的值为5，这个表达式(++i)的结果为5
         * i * 4这个表达式，此时i为5，进行乘法，所以这个表达式(i*4)的结果为20
         * 
         * 最后三个表达式的结果相加：3 + 5 + 20 = 28
         */
        
        System.out.println(j);
    }
}

package cn.temptation;

public class Sample05 {
    public static void main(String[] args) {
        // 加号 + 的用法：
        /*
         * 1、作为算术运算符的加号
         * 2、作为正数的符号 +
         * 3、作为字符串的连接符号
         */
        int result = 1 + 2;
        System.out.println(result);
        
        int x = +99;
        System.out.println(x);
        
        System.out.println("北京" + 2008);
    }
}

package cn.temptation;

public class Sample06 {
    public static void main(String[] args) {
        // 2、赋值运算符：=、+=、-=、*=、/=、%=
        
        // Java中的一个等号 = 表示的是将等号（赋值号）右侧的内容赋值给等号（赋值号）左侧的变量，习惯上称之为赋值号
        
        int i = 2;
        // 完整描述：把整型的字面量常量2 赋值给 整型类型的变量i
        // 赋值号左侧的部分称为声明
        // 赋值号右侧的部分称为赋值
        System.out.println(i);
        
        // 一行语句中声明多个变量
        int x, y;
        
        // 下句语句先把123赋值给变量y，再将y赋值给x，所以最后x和y的值均为123
        x = y = 123;
        
        System.out.println(x);
        System.out.println(y);
        
        // 以+=为例，表示的是将赋值号（+=）左侧的变量 和 右侧的内容按照=之前的运算符进行相应的运算，操作后的结果再赋值给左侧的变量
        int j = 3;
        System.out.println(j);        // 3
        // j += 4;
        // 上句等价于
        j = j + 4;
        System.out.println(j);        // 7
        
//        byte k = 5;
//        // Type mismatch: cannot convert from int to byte
//        k = k + 3;
//        System.out.println(k);
        
        // 对于非默认数据类型的数据，使用带有算术运算符的赋值运算符时，会自动进行强制类型转换
        byte k = 5;
//        k += 3;
        // 上句等价于
        k = (byte) (k + 3);
        System.out.println(k);
    }
}

package cn.temptation;

public class Sample07 {
    public static void main(String[] args) {
        // 3、比较运算符：==、!=、>、<、>=、<=
        
        // Java中使用 == 表示相等（内容相等）
        // 比较的结果必然是一个boolean类型的值
        int i = 2;
        int j = 3;
        int k = 2;
        
//        System.out.println(i == j);        // false
//        System.out.println(i == k);        // true
//        System.out.println(i + j == j + k);            // true
        // 上句等价于
//        System.out.println((i + j) == (j + k));        // true
        
        System.out.println(i != j);        // true
        System.out.println(i != k);        // false
        
        System.out.println(i > j);        // false
        System.out.println(i < j);        // true
        System.out.println(i >= j);        // false
        System.out.println(i <= j);        // true
        
        System.out.println(k <= k);        // true
    }
}

package cn.temptation;

public class Sample08 {
    public static void main(String[] args) {
        // 逻辑运算符：&、|、!、^、&&、||
        // 参与运算的变量或表达式的值均为boolean类型
        
        /*
         * &：逻辑与，有一个是false得到的结果就是false
         * |：逻辑或，有一个是true得到的结果就是true
         * !：逻辑非，颠倒黑白
         * ^：逻辑异或，类似吸铁石
         */
//        System.out.println(true & true);        // true
//        System.out.println(true & false);        // false
//        System.out.println(false & true);        // false
//        System.out.println(false & false);        // false
        
//        System.out.println(true | true);        // true
//        System.out.println(true | false);        // true
//        System.out.println(false | true);        // true
//        System.out.println(false | false);        // false
        
//        System.out.println(!true);                // false
//        System.out.println(!false);            // true
        
//        System.out.println(true ^ true);        // false
//        System.out.println(true ^ false);        // true
//        System.out.println(false ^ true);        // true
//        System.out.println(false ^ false);        // false
        
        /*
         * &&：逻辑与（聪明与/短路与）如果参与运算的第一个变量或表达式为false，得到的结果就是false，其他的变量或表达式就不去执行；如果多个逻辑与参与运算，以此类推
         * ||：逻辑或（聪明或/短路或）如果参与运算的第一个变量或表达式为true，得到的结果就是true，其他的变量或表达式就不去执行；如果多个逻辑或参与运算，以此类推
         */
//        System.out.println(true && true);        // true
//        System.out.println(true && false);        // false
//        // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
//        System.out.println(false && true);        // false
//        // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
//        System.out.println(false && false);    // false
        
        // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
        System.out.println(true || true);        // true
        // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
        System.out.println(true || false);        // true
        System.out.println(false || true);        // true
        System.out.println(false || false);    // false
        
        // 在实际的开发中，常用的是：!、^、&&、||
    }
}

package cn.temptation;

public class Sample09 {
    public static void main(String[] args) {
        // 结合自增 和 逻辑运算符的一道题
        int i = 2;
        int j = 3;
        
        System.out.println((++i == 2) && (j++ == 3));        // false
        // 因为++i先自增再赋值，表达式++i的结果为3，所以++i == 2这个表达式的结果为false
        // 又因为使用聪明与，第一个表达式为false，后续的表达式不会执行，所以i = 3， j = 3
        
        // 问：最终显示i和j的值为多少？
        System.out.println(i);            // 3
        System.out.println(j);            // 3
    }
}

package cn.temptation;

public class Sample10 {
    public static void main(String[] args) {
        // 位运算符：&、|、~、^、>>、>>>、<<
        /*
         * 规则：（在二进制中）操作的是补码
         * &：位与，进行操作的两个数的同一位上，有一个是0，该位运算的结果就是0
         * |：位或，进行操作的两个数的同一位上，有一个是1，该位运算的结果就是1
         * ~：位非，进行操作的数按位取反
         * ^：位异或，进行操作的两个数的同一位上，两个相同为0，两个不同为1
         */
//        System.out.println(2 & 3);        // 2
//        System.out.println(2 | 3);        // 3
//        System.out.println(~2);            // -3
//        System.out.println(2 ^ 3);        // 1
        /*
         * 2：0000 0010
         * 3：0000 0011
         * 
         * 2
         * 原码：0000 0000 0000 0000 0000 0000 0000 0010
         * 反码：0000 0000 0000 0000 0000 0000 0000 0010
         * 补码：0000 0000 0000 0000 0000 0000 0000 0010
         * 
         * ~2：（操作补码）
         * 补码：1111 1111 1111 1111 1111 1111 1111 1101
         * 反码：1111 1111 1111 1111 1111 1111 1111 1100
         * 原码：1000 0000 0000 0000 0000 0000 0000 0011
         */
        
        // 位异或^的用法：
        // 规律：一个数连续两次和另一个数做位异或运算，得到其本身的值
        // 可以应用在简单的加密解密中，连续两次进行位异或的那个数可以设置为密钥
        System.out.println(2 ^ 3 ^ 3);        // 2
        
        /*
         * <<：左移，左边的高位删除，右边的低位补0
         * >>：右移，因为左侧的最高位是符号位，所以要区分是0还是1：左侧的最高位是0，左侧补0；左侧的最高位是1，左侧补1
         * >>>：无符号右移，不论左侧的最高位是0还是1，左侧补0
         */
        System.out.println(2<<1);            // 4
        System.out.println(2>>1);            // 1
        System.out.println(-2>>1);            // -1
        System.out.println(-2>>>1);            // 2147483647
        /*
         * -2：
         * 原码：1000 0000 0000 0000 0000 0000 0000 0010
         * 反码：1111 1111 1111 1111 1111 1111 1111 1101
         * 补码：1111 1111 1111 1111 1111 1111 1111 1110
         * 
         * 右移1位操作（操作补码）
         * 补码：1111 1111 1111 1111 1111 1111 1111 1111
         * 反码：1111 1111 1111 1111 1111 1111 1111 1110
         * 原码：1000 0000 0000 0000 0000 0000 0000 0001
         * 
         * 无符号右移1位操作（操作补码）
         * 补码：0111 1111 1111 1111 1111 1111 1111 1111
         * 反码：0111 1111 1111 1111 1111 1111 1111 1111
         * 原码：0111 1111 1111 1111 1111 1111 1111 1111
         */
    }
}

package cn.temptation;

public class Sample11 {
    public static void main(String[] args) {
        // 依据参与运算的元素个数分类：
        // 1、一元运算符：!、~
        // 2、二元运算符：+、-、*、/、%、&、|、&&、||、^等等
        // 3、三元运算符：由两个符号组成的复合运算符       ? :
        
        // 三元运算符：只有一个
        // 格式：(比较表达式) ? (比较表达式为真值时，执行的内容) : (比较表达式为假值时，执行的内容);
        
        int i = 2;
        int j = 3;
        int result = ((i > j) ? i : j);
        System.out.println(result);
    }
}

package cn.temptation;

public class Sample12 {
    public static void main(String[] args) {
        // 需求：取得给定的两个数字中较大的一个（使用三元运算符来做）
//        int x = 28;
//        int y = 17;
//        int max = (x > y) ? x : y;
//        System.out.println(max);
        
        // 需求：取得给定的三个数字中最大的一个（使用三元运算来做）
        /*
         * 思路：
         * 1、要获取三个数字中最大的，先拿出两个数字比一比，先找出这两个数字中较大的一个
         * 2、拿着比较出来的较大的那个数字再和剩下的那个数字做比较，如果剩下的那个数字比它大，那么剩下的那个数字就是最大的
         *         否则，比较出来的较大的那个数字就是最大的
         */
        int a = 5;
        int b = 4;
        int c = 6;
        
        // 分步操作
//        // 1、要获取三个数字中最大的，先拿出两个数字比一比，先找出这两个数字中较大的一个
//        int temp = (a > b) ? a : b;
//        // 2、拿着比较出来的较大的那个数字再和剩下的那个数字做比较
//        int max = (temp > c) ? temp : c;
//        System.out.println("最大的数字为：" + max);
        
        // 如果就要在一行语句中写，如何实现？需要使用三元运算符的嵌套
        // 如下写法，在实际开发中不要这样写，可读性很差，纯炫技耳！
        int max = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
        System.out.println("最大的数字为：" + max);
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample13 {
    public static void main(String[] args) {
        // 需求：通过键盘的录入，把输入的数据赋值给变量（交互操作的需求）

        // 创建一个扫描器对象
        Scanner input = new Scanner(System.in);
        System.out.println("输入一个数字：");
        // 接收用户的键盘的录入，并赋值给声明的变量
        int i = input.nextInt();
        // 扫描器对象使用完毕后，关闭
        input.close();
        
        System.out.println("用户通过键盘录入的数字为：" + i);
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample14 {
    public static void main(String[] args) {
        // 需求：通过键盘录入三个数字，比较获取其中最大的一个

        // 声明三个变量来接收键盘录入的三个数字
        Scanner input = new Scanner(System.in);
        System.out.println("输入第一个数字：");
        int i = input.nextInt();
        System.out.println("输入第二个数字：");
        int j = input.nextInt();
        System.out.println("输入第三个数字：");
        int k = input.nextInt();
        input.close();

        // 分步操作
        int temp = (i > j) ? i : j;
        int max = (temp > k) ? temp : k;
        System.out.println("输入的数字：" + i + "," + j + "," + k + "中，最大的数字为：" + max);
    }
}