重学Java的第一章

1.写在前面

今年的行情很差，差到很多人都没有办法找到工作，博主也是一个菜逼，找了一家小破公司，导致我那段时间很迷茫，也是也很焦虑，思考了很多，觉得我自己学的已经够多了，但是每一次面试，博主都是没有好好的准备的，导致找到的工作也不是很好，现在这家公司也不是很好，领导天天PUA我，这次没有像之前一样，直接离职，博主知道现在的行情，都是混口饭。我开始反思，我发现我学的东西很多，都是没有串起来，导致我整个的知识体系也没有。那么就打碎掉吧。从头再来，不丢人。于是重学Java吧！玩了一年多了，突然发现重新捡起来学习，有点难！

2.为什么需要变量

由于我们是有基础的，不需要去了解什么Java的历史，如果你们想了解的话，可以去看看对应的Java的历史，博主这儿就不做过多的赘述。直接从变量开始，不管你们学过还是没有学过。我相信总有一些细节你们没有记住。

看到这个标题，你们第一时间想到了什么？为什么需要变量？我们都知道在计算机中所有的所有的数据都是通过二进制存储起来的。那么问题来了？这些数据是怎么存储的？怎么找到的？这儿博主想到了一句话，从汇编的一本书上看到的一句话**数据的两大的要素，一个是地址，还有一个就是长度。**这句话，博主这儿不做过多的解释，通过你们读取这篇文章，你们会有更多的体会。

回到刚才的问题，为什么需要变量？

• 一个程序就是一个世界 (一个程序对计算机来说表示一个世界)
• 变量是程序的基本组成单位（变量的组成的 类型 名称 值）

计算机程序的基本组成单位都是变量了，而且我们平时不管写什么程序都是需要变量了，而且计算机大部分的时候都是与数据进行打交道，而数据的载体是变量。那么不言而喻，变量的重要性了。

3.变(变化)量(值)的介绍

3.1概念

变量相当于内存中一个数据存储空间的表示， 你可以把变量看做是一个房间的门牌号， 通过门牌号我们可以找到房间， 而通过变量名可以访问到变量(值)。

3.2变量使用的基本步骤

声明变量 赋值

3.3简单的案例

package chapter03;

public class Var02 {
    //编写一个 main 方法
    public static void main(String[] args) {
        //记录人的信息
        int age = 30;
        double score = 88.9;
        char gender = '男';
        String name = "king";
        //输出信息, 快捷键
        System.out.println("人的信息如下:");
        System.out.println(name);
        System.out.println(age);
        System.out.println(score);
        System.out.println(gender);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.变量使用注意事项

1. 变量表示内存中的一个存储区域[不同的变量，类型不同，占用的空间大小不同]
2. 该区域有自己的名称[变量名]和类型[数据类型] 这句话就可以回到我们之前说的两大要素，就是地址，长度，其中的变量名我们可以简单的理解为变量名，长度我们可以简单的理解为类型，因为每一种数据的类型的长度都是不一样。因为计算机不知道你存的是什么东西，你只要给它一个地址，然后读取对应的地址的，同时从这个地址对应长度的字节，就能确定这个空间存的是什么东西了。
3. 变量必须先声明，后使用
4. 变量在同一个作用域内不能重名
5. 变量=变量名+值+数据类型

package chapter03;

public class VarDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        //变量必须先声明， 后使用, 即有顺序
        int a = 50;//int
        System.out.println(a);//50
        //该区域的数据/值可以在同一类型范围内不断变化
        //a = "jack"; //×
        a = 88; //对
        System.out.println(a);//88
        //变量在同一个作用域内不能重名
        //int a = 77;//错误
    }
}

class Dog {
    public static void main(String[] args) {
        int a = 666;//对
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5.程序中+号的使用

1. 当左右两边都是数值型时，则做加法运算。
2. 当左右两边有一方为字符串，则做拼接运算。
3. 运算顺序，是从左到右。

6.数据类型

上面的8大基本的数据类型，要烂熟于胸。至于范围后面学习对应的存储的方式再来和大家说为啥是这个范围。

7.整型的使用细节

1. Java各整数类型有固定的范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。
2. Java的整型常量默认为int型，声明long型常量须后加l或者L
3. Java程序中变量常声明为int型，除非不足以表示大数，才使用long
4. bit:计算机中的最小存储单位。byte：计算机中基本存储单元，1byte=8bit

package chapter03;

public class IntDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        //Java 的整型常量（具体值） 默认为 int 型， 声明 long 型常量须后加‘l’或‘L’
        int n1 = 1;//4 个字节
        //int n2 = 1L;//对不对?不对
        long n3 = 1L;//对
    }
}
1
2
3
4
5
6
7
8
9
10
11

8.浮点类型

