Java基础语法01-05

默海笑
4 阅读14分钟

01 Java 基础语法 + 注释

一、注释（写代码必用）

1. 单行注释

// 这是单行注释，只对这一行有效

2. 多行注释

/*
  这是多行注释
  可以写很多行
  中间内容都不会被执行
*/

3. 文档注释（生成说明文档用）

/**
 * 文档注释，一般写在类、方法上面
 * 可以被工具提取成 API 文档
 */

Java基础02：标识符和关键字

核心重点：掌握关键字的特性、标识符的命名规则，避免编写代码时出现语法错误，小白必看必记。

一、关键字（Java内置，不可乱用）

关键字是Java语言预先定义好的、具有特定含义的单词，全部小写，不能作为变量名、类名、方法名使用。

1. 常用关键字（必记）

// 类和方法相关
public、class、static、void

// 数据类型相关
int、double、String、char、boolean

// 流程控制相关
if、else、for、while、break、continue

// 其他常用
new、return、null、true、false

2. 关键字核心注意事项

  • 全部小写，比如不能写Public、Class（会报错）；
  • 无自定义关键字，Java官方固定，不能自己创造；
  • 部分单词看似像关键字（如main），但其实不是，可作为标识符（但不推荐）。

二、标识符（自定义命名，有规则）

标识符是我们自己定义的名称，用于给类、变量、方法、文件夹等命名，必须遵循以下规则（违反则编译报错）。

1. 标识符命名规则（必须遵守）

// 正确示例
int studentAge = 20;
public class Student {}
public void study() {}

// 错误示例（标注原因）
int 123age; // 不能以数字开头
int student#Age; // 不能包含特殊符号（除_和$）
int class; // 不能使用关键字
int 学生年龄; // 不推荐中文（可编译，但易出错、不规范）
  • 由字母（A-Z、a-z）、数字（0-9）、下划线（_）、美元符号（$）组成；
  • 不能以数字开头；
  • 不能使用Java关键字；
  • 区分大小写（比如student和Student是两个不同的标识符）；
  • 无长度限制，但建议简洁、有意义。

2. 标识符命名规范（推荐遵守，提升可读性）

  • 类名：首字母大写，后面每个单词首字母也大写（帕斯卡命名法），如：HelloWorld、Student；
  • 变量名、方法名：首字母小写，后面每个单词首字母大写（驼峰命名法），如：userName、getScore；
  • 常量名：全部大写，单词之间用下划线连接，如：MAX_AGE、PI；
  • 避免使用中文、拼音（推荐英文，如student比xuesheng更规范）。

三、易错点总结

  • 关键字≠标识符：关键字是Java内置，标识符是自定义；
  • 命名时先看“规则”（必须遵守），再看“规范”（推荐遵守）；
  • 常见错误：用关键字命名、以数字开头、包含特殊符号。

Java基础03：数据类型讲解

核心重点：Java是强类型语言，变量声明时必须指定数据类型，否则会报错。掌握数据类型的分类、取值范围及使用场景，是编写正确Java代码的基础，小白必记必练。

一、数据类型整体分类

Java数据类型分为两大类，核心区别在于是否直接存储数据值：

  • 基本数据类型：直接存储数据本身，占用内存固定，效率高（8种，重点掌握）；
  • 引用数据类型：存储数据的内存地址，占用内存不固定（如String、数组、类等，后续详解）。

关键提醒：基本数据类型是基础，日常写代码（变量、运算）用得最多，先重点掌握8种基本类型。

二、8种基本数据类型（重点）

8种基本数据类型分为4大类：整数型、浮点型、字符型、布尔型，每类对应不同的取值范围和用途，具体如下：

1. 整数型（存储整数，无小数）

用于存储正整数、负整数和0，根据取值范围不同，分为4种，优先使用int（最常用）：

