# JavaSE 基础 — Day01 笔记

> **日期**：2026-07-13  
> **项目**：`javaSE-260713-FirstJava`  
> **作者**：WanJL

---

## 一、Java 文件结构

一个 `.java` 源文件由两部分组成：

| 组成部分 | 说明 |
|---------|------|
| **Java 代码** | 真正参与运行的程序指令 |
| **Java 注释** | 写给程序员看的说明文字，**不参与编译和运行** |

---

## 二、Java 注释

Java 提供三种注释方式：

| 注释类型 | 语法 | 用途 |
|---------|------|------|
| **单行注释** | `// 注释内容` | 注释单行说明 |
| **多行注释** | `/* 注释内容 */` | 注释多行说明文字 |
| **文档注释** | `/** 注释内容 */` | 为类、方法生成 API 文档（JDK 自带 `javadoc` 工具） |

### 示例

```java
// 这是单行注释

/*
   这是
   多行注释
*/

/**
 * 这是文档注释
 * @author WanJl
 * @version 1.0
 */
```

---

## 三、核心概念 — 数据

Java 程序的核心是**数据**，数据分为不同**数据类型**。

### 1. 常量 / 字面量

直接写在代码中的具体值称为**字面量（Literal）**。

```java
25          // 整数字面量
"张三"      // 字符串字面量
7           // 整数字面量
```

### 2. 变量

变量是存放数据的**容器**，可以理解为贴了标签的盒子。

#### 定义变量的格式

```java
数据类型 变量名 = 变量值;
```

> 每一条 Java 语句以 **分号 `;`** 结束。

#### 示例

```java
int age = 25;
// int  → 数据类型（整数类型，integer 的缩写）
// age  → 变量名
// 25   → 字面量
```

---

## 四、Java 数据类型

Java 中的数据类型分为两大类：

### 1. 基本数据类型（Primitive Type）

> 从 C / C++ 继承而来，共 **4 类 8 种**。

| 类型 | 说明 | 位数（bit） | 字节数（byte） | 表示范围 |
|------|------|------------|---------------|---------|
| `byte` | 字节型 | 8 | 1 | -2^7 ~ 2^7-1 |
| `short` | 短整型 | 16 | 2 | -2^15 ~ 2^15-1 |
| `int` | 整型 | 32 | 4 | -2^31 ~ 2^31-1 |
| `long` | 长整型 | 64 | 8 | -2^63 ~ 2^63-1 |
| `float` | 单精度浮点型 | 32 | 4 | 约 ±3.4×10³⁸ |
| `double` | 双精度浮点型 | 64 | 8 | 约 ±1.8×10³⁰⁸ |
| `char` | 字符型 | 16 | 2 | 0 ~ 65535（Unicode） |
| `boolean` | 布尔型 | 1（JVM 中占 1 字节） | 1 | `true` / `false` |

> **分配内存的原则**：程序运行在内存中，不同大小的数据需要分配不同的内存空间。例如「一个人的年龄」和「太阳到地球的距离（米）」显然不能分配相同大小的内存。

#### 存储单位换算

| 单位 | 换算 |
|------|------|
| 1 bit（比特位） | 1 位二进制数（0 或 1） |
| 1 B（字节） | 8 bit |
| 1 KB | 1024 B |
| 1 MB | 1024 KB |
| 1 GB | 1024 MB |
| 1 TB | 1024 GB |

> ⚠️ 计算机最小的存储单元是 **bit**，但最小的**分配单元**是 **byte**（1 字节 = 8 bit）。好比烧烤店 1 串 3 元，但至少 5 串起卖。

### 2. 引用数据类型（Reference Type）

> 面向对象语言特有的类型。Java 中除了 8 种基本数据类型，其余**全部**属于引用数据类型。

包括：
- Java 类（`class`）
- Java 接口（`interface`）
- Java 数组（`[]`）
- Java 枚举（`enum`）
- Java 注解（`@interface`）

> 后续课程会详细讲解引用类型。

### 3. 基本数据类型注意事项（特殊规则）