1. 关于浮点数在机器中存放的形式的简单说明，浮点数=符号位+指数位+尾数位
2. 尾数部分可能丢失，造成精度损失(小数都是近似值)
3. 与整数类型类似，Java浮点类型也有固定的范围和字段长度，不受操作系统影响
4. Java的浮点类型的常量默认为double类型，声明float型常量，须后加’f’或‘F’
5. 浮点型常量有两种表示形式
   • 十进制数形式：如5.12 512.0f .512（必须有小数点）
   • 科学计数法形式：如5.12e2[5.12*10的2次方] 5.12E-2[5.12/10的2次方]
6. 通常情况下，应该使用double型，因为它比float型更精确。
7. 浮点数使用陷阱：2.7 和 8.1/3比较

package chapter03;

public class FloatDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        //Java 的浮点型常量(具体值)默认为 double 型， 声明 float 型常量， 须后加‘f’或‘F'
        //float num1 = 1.1; //对不对?错误
        float num2 = 1.1F; //对的
        double num3 = 1.1; //对
        double num4 = 1.1f; //对
        //十进制数形式： 如： 5.12 512.0f .512 (必须有小数点）
        double num5 = .123; //等价 0.123
        System.out.println(num5);
        //科学计数法形式:如： 5.12e2 [5.12 * 10 的 2 次方 ] 5.12E-2 []
        System.out.println(5.12e2);//512.0
        System.out.println(5.12E-2);//0.0512
        //通常情况下， 应该使用 double 型， 因为它比 float 型更精确。
        //[举例说明]double num9 = 2.1234567851;float num10 = 2.1234567851F;
        double num9 = 2.1234567851;
        float num10 = 2.1234567851F;
        System.out.println(num9);
        System.out.println(num10);
        //浮点数使用陷阱: 2.7 和 8.1 / 3 比较
        //看看一段代码
        double num11 = 2.7;
        double num12 = 2.7; //8.1 / 3; //2.7
        System.out.println(num11);//2.7
        System.out.println(num12);//接近 2.7 的一个小数， 而不是 2.7
        //得到一个重要的使用点: 当我们对运算结果是小数的进行相等判断是， 要小心
        //应该是以两个数的差值的绝对值， 在某个精度范围类判断
        if (num11 == num12) {
            System.out.println("num11 == num12 相等");
        }
        //正确的写法 , ctrl + / 注释快捷键, 再次输入就取消注释
        if (Math.abs(num11 - num12) < 0.000001) {
            System.out.println("差值非常小， 到我的规定精度， 认为相等...");
        }
        //可以通过 java API 来看 下一个视频介绍如何使用 API
        System.out.println(Math.abs(num11 - num12));
        //细节:如果是直接查询得的的小数或者直接赋值， 是可以判断相等
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

8.字符类型

1. 字符类型可以表示单个字符，字符类型是char,char是两个字节(可以存放汉字)，多个字符我们用字符串String
2. 字符常量是用单引号(‘’)括起来的单个字符
3. Java中还允许使用转义字符’'来将其后的字符转变为特殊字符型常量。
4. 在Java中，char的本质是一个整数，在输出时，是Unicode码对应的字符。
5. 可以直接给char赋一个整数，然后输出时，会按照对应的Unicode字符输出
6. char类型可以进行运算，相当于一个整数，因为它都对应有Unicode码

package chapter03;

public class CharDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        //在 java 中， char 的本质是一个整数， 在默认输出时， 是 unicode 码对应的字符
        //要输出对应的数字， 可以(int)字符
        char c1 = 97;
        System.out.println(c1); // a
        char c2 = 'a'; //输出'a' 对应的 数字
        System.out.println((int) c2);
        char c3 = '韩';
        System.out.println((int) c3);//38889
        char c4 = 38889;
        System.out.println(c4);//韩
        //char 类型是可以进行运算的， 相当于一个整数， 因为它都对应有 Unicode 码.
        System.out.println('a' + 10);//107
        //课堂小测试
        char c5 = 'b' + 1;//98+1==> 99
        System.out.println((int) c5); //99
        System.out.println(c5); //99->对应的字符->编码表 ASCII(规定好的)=>c
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

9.编码格式

1. ASCII(ASCII编码表 一个字节表示，一个128个字符，实际上一个字节可以表示256个字符，只用128个)
2. Unicode(Unicode 编码表 固定大小的编码 使用两个字节表示字符， 字母和汉字统一都是占用两个字节，这样浪费空间)
3. utf-8(编码表，大小可变的编码 字母使用1个字节，汉字使用3个字节)
4. gbk（可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节）
5. gb2312（可以表示汉字，gb2312 < gbk）
6. big5码(繁体中文，台湾，香港)

注意：这儿引出了一个问题，就是如果我们用的utf-8的编码，那么汉字就是占用三个字节，而char只占用两个字节，这个是怎么操作的呢？在Java文件中如果声明了char c = '中';，编译后生成的class文件会把中转化成Unicode的一种表现方式。

10.布尔类型

1. 布尔类型也叫boolean类型，boolean类型数据只允许取值true和false，无null
2. boolean类型占1个字节
3. boolean类型适用于逻辑运算，一般用于程序流程控制。

