第一章：注释

1.1 概述

• 注释就是对代码的解释和说明。
• 注释的目的是让人们能够更加轻松的了解代码，为代码添加注释，是十分必要的，它不会影响程序的编译和执行。

1.2 Java 中的注释

• Java 中的注释有 单行注释 、 多行注释 和 文档注释 三种。
• 单行注释：以 // 开头，以 换行 结束，格式如下：

// 注释内容

• 多行注释：以 /* 开头，以 */ 结尾，格式如下：

/* 
    注释内容
*/

• 文档注释：以 /** 开头，以 */ 结尾，格式如下：

/**
    注释内容
*/

• javadoc 命令可以抽取每个类、方法中的文档注释，生成 API 手册。

• 示例：

package day02;
/**
 * 这里是一个文档注释，通常包括对类或方法的介绍，还有作者、日期等信息。
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-07-29 22:09
 */
public class HelloWorld {
    /*
        多行注释：注释内容可以分很多行编写。
        注意：多行注释不能嵌套，嵌套会导致多行注释提前结束。
        main函数是整个程序的入口。
        main函数的声明格式是固定的。
        每一个类中最多只有一个main函数。
     */
    public static void main(String[] args) {
        // 单行注释：在命令行窗口打印一句话
        // 单行注释仅对当前行有效
        System.out.println("Hello World");
    }
}

第二章：关键字

2.1 概述

• 关键字是指在程序中，Java 已经定义好的单词，具有特殊含义。
• 关键字的特点：全都是 小写字母 。

2.2 Java 中的关键字

注意：

• 关键字一共50个，其中 const 和 goto 是保留字。
• true 、 false 和 null 看起来像关键字，但从技术角度，它们是特殊的布尔值和空值。

第三章：标识符

3.1 概述

• 简单的讲，凡是程序员自己命名的部分都可以称为标识符。换言之，给类、变量、方法、包等命名的字符序列就是标识符。

3.2 标识符的命名规则（必须遵守）

• 规则是硬性规定，一旦违反，程序就会在编译过程中报错。

• ① Java 中的标识符只能使用 26 个英文字母大小写，0~9 的数字，下划线 _ 和美元符号 $ 。

• ② 不能使用 Java 的关键字或保留字和特殊值。
• ③ 数字不能开头。
• ④ 不能包含空格。
• ⑤ 严格区分大小写。

3.3 标识符的命名规范

• 规范是柔性规范：违反规范，不会导致编译报错，但是如果不遵守基本的规范，可能会被大家鄙视。

• ① 见名知意。

• ② 类名、接口名等：每个单词的首字母都大写，形式：XxxYyyZxx 。
• ③ 变量、方法名等：从第二个单词开始首字母大写，其余字母小写，形式：xxxYyyZzz 。
• ④ 包名等：每一个单词都小写，单词之间使用点 . 分隔，形式：com.github 。
• ⑤ 常量名等：每一个单词都大写，单词之间使用下划线 _ 分隔，形式：XXX_YYY_ZZZ 。

第四章：初识数据类型

4.1 数据类型分类

• Java 中的数据类型分为两大类：
  • 基本数据类型：整型 、浮点类型 、字符类型 、布尔类型 。
  • 引用数据类型：类 、数组 、接口 。

4.2 基本数据类型

• 四类八种数据类型。

Java 中的默认类型：整数类型是 int 、浮点类型是 double 。

• 常量整数值：
  • 赋值给 byte，只要在 byte 范围内即可。
  • 赋值给 short，只要在 short 范围内即可。
  • 赋值给 int，只要在 int 范围内即可。
  • 赋值给 long，在 int 范围内的，可以加 L 也可以不加 L ，会自动升级为 long ，如果数字超过了 int 范围，必须加 L 。
• 小数常量值：
  • 无论多大，不加 F ，就是 double 类型。

第五章：常量

5.1 概述

• 常量指的是在程序执行的过程中，其值不可以发生改变的量。

5.2 常量的分类

• 自定义常量：通过 final 关键字定义。
• 字面值常量： | 字面值常量 | 举例 | | —- | —- | | 字符串常量 | “HelloWorld” | | 整数常量 | 12，-23 | | 浮点常量 | 12.34 | | 字符常量 | ‘a’，’0’，’沙’ | | 布尔常量 | true，false | | 空常量 | null |