```java
// 特殊 1：long 类型赋值时，整数值末尾要加 L 或 l（推荐大写 L）
long distance = 10000000000L;

// 特殊 2：float 类型赋值时，小数值末尾要加 F 或 f
float price = 19.99F;

// 特殊 3：char 类型必须使用单引号 '' 括起来，且只能有 1 个字符
char gender = '男';

// 特殊 4：boolean 类型值只能是 true 或 false
boolean isPass = true;
```

### 4. 基本数据类型 vs 引用数据类型

Java 中除了 8 种基本数据类型，其余全部是引用数据类型。两者在底层有着本质区别：

| 维度 | 基本数据类型 | 引用数据类型 |
|------|------------|-------------|
| **存什么** | 直接存"值" | 存的是数据在内存中分配的**空间地址值** |
| **默认值** | `0` / `0.0` / `false` | `null`（空） |
| **赋值行为** | 直接复制值，值与值之间互相独立 | 复制的是**地址值**，多个引用可能指向同一对象 |
| **比较方式** | 比较的是值（内容） | 比较的是地址（`==` 默认比较地址） |

> 💡 **一句话总结**：基本类型存的是"东西本身"，引用类型存的是"东西放在哪里的门牌号"。

#### 典型引用类型：String（字符串）

```java
String name = "张三";
```

> ⚠️ **重要**：`String` **不是** Java 关键字（keyword），它是 Java 官方提供的类，属于引用数据类型。
>
> 所有引用数据类型的命名都遵循**大驼峰命名法（PascalCase）**：每个单词的首字母都大写。
>
> 例如：`StringBuffer`、`MyClass`、`StudentName`

#### 课堂练习：个人简历变量定义

根据注释中的要求，为以下个人信息选择合适的数据类型并定义变量：

| 信息 | 推荐数据类型 | 说明 |
|------|------------|------|
| 姓名 | `String` | 字符串 |
| 年龄 | `int` | 整数 |
| 学号 | `String` 或 `long` | 学号可能含前导零，推荐 String |
| 性别 | `char` 或 `String` | 单字符可用 `char` |
| 身高（cm） | `double` 或 `int` | 小数用 `double` |
| 体重（kg） | `double` | 小数用 `double` |
| 学校 | `String` | 字符串 |
| 专业 | `String` | 字符串 |
| 班级 | `String` | 字符串 |
| 爱好 | `String` | 字符串 |

```java
// 示例：
String name = "张三";
System.out.println("我叫：" + name);
```

### 5. 基本数据类型转换

> 数值类型（除 `boolean` 外）之间可以相互转换，分为**自动转换**和**强制转换**两种。

#### 自动转换（隐式转换 / Widening）

把表示范围**小**的类型的变量，直接赋值给表示范围**大**的类型的变量，可以自动完成。

**转换方向**（箭头方向为自动转换方向）：

```
byte → short → int → long → float → double
```

> 就像把一瓶 500ml 的水倒进一个 1L 的瓶子里，完全装得下。

```java
byte  a = 120;
short b = a;   // byte → short（自动）
int   c = b;   // short → int（自动）
long  d = c;   // int → long（自动）
float f = d;   // long → float（自动）
double dd = f; // float → double（自动）
```

#### 强制转换（显式转换 / Narrowing）

把表示范围**大**的类型的值，赋值给表示范围**小**的类型的变量，需要使用**强制转换运算符**。

**语法格式：**

```java
目标类型 变量名2 = (目标类型) 变量1;
```

> 强制转换可能丢失精度，分两种情况：
> - 能装得下：1L 瓶里有 300ml 水 → 倒进 500ml 的瓶子 ✅
> - 装不下：1L 瓶里有 600ml 水 → 倒进 500ml 的瓶子 ❌（数据溢出）

```java
// 示例 1：double → int（小数截断，不是四舍五入）
double pi = 3.94;
int n = (int) pi;       // n 的值是 3，丢失了小数部分
System.out.println(n);

// 示例 2：int → byte（数据溢出）
int n2 = 128;
byte b2 = (byte) n2;    // byte 最大值是 127，128 会溢出
System.out.println(b2); // 输出 -128
```