package chapter03;

public class Boolean01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        //演示判断成绩是否通过的案例
        //定义一个布尔变量
        boolean isPass = true;//
        if (isPass == true) {
            System.out.println("考试通过， 恭喜");
        } else {
            System.out.println("考试没有通过， 下次努力");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

11.基本数据类型的转换

11.1自动类型转换

当Java程序在进行赋值或者运算时，精度小的乐行自动转换为精度大的数据类型，这个就是自动类型转换。

这儿可能有一个疑问就是long不是8字节，而float是4个字节，为啥能自动转换呢？你如果看我前面的范围你会发现，float的范围会比long大，这是为什么呢？这需要了解计算机中的浮点数是怎么存的。

11.2自动类型转换注意和细节

1. 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
2. 当我们吧精度大的数据类型赋值给精度小的数据类型时，就会报错，反之就会进行自动类型转换。
3. byte short和char之间不会相互自动转换。
4. byte short char 他们三者可以计算，在计算时首先转换为int类型
5. boolean不参与转换
6. 自动提升原则：表达式结果的类型自动提升为操作数中最大的类型。

package chapter03;

//自动类型转换细节
public class AutoConvertDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        //细节 1： 有多种类型的数据混合运算时，
        //系统首先自动将所有数据转换成容量最大的那种数据类型， 然后再进行计算
        int n1 = 10; //ok
        //float d1 = n1 + 1.1;//错误 n1 + 1.1 => 结果类型是 double
        //double d1 = n1 + 1.1;//对 n1 + 1.1 => 结果类型是 double
        float d1 = n1 + 1.1F;//对 n1 + 1.1 => 结果类型是 float

        //细节 2: 当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，
        //就会报错， 反之就会进行自动类型转换。
        //
        //int n2 = 1.1;//错误 double -> int

        //细节 3: (byte, short) 和 char 之间不会相互自动转换
        //当把具体数赋给 byte 时， (1)先判断该数是否在 byte 范围内， 如果是就可以
        byte b1 = 10; //对 , -128-127
        // int n2 = 1; //n2 是 int
        // byte b2 = n2; //错误， 原因： 如果是变量赋值， 判断类型
        //
        // char c1 = b1; //错误， 原因 byte 不能自动转成 char
        //
        //

        //细节 4: byte， short， char 他们三者可以计算， 在计算时首先转换为 int 类型
        byte b2 = 1;
        byte b3 = 2;
        short s1 = 1;
        //short s2 = b2 + s1;//错, b2 + s1 => int
        int s2 = b2 + s1;//对, b2 + s1 => int
        //byte b4 = b2 + b3; //错误: b2 + b3 => int
        //
        //boolean 不参与转换
        boolean pass = true;
        //int num100 = pass;// boolean 不参与类型的自动转换
        //自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型
        //看一道题
        byte b4 = 1;
        short s3 = 100;
        int num200 = 1;
        float num300 = 1.1F;
        double num500 = b4 + s3 + num200 + num300; //float -> double
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

11.3强制类型转换

自动类型转换的逆过程， 将容量大的数据类型转换为容量小的数据类型。 使用时要加上强制转换符 ( )， 但可能造成
精度降低或溢出,格外要注意

1. 当进行数据的大小 从 大到小，就需要使用到强制转换
2. 强制符号只针对与最近的操作数有效，往往会使用小括号提升优先级
3. char类型可以保存int的常量值，但不能保存int的变量值，需要强转
4. byte和short char类型在进行运算时，当做int类型处理。

package chapter03;

public class ForceConvertDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        //演示强制类型转换
        //强转符号只针对于最近的操作数有效， 往往会使用小括号提升优先级
        //int x = (int)10*3.5+6*1.5;//编译错误： double -> int
        int x = (int) (10 * 3.5 + 6 * 1.5);// (int)44.0 -> 44
        System.out.println(x);//44
        char c1 = 100; //ok
        int m = 100; //ok
        //char c2 = m; //错误
        char c3 = (char) m; //ok
        System.out.println(c3);//100 对应的字符, d 字符
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

12.基本数据类型和String类型转换

1. 基本类型转String类型 将基本类型的值+""即可
2. String类型转成基本数据类型 通过基本类型的包装类调用parseXX方法就可以了。

13.写在最后

-> 44
System.out.println(x);//44
char c1 = 100; //ok
int m = 100; //ok
//char c2 = m; //错误
char c3 = (char) m; //ok
System.out.println(c3);//100 对应的字符, d 字符
}
}

## 12.基本数据类型和String类型转换

1. 基本类型转String类型 将基本类型的值+""即可
2. String类型转成基本数据类型 通过基本类型的包装类调用parseXX方法就可以了。

## 13.写在最后

这篇文章简单的介绍了一下Java的变量，就算我是一个做了几年的开发，但是有些细节还是不太记得了。还是有收获，查漏补缺吧。共勉。
1
2
3
4
5
6
7
8
9