• ①如何理解 字面 ？
• 我们看到的字面，就是数据本身，字面含义就是数据。
• ②对照 变量 来理解 字面量 。
• int a = 10; // 这里的变量 a 不代表 a 这个字符，它代表一个等于 10 的整数。
• 'a' // 这里的 ‘a’ 就是字面常量，它就是按照字面意思，代表 ‘a’ 这个字符。

注意事项：

• 字符常量，单引号里面有且仅有一个字符。
• 空常量，不可以在输出语句中直接打印。

• 示例：

package day02;
/**
 * 常量
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-07-31 10:40
 */
public class ConstantDemo {
    public static void main(String[] args) {
        // 字符串常量
        System.out.println("HelloWorld"); // 普通字符串
        System.out.println("a"); // 只包含一个字符的字符串
        System.out.println(""); // 空字符串
        // 字符常量
        System.out.println('a'); // 字符
        System.out.println('许'); // 字符
        System.out.println('大'); // 字符
        System.out.println('仙'); // 字符
        // 整数常量
        System.out.println(12); // 普通整数：正数
        System.out.println(-12); // 普通整数：负数
        System.out.println(220000000000000000L); //整数常量默认是int类型，如果超过这个范围，需要加L，转换为long类型
        // 布尔类型常量
        System.out.println(true);
        System.out.println(false);
        // 浮点类型常量
        System.out.println(3.14F); //单精度浮点类型常量
        System.out.println(3.14); //双精度浮点类型常量，可以加d或D，如果不写，默认就是双精度浮点类型常量
    }
}

第六章：变量

6.1 变量的概念

• 变量：在程序执行的过程中，其值可以发生改变的量。

6.2 变量的作用

• 变量的作用：用来存储数据，代表内存的一块存储区域，这块内存中的值是可以改变的。

6.3 变量的三要素

• 数据类型。
• 变量名。
• 值。

6.4 变量的作用域

• 概念：一个变量的有效范围。
• 变量必须在有效范围内使用。

• 具体范围：在 Java 语言中，变量的作用域就是它所在的一组 {} 。

• 错误示例：

public class VariableDemo{
    public void method(){
        {
            boolean flag = true;
        }
        System.out.println(flag);// 此处代码有问题
    }
}

6.5 变量使用的注意事项

• ① 先声明后使用。
• ② 在使用之前必须初始化（看情况，如果是类属性，系统会根据其数据类型，自动赋予初始化值）。
• ③ 变量有作用域。
• ④ 在同一个作用域中不能有同样的变量名，换言之，一个变量在作用域中只能使用一次。

6.6 变量的声明、赋值和使用语法

6.6.1 变量的声明语法

• 语法：

数据类型 变量名;

• 示例：

package day02;
/**
 * 变量
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-07-31 13:22
 */
public class VariableDemo {
    public static void main(String[] args) {
        // 声明变量
        int age;
        String name;
        double weight;
        char gender;
        boolean isMarry;
    }
}

6.6.2 变量的赋值语法

• 语法：

变量名 = 值;

• 示例：

package day02;
/**
 * 变量
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-07-31 13:22
 */
public class VariableDemo {
    public static void main(String[] args) {
        // 声明变量
        int age;
        String name;
        double weight;
        char gender;
        boolean isMarry;
        // 赋值
        age = 18;
        name = "许大仙";
        weight = 80.20;
        gender = '男';
        isMarry = false;
    }
}

6.6.3 变量的使用语法

• 语法：

通过变量名直接引用

• 示例：

package day02;
/**
 * 变量
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-07-31 13:22
 */
public class VariableDemo {
    public static void main(String[] args) {
        // 声明变量
        int age;
        String name;
        double weight;
        char gender;
        boolean isMarry;
        // 赋值
        age = 18;
        name = "许大仙";
        weight = 80.20;
        gender = '男';
        isMarry = false;
        // 变量的使用
        System.out.println(age);
        System.out.println(name);
        System.out.println(weight);
        System.out.println(gender);
        System.out.println(isMarry);
    }
}

第七章：两种常见的输出语句

• 换行输出语句：输出内容，完毕后进行换行，格式如下：

System.out.println("输出内容");

• 直接输出语句：输出内容，完毕后不做任何处理，格式如下：