**int 128 → byte 的转换过程：**

```
1. int 的 128（十进制）→ 32 位二进制：
   0000 0000 0000 0000 0000 0000 1000 0000

2. 转换为 byte（8 位），直接砍掉高位（左边 24 位）：
   1000 0000

3. 二进制中，最左边是符号位：
   0 → 正数，1 → 负数
   所以 1000 0000 对应十进制 -128
```

### 6. 表达式提升与编码表

#### 表达式提升

`byte`、`short`、`char` 参与算术运算时，会自动提升为 `int` 类型。

```java
byte a = 15;
short b = 20;

// byte c1 = a + b;   // ❌ 编译错误：a + b 结果是 int
// short c2 = a + b;  // ❌ 编译错误：a + b 结果是 int
int c3 = a + b;        // ✅ 正确
```

#### 整数除法截断

两个整数相除，结果直接截断小数部分，**不会四舍五入**。

```java
System.out.println(10 / 3);    // 输出 3（截断小数）
System.out.println(10 / 3.0);  // 输出 3.3333333333333335（浮点数除法）
```

#### char 与 int 的关系

`char` 本质上是数值类型，可以与 `int` 相互转换：

```java
char cc = 'A';
int d1 = cc + 6;        // 'A' 的 ASCII 码是 65，65 + 6 = 71
System.out.println(d1);  // 输出 71

char c6 = 97;            // 直接为 char 赋整数值
System.out.println(c6);  // 输出 'a'（97 对应 ASCII 表的 'a'）
```

> Java 中 8 种基本数据类型除了 `boolean`，其余 7 种都属于**数值类型**，都可以转换为数字。

#### 编程语言的演变

```
机器语言（二进制）→ 汇编（单词缩写）→ 高级语言（C / C++ / Java ...）
```

计算机底层只能识别二进制，为了方便人类读写，逐渐发展出汇编和高级语言。

#### 编码与解码

| 概念 | 方向 | 说明 |
|------|------|------|
| **编码（Encode）** | 字符 → 二进制数 | 把人类可读的字符映射为计算机识别的二进制 |
| **解码（Decode）** | 二进制数 → 字符 | 把二进制映射回人类可读的字符 |

#### 常见编码表（字符集）

| 编码表 | 说明 |
|--------|------|
| **ASCII** | 美国标准信息交换码，使用 **1 字节（8 位）** 存放对照表，共 **256 个字符**（-128 ~ 127） |
| **GB-2312 / GBK** | 中国国家标准简体中文字符集 |
| **Unicode** | 通用字符编码标准，基于 **2 字节（16 位）** 设计，可表示 **65536**（256×256）个字符 |
| **UTF-8** | Unicode 的一种变长编码实现，互联网最常用的字符集（中国大陆常用编码） |

### 7. 类型推断 `var`（JDK 10+）

> 从 **JDK 10** 开始，Java 新增了**局部变量类型推断**，使用 `var` 关键字声明变量，由编译器自动推断类型。

```java
var name = "张三";  // 推断为 String
var age = 25;       // 推断为 int
var gender = '男';  // 推断为 char
var score = 85.6;   // 推断为 double
```

**本质说明：**

- `var` 是**编译时语法糖**（syntactic sugar），编译后变量仍有确定的静态类型
- **不影响运行性能**，编译后 `var` 会被替换为实际类型
- 只能在**局部变量**（方法内部）使用，不能用于成员变量、方法参数等

> ⚠️ 注意：Java 仍然是**强类型语言**——定义变量必须先指定类型，变量值必须符合类型要求。`var` 只是让编译器替你写类型，类型约束依然存在。

---

## 五、输出语句

```java
System.out.println(输出的内容);
```

| 关键字 | 含义 |
|--------|------|
| `System` | 系统 |
| `out` | 输出 |
| `print` | 打印 |
| `ln` | 换行（等价于 `\n`） |

> **快捷输入**：在 IntelliJ IDEA 中输入 `sout` + `Tab` 可直接生成。

---

## 六、程序入口 — main 方法

```java
public static void main(String[] args) {
    // 代码写在这里才能执行
}
```