// 正确声明（常用写法）
int age = 20;          // 最常用，取值范围足够日常使用
long phone = 13800138000L; // long类型必须加L/l（推荐大写L，避免和1混淆）
byte num1 = 127;       // 取值范围小，仅用于节省内存
short num2 = 32767;    // 取值范围介于byte和int之间
  • byte：取值范围 -128 ~ 127，占用1字节；
  • short：取值范围 -32768 ~ 32767，占用2字节；
  • int（常用）：取值范围 -2147483648 ~ 2147483647，占用4字节；
  • long：取值范围极大，占用8字节，声明时必须加L/l。

2. 浮点型（存储小数，有精度差异）

用于存储带小数的数值，分为float和double，优先使用double（精度更高，更常用）：

// 正确声明
double score = 99.5;   // 最常用，精度高
float weight = 52.3F;  // float类型必须加F/f（推荐大写F）

// 注意：浮点型存在精度误差，不适合精确计算（如金钱）
double a = 0.1;
double b = 0.2;
System.out.println(a + b); // 输出0.30000000000000004（而非0.3）
  • float：单精度，占用4字节，声明时必须加F/f，精度较低；
  • double（常用）：双精度，占用8字节，精度是float的2倍，日常使用首选。

3. 字符型（存储单个字符）

用于存储单个字符（字母、数字、符号），仅占2字节，声明时用单引号（''）包裹：

// 正确声明
char c1 = 'A';         // 单个字母
char c2 = '6';         // 单个数字
char c3 = '！';        // 单个符号

// 错误示例
// char c4 = "A"; // 不能用双引号（双引号是字符串）
// char c5 = 'AB'; // 不能存储多个字符

补充：字符型本质是存储对应的ASCII码（如'A'对应65，'a'对应97），可以参与数字运算。

4. 布尔型（存储真假）

用于判断条件（真/假），仅占1字节，取值只有两个：true（真）、false（假），常用于if、while等判断语句：

// 正确声明
boolean flag = true;   // 真
boolean isPass = false;// 假

// 常用场景（结合后续流程控制）
if (isPass) {
    System.out.println("考试通过");
} else {
    System.out.println("考试未通过");
}

三、基本数据类型使用注意事项

  • 声明变量时，数据类型必须和赋值内容匹配（如int不能赋值小数，char不能赋值多个字符）；
  • long和float类型声明时，必须加后缀（L/l、F/f），否则会报错；
  • 浮点型存在精度误差，精确计算（如金额）需使用专门的类（如BigDecimal，后续讲解）；
  • 基本数据类型有默认值（如int默认0，boolean默认false），但局部变量（方法内的变量）必须赋值后才能使用。

四、基本数据类型 vs 引用数据类型（简单区分）

  • 基本数据类型：存储具体值（如int a = 10，存储的是10本身）；
  • 引用数据类型：存储内存地址（如String name = "张三"，存储的是"张三"所在的内存地址）；
  • 常见引用数据类型：String（字符串）、数组、类（如Student）、接口等。

补充：String虽然是字符串（多个字符），但它是引用数据类型，不是基本数据类型，后续会单独详解String的使用。

字节、位、字符（结合 Java 数据类型，小白易懂版）

三者是计算机中表示数据大小的核心单位，关系：位（最小）→ 字节 → 字符，结合 Java 场景具体说明：

1. 位（bit，缩写 b）
  • 最基础、最小的存储单位，只能表示 0 或 1（计算机底层二进制）。
  • 例：1 个二进制数字（0/1）就是 1 位，8 位 = 1 字节。
  • Java 中无直接对应变量类型，是所有数据存储的底层基础（如 byte 占用 8 位，本质是 8 个 0/1 的组合）。
2. 字节（Byte，缩写 B）

  • 计算机基本存储单位，1 字节 = 8 位（固定换算）。

  • 用途：衡量数据占用内存大小，Java 中基本数据类型的内存占用均以字节为单位：

    • byte：1 字节（8 位）、short：2 字节（16 位）、int：4 字节（32 位）、long：8 字节（64 位）
    • char：2 字节（16 位）、float：4 字节、double：8 字节、boolean：1 字节