System.out.print("输出内容");

注意事项：

• ① 换行输出语句，括号内可以什么都不写，只做换行处理。
• ② 直接输出语句，括号内什么都不写，直接报错。
• ③ 如果输出语句的括号内有多向内容，那么必须使用 + 连接起来。
• ④ 如果某些内容想要原样输出，就用 "" 引起来；如果想要输出变量中额内容，则不要将变量名用 "" 引起来。

• 示例：

package day02;
/**
 * 打印输出语句
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-07-31 15:13
 */
public class PrintDemo {
    public static void main(String[] args) {
        // 带有换行效果的输出
        System.out.println("Hello Java");
        // 不带有换行效果的输出
        System.out.print("Hello Java");
        System.out.print("Hello Java");
        // 调用print()函数的时候，不传参数，编译直接报错
        // System.out.print();
        // "age"是一个字面量，也可以说是一个字符串常量
        System.out.println("age");
        int age = 18;
        // age是一个变量，在打印语句中会输出这个变量的值
        System.out.println(age);
        // 输出很多内容的时候，可以使用 + 做字符串连接
        System.out.println("age = " + age);
    }
}

第八章：计算机是如何存储数据的？

8.1 概述

• 计算机世界只有二进制，那么在计算机中存储和运算所有的数据都要转为二进制，包括数字、字符、图片、声音和视频等。

8.2 进制（了解）

8.2.1 进制的分类

• ① 十进制：
  • 数字组成：0~9 。
  • 进位规则：逢十进一。
• ② 二进制：
  • 数字组成：0~1 。
  • 进位规则：逢二进一。
• ③ 八进制：很少使用
  • 数字组成：0~7 。
  • 进位规则：逢八进一。
  • 和二进制的换算规则：每三位二进制是一位八进制。
• ④ 十六进制：
  • 数字组成：0~9 、A~F 。
  • 进位规则：逢十六进一。
  • 和二进制的换算规则：每四位二进制是一位十六进制。

8.2.2 进制的换算

8.2.3 在代码中如何表示四种进制的值（了解）

• 十进制：正常表示

System.out.println(10);

• 二进制：0b 或 0B 开头

System.out.println(0B10);

• 八进制：0 开头

System.out.println(010);

• 十六进制：0x 或 0X 开头

System.out.println(0X10);

8.3 计算机中存储单位

• 字节（Byte）：是计算机信息技术用于计量存储容器的一种计量单位， 1Byte 等于 8bit 。
• 位（bit）：是数据存储的最小单位，也就是二进制。二进制数系统中，每个 0 或 1 就是一个位，叫做 bit ，其中 8bit 就是 1Byte 。
• 转换关系：
  • 1 Byte = 8 bit。
  • 1 KB = 1024 Byte。
  • 1 MB = 1024 KB。
  • 1 GB = 1024 MB。
  • 1 TB = 1024 GB。
  • ……

8.4 Java 的基本数据类型的存储范围

8.4.1 整型系列

• ① byte：字节类型
  • 占内存：1 Byte 。
  • 存储范围： -128 ~ 127 。
• ② short：短整型类型
  • 占内存：2 Byte 。
  • 存储范围： -32768 ~ 32767 。
• ③ int：整型
  • 占内存：4 Byte 。
  • 存储范围：-2^31 ~ 2^31-1 。
• ④ long：整型
  • 占内存：8 Byte 。
  • 存储范围：-2^63 ~ 2^63-1 。

注意：如果要表示某个超过 int 范围的常量整数就是 long 类型，那么需要在数字后面加 L 。

8.4.2 浮点型系列

• ① float ：单精度浮点型

  • 占内存：4 Byte 。
  • 精度：科学计数法的小数点后6~7位 。

    注意：如果要表示某个常量小数是 float 类型，那么需要在数字后面加 f 或 F ，否则就是 double 类型。

• ② double ：双精度浮点型

  • 占内存：8 Byte 。
  • 精度：科学计数法的小数点后15~16位 。

8.4.3 单字符类型

• char ：占内存 2 Byte 。

8.4.4 布尔类型

• boolean ：只能存储 true 或 false 。

注意：虽然计算机底层使用 0 或 1 表示 false 或 true ，但是在代码中不能给 boolean 类型的变量赋值 0 或 1 ，只能赋值 true 或 false 。