- `main` 方法是 Java 程序的**运行入口**
- 所有可执行的代码必须放在 `main` 方法内部
- **快捷输入**：在 IntelliJ IDEA 中输入 `psvm` + `Tab`

---

## 七、变量命名规则

| 规则 | 说明 |
|------|------|
| ① 允许的字符 | 字母（a~z、A~Z）、数字（0~9）、美元符号 `$`、下划线 `_` |
| ② 大小写敏感 | `age` 和 `Age` 是两个不同的变量 |
| ③ 禁止关键字 | 不能使用 Java 关键字/保留字（如 `public`、`static`、`void`、`class` 等） |
| ④ 驼峰命名法 | **小驼峰**：第一个单词首字母小写，后续单词首字母大写（如 `myName`） |

---

## 八、完整代码示例

### Demo01.java — 概念总览

```java
public class Demo01 {
    // 单行注释

    /*
        多行注释
    */

    /**
     * 文档注释
     */

    // 此处仅为概念说明，无 main 方法，不能独立运行
}
```

### Demo02.java — 变量与输出实战

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo02
 * @create 2026/7/13
 */
public class Demo02 {
    public static void main(String[] args) {
        // 1. 定义变量
        int age = 24;

        // 2. 输出变量
        System.out.println(age);
    }
}
```

### Main.java — 默认入口模板

```java
public class Main {
    public static void main(String[] args) {
        System.out.printf("Hello and welcome!");

        for (int i = 1; i <= 5; i++) {
            System.out.println("i = " + i);
        }
    }
}
```

### Demo03.java — 数据类型实战

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo03
 * @create 2026/7/13
 */
public class Demo03 {
    public static void main(String[] args) {
        // 创建各种基本数据类型的变量并输出
        int a = 15;
        System.out.println(a);

        // 特殊 1：long 类型要在整数值后面加 L 或 l
        // 特殊 2：float 类型要在小数后面加 F 或 f
        // 特殊 3：char 类型的值必须使用单引号，且只能是 1 个字符
        // 特殊 4：boolean 类型的值只能是 true 或 false
    }
}
```

### Demo04.java — 基本类型 vs 引用类型 & String

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo04
 * @create 2026/7/13
 */
public class Demo04 {
    public static void main(String[] args) {
        /*
            引用数据类型

            基本数据类型                  引用数据类型
存什么       直接存"值"                    存的数据在内存中分配的空间的地址值
默认值       0/0.0/false                  null
赋值         直接复制值，值跟值之间是独立的    复制的是地址值
比较         比较的是值                     比较的是地址

            非常典型的引用数据类型
            字符串     String 类型
            注意：String类型不是关键字，String的首字母大写
            （所有的引用数据类型都采用大驼峰命名）
                StringBuffer    MyClass     StudentName
         */

        /*
            练习：定义变量，输出一份个人简历，包含：
            姓名、年龄、学号、性别、身高、体重、学校、专业、班级、爱好
            为这些变量设置符合实际情况的数据类型
         */
        String name = "张三";
        System.out.println("我叫：" + name);
    }
}
```

### Demo05.java — 基本数据类型转换

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo05
 * @description 基本数据类型的转换
 * @create 2026/7/13
 */
public class Demo05 {
    public static void main(String[] args) {
        // ========== 自动转换 ==========
        // 小范围 → 大范围，自动完成
        byte a = 120;
        short b = a;    // byte → short
        int c = b;      // short → int
        long d = c;     // int → long
        float f = d;    // long → float
        double dd = f;  // float → double

        // ========== 强制转换 ==========
        // 大范围 → 小范围，需要强制转换运算符，可能丢失精度

        // 示例 1：double → int（小数截断）
        double pi = 3.94;
        int n = (int) pi;   // double → int
        System.out.println(n);  // 3（直接截断小数，不是四舍五入）

        // 示例 2：int → byte（数据溢出）
        int n2 = 128;
        byte b2 = (byte) n2;    // int → byte，byte 最大值 127
        System.out.println(b2); // -128（溢出导致）
        /*
            转换过程：
            1. int 128 → 32位二进制：
               0000 0000 0000 0000 0000 0000 1000 0000
            2. 截取低8位 → byte：
               1000 0000（最左边是符号位，1 表示负数）
            3. 1000 0000 二进制 → 十进制 -128
         */
    }
}
```

