【系统性扩展学习】了解回顾标识符、数据类型、数据类型转换、变量等知识点和实操。并了解运算原理和断点调试小技巧。【萌新友好版】

对于以下出现的一些标识符萌新们看不懂没关系，因为这是需要慢慢掌握的。对于前期的宝子们来说，只需要看懂简单常见的就行了，请跟着小编的脚步一步一步的来踩踏实吧。

public class Demo02 {
    public static void main(String[] args) {
        String str= "加油！" + "加油！！";  // 这里的+加号表示连接作用。此时str的值为"加油！加油！！"
        System.out.println(str);

        String str01 = "加油";
        String str05 = "我", str06 = "是" ,str07 = "程序猿";  // 单行定义多个同类型变量，不过这样书写不够规范。

        // 整数:java中整数默认类型是int。
        byte num01 = -128;  // byte取值范围在 -128 —— 127
        byte num02 = 127;
        short num03 = 2000;
        int num04 = 10;
        long num05 = 123L;  // =右边的整数默认为int类型，加上L表示将123转换为long类型。

        // 小数：浮点数
        double real_num01 = 118.110;  // 等号(赋值运算符)右边的只要带小数点，那么右边的实数(浮点数)就会默认为double类型。
        float real_num02 = 118.00f;  // 118.112在这里默认为double类型，末尾f(F也可以)表示将118.00转换成float类型。
        float real_num03 = 119.128F;  // 如果没有f那么=左边定义的是float类型，右边119.128是double类型，赋值语句就会报错。

        // 字符类型：字符类型只能且必须存储一个字符。占2个字节。
        char name = '我';  // 字符类型用''赋值，里面只能有一个字符，有两个会报错。
        char name_01 = 'a';  // char null = ''; 这一句字符为空会报错。

        // 字符串：String不是关键字，是一个类，是引用类型。
        String string = "中国";

        // 布尔值：只有true和false两个值，代表是和非。
        boolean flag = true;  // 理论上：布尔值仅占1位，就是二进制的0或1。
        System.out.println(flag);
    }
}

数据类型扩展：

public class Demo03 {
    public static void main(String[] args) {
        // 整数扩展：进制      二进制 0b      十进制     八进制 0       十六进制 0x    不同进制是以不同开头来表示的。如下：

        int i = 10;
        int i1 = 010;  // 八进制，逢八进一。
        int i3 = 0x10;  // 十六进制：逢十六进一。由 0~9 和 A~F 组成，F = 16。
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i3);
        System.out.println("==============================================");

        // 浮点数扩展：    银行业务怎么表示？钱
        // BigDecimal 数学工具类

        // float特点：    有限      离散     舍入误差     大约     接近但不等于
        // double
        // 因此最好完全避免使用浮点数进行比较

        float f = 0.1F;
        double d =1.0/10;
        System.out.println(f == d);  // false
        System.out.println(f);
        System.out.println(d);
        float d1 = 11111111111111111111111f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);  // true。因为超出float的有效精度了，d1和d2的保存截取内容相同。
        System.out.println("==============================================");

        // 字符扩展：

        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println(c2);
        System.out.println((int)c1);  // 强制转换
        System.out.println((int)c2);

        // 所有字符的本质是数字，字符类型占2个字节。
        // Unicode编码表：(97 = a, 65 = A)占2个字节，共有2的16次方 = 65536个字符(0 —— 65536)。【Excel最大长度也是65536行】
        // Unicode编码：U0000    UFFFF     每一个对应着不同的字符。
        // 对应int类型：   0      65536
        char c3 = '\u0061';  // '\u'表示Unicode编码，这一句表示将0061所对应的Unicode编码的字符赋值给了c3。

        System.out.println(c3); // a

        // 转义字符:
        // \t   制表符；\n   换行......
        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");

        System.out.println("==============================================");

        // 扩展：
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb);  // 输出：false

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);  // true

        // 布尔值扩展
        boolean flag = true;
        if(flag == true){}
        //      ||
        if(flag){}      // 两者相等，建议直接使用这一种。Less is More!代码要精简易读

    }
}

public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;  // 内存溢出。byte类型范围在 -128 —— 127。
        // 强制转换：(类型)变量名     从高-----低
        double d = i;
        // 自动转换：    从低-----高
        System.out.println(i);
        System.out.println(b);  // 输出：-128
        System.out.println(d);

        /*
        注意点：
        1. 不能把布尔值进行转换
        2. 不能把对象类型转换为不相干的类型
        3. 在把高容量转换为低容量的时候，强制转换
        4. 转换的时候可能存在内存溢出，或者精度问题！
         */
        System.out.println("====================================");
        System.out.println((int) 23.7);  // 输出：23
        System.out.println((int) -45.89f);  // 输出：-45

        System.out.println("====================================");
        char c ='a';
        int e = c +1;
        System.out.println((int) c);  // 输出：97
        System.out.println(e);
        System.out.println((char) e);  // 输出：b
    }
}

小知识点：

public class Demo06 {
    public static void main(String[] args) {
        // JDK7新特性：数字之间可以用下划线分割
        int money = 10_0000_0000;  // 输出：1000000000
        int years = 20;
        // 操作很大的数字时，注意溢出问题
        int total = money * years;
        System.out.println(total);  // 输出：-1474836480。计算溢出，超出int类型范围
        long total2 = money * years;  // money * years值默认为int,转换之前已经存在问题。
        System.out.println(total2);  // 输出：-1474836480。
        long total3 = money * ((long)years);  // 将years转换为long类型，和money的乘积也会为long类型，因此total3值正常。
        System.out.println(total3);  // 输出：20000000000

    }
}