3. 字符（Char）

  • 用于表示单个文字 / 符号（如 'A'、'6'、'！'），是 “人类可识别的最小单位”。

  • 与字节的关系：取决于编码（Java 默认 UTF-8 编码）：

    • 英文 / 数字 / 符号：1 字符 = 1 字节（如 'A' → 1 字节 = 8 位）
    • 中文：1 字符 = 3 字节（如 ' 张' → 3 字节 = 24 位）

  • Java 中 char 类型专门存储单个字符，固定占用 2 字节（无论中英文，适配 Unicode 编码）。

一句话总结

  • 位：最小单位（0/1），底层基础；
  • 字节：基本存储单位（1B=8b），衡量内存占用；
  • 字符：人类可识别的单个符号，大小由编码决定。

Java基础04：数据类型扩展

二、核心知识点（重点记忆）

1. 整数类型拓展（面试基础考点）

  • 二进制：前缀 0b（例：0b10 → 对应十进制2）
  • 八进制：前缀 0（例：010 → 对应十进制8）
  • 十六进制：前缀 0x（例：0x10 → 对应十进制16，09、AF表示）
  • 十进制：无特殊前缀（常规书写）

2. 浮点类型拓展（重点易错点）

  • 特性：float、double 是 有限、离散、舍入误差 的，非精确值
  • 易错点：不能用 == 直接判断两个浮点数是否相等（会出现精度偏差）
  • 解决方案：高精度场景（如金融计算），使用 BigDecimal 类

3. 字符类型拓展

  • 本质：所有字符底层都是数字，可通过强制类型转换获取编码值（例：'a' → 97，'中' → 对应Unicode编码）
  • 编码标准：采用 Unicode 编码，占2个字节，可表示0~65536个字符
  • 特殊写法：可用 \u+编码值 定义字符（例：\u0061 → 'a'）
  • 常用转义字符：\t（制表符）、\n（换行符）

4. 布尔类型拓展（代码规范）

  • 规范写法：if (flag) 优于 if (flag == true)（精简、符合开发规范）
  • 核心：布尔值仅表示“真/假”，无需多余判断

5. 引用类型小补充（String为例）

  • new String("abc") 创建的对象，用== 比较的是 内存地址，而非内容
  • 结论：两个内容相同的 new String 对象，用 == 比较结果为 false

三、高频面试题（必背）

  1. 问：为什么浮点数不能用于金融计算？答：float、double 存在舍入误差，无法精确表示十进制小数，会造成精度丢失。
  2. 问：Java中字符类型的本质是什么？答：本质是数字，基于Unicode编码，可与整数相互转换。
  3. 问：布尔类型作为判断条件时，推荐哪种写法？答：推荐精简写法 if (flag)，而非 if (flag == true)。
  4. 问：Java中整数的不同进制如何表示？答：二进制前缀0b、八进制前缀0、十六进制前缀0x，十进制无前缀。
  5. 问：== 对基本类型和引用类型的比较有什么区别？答：基本类型比较“值”，引用类型比较“内存地址”。

Java基础05：类型转换 学习笔记

核心前提

Java 是强类型语言，不同数据类型进行赋值、运算时，需要通过类型转换完成类型适配，运算中不同类型数据会先转为同一类型再计算。 基本数据类型取值范围（低→高）：byte < short < char < int < long < float < double，其中 float 虽为 32 位，优先级高于 64 位的 long，原因是小数优先级大于整数。

一、隐式转换（自动类型提升）

1. 定义

无需手动编写代码，Java 编译器自动将取值范围小的类型转换为取值范围大的类型，转换过程安全，无数据丢失 / 溢出。