8.5 如何存储数据

8.5.1 概述

• Java 中使用的字符集是：Unicode 编码集。

8.5.2 编码表

• 在计算机的内部都是二进制的 0 和 1 的数据，如何让计算机可以直接识别人类文字的功能，就产生了编码表的概念。简而言之，编码表就是将人类的文字和一个十进制数进行对应起来形成一张表格，如下所示： | 字符 | 数值 | | —- | —- | | 0 | 48 | | A | 65 | | a | 97 |

• 将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表 ASCII（ American Standard Code for Information Interchange 美国标准信息交换码）。
• Unicode (统一码、万国码)是计算机科学领域里的一项业界标准，包括字符集、编码方案等。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。

8.5.3 字符常量的几种表示方式

• ① 一个字符：'a' 、'b' 等。
• ② 转义字符：将一个字符通过在前面添加 \ 符号，让它从自己原本的含义，转变为新的含义。 | 转义字符 | 描述 | | —- | —- | | \\n | 换行 | | \\r | 回车 | | \\t | tab键 | | \\\\ | \\ | | \\" | " | | \\' | ' | | \\b | 删除键backspace |

• ③ \u 字符的 Unicode 编码值的十六进制。例如：'\u8bb8' 代表了许。
• ④ 直接给 char 类型变量赋值十进制的 0~65536 之间的 Unicode 编码值。例如：'a' 的编码值是 97 。

第九章：基本数据类型转换

9.1 概述

• 在 Java 程序中，不同的基本数据类型的值经常需要进行互相转换，Java 语言所提供的七种数值类型之间可以相互转换，基本数据类型转换有两种方式：自动类型转换 和 强制类型转换 。

9.2 自动类型转换（隐式类型转换）

• 自动类型转换的概念：将 取值范围小的类型 自动提升为 取值范围大的类型 。
• 基本数据类型的转换规则如下所示：

• 自动类型转换的场景：
• ① 当将存储范围小的值（常量值、变量值、表示式计算的结果值）赋值给存储范围大的变量时：

int i = 'A'; //char自动升级为int

double d = 10; // int自动升级为double

byte b = 127; // 右边的整数常量值必须在 -128 ~ 127 范围内

long num = 12345678; // 右边的整数常量如果在int范围内，编译和运行都可以通过，这里涉及到数据类型转换

long bigNum = 1234567898103433433L; // 右边的整数常量值如果超过int范围，必须加L，否则编译不通过

• ② 当存储范围小的数据类型和存储范围大的数据类型一起混合运算时，会先转换为存储范围大的数据类型，然后再计算：

int i = 10;
byte b = 10;
double d = 10;
double sum = i + b + d;
System.out.println(sum); // 混合运算，升级为double

• ③ 当 byte 、short 、char 数据类型进行算术运算的时候，会按照 int 类型处理：

byte b1 = 1;
byte b2 = 2;
// byte b3 = b1 + b2; // 编译报错，b1 + b2 自动升级为int

char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2); // 113

• ④ boolean 类型不参与。

9.3 强制类型转换（显示类型转换）

• 强制类型转换：将 取值范围大的类型 强制转换成 取值范围小的类型 。
• 语法：

数据类型 变量名 = (数据类型)被强制转换值;

注意：强制类型转换可能会损失精度或溢出。

• 强制类型转换的场景：
• ① 当将存储范围大的值（常量值、变量值、表示式计算的结果值）赋值给存储范围小的变量时：

 int i = (int) 3.14; // 强制类型转换，损失精度

double d = 1.2;
int num = (int) d; // 损失精度

int i = 200;
byte b = (byte) i;
System.out.println("b = " + b); // 溢出 -56

• ② boolean 类型不参与。
• ③ 当某个值想要提升数据类型的时候，也可以使用强制数据类型：

int i = 1;
int j = 2;
double d = (double) i / j;
System.out.println(d);

注意：③ 场景下的强制类型转换是没有风险的。

9.4 特殊的数据类型转换

• ① 任意数据类型的数据和 String 类型进行 + 运算的时候，结果一定是 String 类型。

System.out.println("" + 1 + 2); //12

• ② String 类型不能强制类型转换，转为其他类型：

String str = "123";
int num = (int)str;// 错误

String str = "123";
int num = Integer.parseInt(str);// 正确