public class Demo07 {
    public static void main(String[] args) {
//      int a = 1, b = 2 ,c =3;  不建议这样写
        int a = 1;
        int b = 2;
        int c = 3;  // 应该像这样，规范格式
        String neme = "大帅";
        char x = 'X';
        double pi = 3.14;
    }
}

public class Demo08 {  // 定义Demo08类

    // 类变量  static，从属于Demo08这个类。
    static double salary = 2500;

    // 实例变量：从属于对象。在Demo08这个类里面都能用。
    String name;  // 实例变量不同于局部变量，可以不用赋初始值。系统会赋予默认值。
    int age;
    char c;

    /*
    byte、short、int、long的默认值均为0。
    float的默认值为0.0f，double的默认值为0.0d。
    char的默认值为'\u0000'。即Unicode编码为0的字符，通常表示空字符。
    boolean默认值为false。
    除了基本类型，其他默认值都是null。
    */

    // main方法
    public static void main(String[] args) {

    // 局部变量：必须声明和赋初始化值。在方法内定义的变量就叫局部变量，且只能在该方法内使用。{}就代表范围
        int i = 10;
        char b;
        System.out.println(i);

        // 扩展：变量类型 变量 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);  // 输出0。int类型的默认值为0。
        System.out.println(demo08.name);  // 输出：null。String为引用类型，不是基本类型。
        System.out.println(demo08.c);  // 输出：空字符（通常是空格或不可见字符）
        // static 类变量
        System.out.println(salary);
    }

    // 如：其他方法
    public void add(){

    }
}

public class Demo09 {

    // static、final都是修饰符，修饰符的使用不区分前后。
    final double P = 3.14;
    final static double IP = 3.14;
    static final double PI = 3.14;
    public static final double PII = 3.14;  // public表示公共的，static表示静态的，final表示常量。

    public static void main(String[] args) {
        System.out.println(IP);
        System.out.println(PI);
        System.out.println(PII);
    }
}

小编认为理解Java编译器的运算规则有助于提高大家的编码质量和思维，有效减少代码bug。以下是小编当前收集到的一点知识扩展，在此分享给大家。前期的萌新看不懂没关系，编码是一个漫长的过程，重点在于保持学习。

public class Demo04 {
    public static void main(String[] args) {
        int a = 123;
        byte b = 123;
        short c = 123;
        /*
        扩展：
        Java中所有数据都有类型，而整数默认是int类型。因此上述等号(=，即赋值运算符)右边123数据类型是int类型。
        int类型的取值范围远比short、byte大。思考：这里为什么从大范围的数据转换成小范围的数据不需要显式(强制)转换呢？
        Java对于小范围数据转换成大范围数据Java编译器会自动类型转换。
        比如：byte--short--int--long--float--double。从左往右，是小范围数据转换成大范围数据。编译器会自动转换，不需要写强制转换。
        double可以精确存储(表示)所有long值。float范围可以表示所有long值，但精度有限，大long值会被近似存储(精度丢失)。
        如下：
         */
        int d = b;  // b的数据类型是byte，编译器会将b的值隐式转换为int类型，再赋值给a。
        int e = (int)b;
        /*
        那么关于上述的思考，为什么从int类型转换成范围比它小的byte、short类型不需要强制转换呢？
        因为Java编译器在编译常量时，有特殊的处理规则。
        Java允许将int类型的常量在编译时，隐式转换为short、byte或char，只要该常量值在目标类型的范围内。
        注意：只在常量时允许。比如 byte x = a;这就会报错，因为a是int变量。
         */
        char z = 120;
        System.out.println(z);  // 输出：x
        // 隐式转换是编译器自动完成且安全的，显式转换是手动操作且可能引发数据丢失或错误的。

        // 有趣点分享：
        double s = 1 / 3;  // s = 0.0。先是两个int类型进行运算，得出结果为0的int类型，然后转换赋值。
        double y = 1;
        double u = 3;
        double t = 0.44444444444444446;  // 6这一位已经超出精度范围，会被近似取值(四舍五入)。改变6的前一位为5来存储到变量t。
        System.out.println(s);
        System.out.println(y / 3);  // 输出：0.3333333333333333
        System.out.println(y / u);  // 输出：0.3333333333333333
        System.out.println(t);  // 输出：0.4444444444444445
        /*
        在Java中，所有的整数类型都有范围，包括byte、short、int和long。
        当你尝试将一个整数的最大值加1时，会发生溢出（overflow），导致数值变成该类型的最小值。
        这是因为计算机使用二进制补码（two's complement）来表示有符号整数，当数值超出其表示范围时，会发生环绕（wrap around）。
         */
        byte i = (byte)128;  // byte取值范围：-128 —— 127。溢出操作都需要显式地进行强制类型转换。
        System.out.println(i);  // 输出：-128
        byte o = (byte)129;
        System.out.println(o);  // 输出：-127
    }
}

double类型的精度：约15位十进制有效数字。

以下是关于Demo03这个类的简单断点调试：
断点调试能够有效的找出bug和看清代码的运行轨迹，比较重要，需要萌新们都能够掌握。

编码注重的是实践哦，在此提醒宝子们好好加油！！