2. 核心规则

  • 基础转换：小范围类型向大范围类型自动转换，如byte→int、long→double。
  • 特殊规则：byte、short、char三种类型无论是否同类型运算，都会先自动提升为int，再进行计算。
  • 混合运算：多种类型混合运算时，所有数据会自动转为操作数中范围最大的类型，再计算。

3. 重要注意

byte、short、char三者之间不会相互自动转换，如byte b=10; char c=b;会编译报错。

4. 代码示例

// 示例1：基础自动转换
byte a = 10;
int b = a; // byte自动转int

// 示例2：byte/short/char运算自动提升为int
short c = 20;
char d = 'A'; // Unicode值65
int e = c + d; // 结果85，c和d先转int再运算

// 示例3：混合运算自动提升为最大类型
int n1 = 10;
double d1 = n1 + 1.1; // n1自动转double，结果11.1

二、强制转换（显式类型转换）

1. 定义

需要手动编写代码指定目标类型，将取值范围大的类型转换为取值范围小的类型，转换可能导致数据溢出或精度丢失，需谨慎使用。

2. 语法格式

目标类型 变量名 = (目标类型) 原变量/值;

3. 核心规则

  • 仅适用于基本数据类型，引用类型转换为向下转型，逻辑不同。
  • 强转符号仅对最近的操作数有效，需用小括号提升表达式优先级。
  • 仅当原类型值在目标类型取值范围内时，强转才安全，否则结果不可控。

4. 代码示例

// 示例1：安全强转（值在目标范围）
int a = 100;
byte b = (byte) a; // 结果100，无丢失

// 示例2：数据溢出（值超出目标范围）
int c = 300;
byte d = (byte) c; // byte范围-128~127，结果44，溢出

// 示例3：精度丢失（浮点转整数，舍弃小数）
double e = 12.9;
int f = (int) e; // 结果12

// 示例4：强转符号的优先级
double a = 3.5;
double b = 2.5;
double c1 = (int)a + b; // 仅a强转int，结果5.5
int c2 = (int)(a + b); // 表达式整体强转int，结果6

三、隐式转换与强制转换对比

对比维度隐式转换强制转换
转换方向小范围 → 大范围大范围 → 小范围
手动干预编译器自动完成，无需代码需手动写(目标类型)
数据安全安全，无丢失 / 溢出可能溢出、丢失精度
适用场景赋值、运算的自动类型适配明确需要缩小类型（如节省内存）

四、类型转换关键注意点

  1. boolean类型不能与任何其他类型进行转换，如boolean flag = 1;编译报错。

  2. 不能把对象类型转换为不相干的类型，与基本数据类型转换逻辑不同。

  3. 高容量转低容量必须使用强制转换，且需提前确认值在目标范围。

  4. char类型可隐式接收在 0~65535 范围内的 int 常量，但接收 int 变量时，无论值是否在范围，都必须强转。

    1. char c1 = 65; // 合法，隐式转'A'
int num = 65;
char c2 = (char)num; // 必须强转，否则报错

五、经典问题：大数运算的溢出问题

1. 问题现象

int 类型进行大数相乘时，结果超出 int 范围（-2147483648~2147483647），会出现内存溢出，结果为负数或错误值。

2. 代码示例

// JDK7新特性：数字可使用下划线分割，不影响取值
int money = 10_0000_0000;
int years = 20;
int total = money * years; // 结果-1474836480，溢出
long total2 = money * years; // 仍溢出，因运算时默认int，转换前已出错

3. 解决方法

运算前将其中一个操作数强制转换为大范围类型（如 long），使运算整体以大范围类型执行，避免溢出。

long total3 = money * (long)years; // 先将years转long，结果20000000000，正确

六、拓展：char 与 int 的互转

char 类型本质存储 Unicode 编码值（int 类型），可与 int 直接运算和转换，是类型转换的常见场景。

char c = 'A'; // Unicode值65
int d = c + 1; // 自动转int，结果66
System.out.println((char)d); // 强制转char，结果'B'
avatar
文章
阅读
粉丝