【原】Java学习笔记003

package cn.temptation;

public class Sample01 {
    public static void main(String[] args) {
        System.out.println("第一个例子");
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // Java的基本数据类型
        // 分为四大类，共八种数据类型
        /*                        占用字节数
         * 1、整数类型
         * byte：    字节类型            1            -128~127
         * short：    短整型            2
         * int：        整型                4
         * long：    长整型            8
         * 
         * 2、浮点数类型
         * float：    单精度类型        4
         * double：    双精度类型        8
         * 
         * 3、字符类型
         * char：    字符类型            2
         * 
         * 4、布尔类型
         * boolean：    布尔类型            1
         */
        
        // 变量：在程序执行过程中发生变化的量
        
        // 思考：为什么要使用变量？全部都使用常量行不行？
//        System.out.println(123);
//        System.out.println(123);
//        System.out.println(123);
        
        // 现在要进行修改，不要显示123了，要显示456，那么需要把前面使用常量123的地方全部改为常量456
//        System.out.println(456);
//        System.out.println(456);
//        System.out.println(456);
        
        // 注意：使用变量是一种思想：通过封装变化来达到拥抱变化的结果，即在变化时，只需要修改变量赋值的地方，不需要修改变量使用的地方
        // int i = 123;
        // 变化时，只要修改变量赋值的地方
        // int i = 456;
        
        // 把变量使用的地方 和 变量赋值的地方 分离开
//        System.out.println(i);
//        System.out.println(i);
//        System.out.println(i);
        
        // 定义变量的格式：
        // 数据类型        变量名        =       初始化的值;
        
        byte i = 3;
        System.out.println(i);
        
        short j = 4;
        System.out.println(j);
        
        int k = 123;
        System.out.println(k);
        
        // Java中书写整型数字，不加说明，默认认为是int类型
        // The literal 12345678901 of type int is out of range
        // long m = 12345678901;
        // 要使用long类型，需要在数字后添加大写的L 或是 小写的l（因为小写的l和数字1容易混淆，所以使用大写的L）
        long m = 12345678901L;
        System.out.println(m);
        
        // Java中书写浮点书数字，不加说明，默认认为是double类型
        // Type mismatch: cannot convert from double to float
        // float x = 123.456;
        // 要使用float类型，需要在数字后添加大写的F 或是 小写的f（为了保持风格的一致，所以使用大写的F）
        float x = 123.456F;
        System.out.println(x);
        
        double y = 987.654;
        System.out.println(y);
        
        // 字符类型使用单引号把字符包含其中
        char z = 'a';
        System.out.println(z);
        
        // 布尔类型有两个特殊值：true 和 false
        boolean flag1 = true;
        boolean flag2 = false;
        System.out.println(flag1);
        System.out.println(flag2);
    }
}

package cn.temptation;

public class Sample03 {
//    int i = 123;
    
    public static void main(String[] args) {
        // 使用变量的注意事项：
        /*
         * 1、作用范围（作用域）：通过大括号来划定作用范围，变量不在该大括号内且没有其他的范围描述时，是无法使用的
         * 2、在同一作用域下，变量不能重复命名
         * 3、变量的初始化值：
         *         变量没有初始化就直接使用会语法出错
         *         要不在声明变量的时候就进行变量的初始化；要不就在使用的时候进行初始化
         */
//        int i = 123;
        // 在主函数之外定义int类型的变量i，在主函数中（大括号）中无法访问到
        // Cannot make a static reference to the non-static field i
//        System.out.println(i);
        
//        int i = 3;
//        System.out.println(i);
        // Duplicate local variable i
//        int i = 4;
//        System.out.println(i);
        
        // 只对变量进行声明但是不赋值
//        int i;
        // 对只声明但是不赋值的变量直接使用
        // The local variable i may not have been initialized
//        System.out.println(i);
        
        // 先做声明
//        int i;
        // 在使用前进行赋值
//        i = 5;
        // 再使用变量，这样没有语法问题
//        System.out.println(i);
        
        // 声明变量时并对变量进行初始化赋值（初始化）
//        int i = 2;
        
        // 如下写法语法没有问题，但是不建议这样写（可读性差）
//        int i = 2; int j = 3;
//        System.out.println(i);
//        System.out.println(j);
        
        // 如下写法也可以，但是不推荐这样写
//        int i = 2, j = 3;
//        System.out.println(i);
//        System.out.println(j);
        
        // 在一行语句中对多个变量进行声明是可以的，并且多个变量之间使用英文的逗号分隔开
        int i, j;
        // 在一行语句中对于声明好的多个变量进行赋值，不能使用英文的逗号分隔开进行赋值，而只能使用英文的分号分隔开进行赋值
        // Syntax error on token ",", ; expected
//        i = 2, j = 3;
        i = 2; j = 3;
        // 上句等价于
        i = 2;
        j = 3;
        System.out.println(i);
        System.out.println(j);
    }
}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
        // 两个int类型的变量做加法
//        int i = 2;
//        int j = 3;
//        int result = i + j;
//        System.out.println(result);
        
        // byte类型的变量 和 int类型的变量做加法