### Demo06.java — 表达式提升与编码表

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo06
 * @description 表达式提升
 * @create 2026/7/13
 */
public class Demo06 {
    public static void main(String[] args) {
        // ========== 表达式提升 ==========
        // byte/short/char 参与运算时自动提升为 int
        byte a = 15;
        short b = 20;
        // byte c1 = a + b;    // ❌ 编译错误
        // short c2 = a + b;   // ❌ 编译错误
        int c3 = a + b;        // ✅ 正确

        // ========== 整数除法截断 ==========
        System.out.println(10 / 3);    // 3（截断）
        System.out.println(10 / 3.0);  // 3.3333...

        // ========== char 与 int 转换 ==========
        char cc = 'A';
        int d1 = cc + 6;   // 'A'的ASCII码65 + 6 = 71
        System.out.println(d1);  // 71

        // 直接为 char 赋整数值
        char c6 = 97;
        System.out.println(c6);  // 'a'
    }
}
```

### Demo07.java — 类型推断 var（JDK 10+）

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo07
 * @description java的类型推断 var (JDK10+)
 * @create 2026/7/13
 */
public class Demo07 {
    public static void main(String[] args) {
        /*
            JDK10以上，新增了类型推断
            之前的Java属于强类型语言
                - 定义变量的时候，必须先指定类型
                - 变量值必须要符合类型的要求
                int a = 10;
                int b = "张三"; // 报错
         */
        var name = "张三";
        var age = 25;
        var gender = '男';
        var score = 85.6;

        // var 属于编译时语法糖，不影响运行性能
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        System.out.println(score);
    }
}
```

### Demo08.java — Git 版本控制入门

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo08
 * @description git 下载、安装及使用
 * @create 2026/7/13
 */
public class Demo08 {
    /*
    Git: 代码版本控制工具
    是现在互联网公司进行软件开发时最常用的一种多人协作开发工具，
    可以帮助管理软件项目。

    比如：公司有3个开发小组，每个小组有5个人。
    共同开发一个项目。15个人写代码都是不同的代码。
    完成后，需要各个小组的组长进行审核，完成再给项目经理审核以及合并到一个项目中。

    下载：https://git-scm.com/install/windows

    公司会搭建自己的仓库（代码托管平台：GitHub、Gitee、GitLab、Gogs）

    协作流程：
        1. 新员工从公司的代码托管平台克隆（clone）需要开发的项目
        2. 员工A开始写自己的代码，员工B也开始写自己的代码
        3. 员工A写完后，先去仓库中拉取最新的代码，如果没有冲突，
           就添加到自己的本地仓库并合并
        4. 员工A提交代码到远程仓库
        5. 员工B写完后，发现远程仓库的代码领先了自己的代码，
           就需要拉取最新代码并合并，如果发现冲突（如A和B改了同一个文件），
           就需要判断和取舍——是合并到一起，还是舍弃谁的代码。
           完成操作后，再把代码提交并推送到远程仓库

    好处：
        1. 方便多人协作编写同一个项目
        2. 如果不小心删除了文件，或者写完发现有错误，
           可以一键恢复到最初版

    安装：一路 next

    配置用户名和邮箱：
    git config --global user.name "你的名字"
    git config --global user.email "你的邮箱@example.com"

    配置换行符处理（Windows 推荐）：
    git config --global core.autocrlf true

    查看配置：
    git config user.name
    git config user.email
     */
}
```

## 九、随堂练习要点

1. 使用 `psvm` 快速生成 `main` 方法
2. 使用 `sout` 快速生成 `System.out.println()`
3. 理解 `//` 注释的内容不会被执行
4. 变量的定义必须遵循命名规则
5. 每条 Java 语句以 `;` 结尾
6. 牢记 **4 类 8 种**基本数据类型：`byte`、`short`、`int`、`long`、`float`、`double`、`char`、`boolean`
7. 区分基本数据类型与引用数据类型的 4 大区别（存什么、默认值、赋值、比较）
8. 掌握基本数据类型的 4 条特殊赋值规则（`L`、`F`、单引号、`true/false`）
9. 理解 bit（位）与 byte（字节）的关系及存储单位换算
10. 记住 `String` 是引用数据类型，**不是关键字**，采用大驼峰命名
11. **个人简历练习**：为姓名、年龄、学号、性别、身高、体重、学校、专业、班级、爱好选择合适的数据类型并输出
12. 掌握**自动转换**方向：`byte → short → int → long → float → double`
13. 掌握**强制转换**语法：`(目标类型) 变量`，理解精度丢失和溢出
14. `byte`、`short`、`char` 参与运算自动提升为 `int`
15. 整数除法结果直接**截断小数**，不是四舍五入
16. `char` 本质是数值类型，可查询 **ASCII 码表** 与 `int` 相互转换
17. 区分**编码**（字符→二进制）与**解码**（二进制→字符），了解常见字符集（ASCII、GBK、Unicode、UTF-8）
18. 了解 `var` 类型推断（JDK 10+）：编译时语法糖，不影响运行性能，只能在局部变量使用
19. Java 仍然是**强类型语言**，`var` 只是让编译器替你写类型，类型约束依然存在
20. 理解 Git 的**多人协作流程**：clone → 开发 → pull → 合并 → commit → push
21. 掌握 Git 初始配置：`git config --global user.name` 和 `user.email`

---

## 十、拓展阅读

| 概念 | 说明 |
|------|------|
| 关键字（Keyword） | Java 预留的具有特殊含义的单词（如 `public`、`class`、`static`、`void`、`int`） |
| 保留字（Reserved Word） | 暂未使用但预留的单词（如 `goto`、`const`） |
| 标识符（Identifier） | 程序员自定义的名称（类名、方法名、变量名等） |

---

## 十一、Git 版本控制入门

> Git 是目前互联网公司最流行的**代码版本控制工具**，用于多人协作开发时的代码管理。

### 1. 什么是 Git？

Git 是一个**分布式版本控制系统**，可以记录每次代码的变更，支持多人并行开发、历史回溯、分支管理等功能。

### 2. 为什么需要 Git？

| 场景 | 问题 | Git 的解决方案 |
|------|------|---------------|
| 多人协作 | 15 人修改同一个项目，手动合并工作量巨大 | 自动合并 + 冲突标记 |
| 代码误删 | 不小心删除了重要文件 | 一键回退到历史版本 |
| 版本回溯 | 改完后发现错误，想回到最初版 | `git reset` / `git revert` |

### 3. 常见代码托管平台

| 平台 | 说明 |
|------|------|
| **GitHub** | 全球最大的代码托管平台（微软旗下） |
| **Gitee（码云）** | 中国本土化的代码托管平台 |
| **GitLab** | 支持私有部署的企业级平台 |
| **Gogs** | 轻量级的自助 Git 服务 |

### 4. 多人协作流程

```
① 员工入职 → 分配账号 → 从远程仓库 clone 项目
② 员工 A 开始写代码，员工 B 也开始写代码
③ 员工 A 写完 → 先 pull 拉取远程最新代码 → 合并到本地
④ 若无冲突 → 员工 A commit + push 到远程仓库
⑤ 员工 B 写完 → 发现远程已领先本地 → 先 pull 拉取
    → 若有冲突（A 和 B 改了同一文件）→ 人工判断取舍
    → 合并完成 → commit + push
```

### 5. Git 安装与初始配置

**下载地址：** [https://git-scm.com/install/windows](https://git-scm.com/install/windows)

安装一路 `Next` 即可。

#### 配置用户名和邮箱（必须）

```bash
git config --global user.name "你的名字"
git config --global user.email "你的邮箱@example.com"

# 示例
git config --global user.name "WanJL"
git config --global user.email "506667090@qq.com"
```

#### 配置换行符（Windows 推荐）

```bash
git config --global core.autocrlf true
```

#### 验证配置

```bash
git config user.name
git config user.email
```