//        byte i = 2;
//        int j = 3;
//        int result = i + j;
//        System.out.println(result);
        
        // int类型的变量 和 int类型的变量做加法，得到的结果赋值给一个byte类型的变量
//        int i = 2;
//        int j = 3;
        // Type mismatch: cannot convert from int to byte
        // 赋值号右侧两个int类型的变量相加，得到的结果还是一个int类型的结果，把这个int类型的结果赋值给byte类型的变量，提示类型不匹配
//        byte result = i + j;
//        System.out.println(result);
        
        // byte类型的变量 和 int类型的变量做加法，得到的结果赋值给一个byte类型的变量
//        byte i = 2;
//        int j = 3;
        // Type mismatch: cannot convert from int to byte
        // 赋值号右侧byte类型的变量  和  int类型的变量相加，得到的结果还是一个int类型的结果（类型提升），把这个int类型的结果赋值给byte类型的变量，提示类型不匹配
//        byte result = i + j;
//        System.out.println(result);
        
        // 解决类型不匹配错误的方法：
        /*
         * 1、将结果的数据类型改为范围大的数据类型
         * 2、使用强制类型转换，注意可能会发生精度丢失的问题
         *         联想一下：小碗盛米，大锅里的米比较少的时候，倒入小碗中是没有问题的；大锅里的米比较多的时候，倒入小碗里就有问题了
         */
        
        // 强制类型转换的格式：(要转换为的数据类型)(被转换的数据内容);
        int i = 2;
        int j = 3;
        byte result = (byte)(i + j);
        System.out.println(result);
    }
}

package cn.temptation;

public class Sample05 {
    public static void main(String[] args) {
        // 字面量常量整数不加说明，默认是int类型
//        byte i = 127;
//        System.out.println(i);
        
//        byte i = (byte)127;
//        System.out.println(i);
        
        // Type mismatch: cannot convert from int to byte
//        byte j = 130;
//        System.out.println(j);
        
        byte j = (byte)130;
        System.out.println(j);        // -126
    }
}
/*
 * 原码、反码 和 补码
 * 规则：
 * 1、正数的原码、反码和补码都相同
 * 2、负数的反码和原码符号位相同，其他位取反；负数的补码  = 负数的反码 + 1;
 * 3、计算机在进行运算时，使用的是补码，最终显示出来的是原码
 * 
 * int类型的正整数130的原码：0000 0000 0000 0000 0000 0000 1000 0010
 * int类型的正整数130的反码：0000 0000 0000 0000 0000 0000 1000 0010
 * int类型的正整数130的补码：0000 0000 0000 0000 0000 0000 1000 0010
 * 
 * 强制类型转换做了截取
 * 
 * byte类型的           补码：1000 0010        最高位是符号位
 * byte类型的           反码：1000 0001    
 * byte类型的           原码：1111 1110        -126
 */

package cn.temptation;

public class Sample06 {
    public static void main(String[] args) {
        double i = 123.45;
        System.out.println(i);
        
        // 在单精度浮点数后添加F 和 对单精度浮点书进行强制类型转换为float类型，效果一致
//        float j = 987.65F;
        float j = (float) 987.65;
        System.out.println(j);
    }
}

package cn.temptation;

public class Sample07 {
    public static void main(String[] args) {
        // 定义两个byte类型的变量
//        byte i = 2;
//        byte j = 3;
        
        // Type mismatch: cannot convert from int to byte
        // 使用加号进行加法计算时，对于比int类型范围小的数据类型进行了类型提升
//        byte result = i + j;
//        byte result = (byte) (i + j);
//        System.out.println(result);
        
        // 第11行使用byte类型的变量相加提示语法错误，第16行使用int类型的字面量常量相加没有语法错误
        byte result = 2 + 3;
        
        // Type mismatch: cannot convert from int to byte
//        byte result = 2 + 126;
        
        System.out.println(result);
        
        // 注意：
        // 变量相加，先看变量的数据类型是否有问题
        // 常量相加，先看结果是否在被赋值的变量的数据类型范围内
    }
}

package cn.temptation;

public class Sample08 {
    public static void main(String[] args) {
        // char字符类型 和 整型存在转换的关系
        System.out.println('a');            // a
        
        char i = 'b';
        System.out.println(i);                // b
        
        // 把字符'c' 和 int类型的数字1做加法，加出来的结果赋值给char类型的变量j
        // 因为j的数据类型为char字符类型，所以输出的结果还是字符
        char j = 'c' + 1;
        System.out.println(j);                // d
        
        // 字符类型和int类型做加法，得到的结果是int类型
        System.out.println('c' + 1);        // 100
        
        // 字符类型和int类型做加法，得到的结果是int类型
        System.out.println('B' + 'e' + 'i' + 'J' + 'i' + 'n' + 'g' + 2008);        // 2672
        
        // 字符类型和字符类型做加法，得到的结果是int类型
        System.out.println('B' + 'e' + 'i' + 'J' + 'i' + 'n' + 'g');            // 664
        
        // 布尔类型不参与加法运算
        // The operator + is undefined for the argument type(s) boolean, int
//        System.out.println(true + 1);
        
//        boolean flag = false;
        // The operator + is undefined for the argument type(s) boolean, int
//        System.out.println(flag + 1);
    }
}