当前位置：首页 > news >正文

Java 入门宝典--注释、关键字、数据类型、变量常量、类型转换

news 2025/4/29 8:02:24

作者：IvanCodes

发布时间：2025年4月28日🐣

专栏：Java教程

哈喽，各位 CSDN 的小伙伴们！👋 这部分内容虽然基础，但 极其重要，是后续学习所有高级特性的基石。准备好了吗？让我们一起稳扎稳打，拿下这些核心概念！💪

一、注释：代码的“便利贴” 📝

想象一下，你在看一本复杂的书，如果作者在旁边贴了一些“便利贴”解释难点，是不是会好懂很多？Java 的注释就是 代码中的“便利贴”！

它们的作用：

解释代码：说明某段代码的功能、目的、实现思路。方便自己以后回顾，也方便别人阅读你的代码。
辅助调试：暂时“注释掉”某段代码，让它不执行，用来排查问题。
提高可读性：让复杂的代码逻辑更清晰。

Java 主要有三种注释：

单行注释 (//)
- 从 // 开始，到这一行的末尾，都是注释内容。
- 最常用，适合简短的说明。

// 这是一条单行注释，用来解释下面这行代码的作用
int age = 25; // 定义一个表示年龄的变量

多行注释 (/* ... */)
- 以 /* 开始，以 */ 结束，中间的所有内容都是注释。
- 可以跨越多行，适合写较长的说明或者注释掉一整块代码。

/*这是一段多行注释。它可以用来详细解释一个方法或一段复杂的逻辑。
*/
int calculateSum(int a, int b) {/*int temp = a; // 临时注释掉的调试代码a = b;b = temp;*/return a + b;
}

文档注释 (/** ... */) ✨
- 以 /** 开始，以 */ 结束。
- 这种注释很特别！它可以被 Java 的 javadoc 工具提取出来，自动生成程序文档 (API 文档)。
- 通常用在类、接口、方法、成员变量的前面，用来描述它们的作用、参数、返回值等。
- 里面可以使用一些特殊的 @ 标签，如 @param, @return, @author, @version 等。

/*** 这是一个计算两个整数之和的工具类。* @author IvanCodes* @version 1.0*/
public class MathUtils {/*** 计算两个整数的和。* @param num1 第一个整数。 <font color="#9b59b6">(参数说明)</font>* @param num2 第二个整数。 <font color="#9b59b6">(参数说明)</font>* @return 两个整数的和。 <font color="#1abc9c">(返回值说明)</font>*/public int add(int num1, int num2) {// 方法体return num1 + num2;}
}

养成写注释的好习惯，未来的你会感谢现在的自己！ 🙏

二、关键字与标识符：代码世界的“规则”与“名字” 📜

1. 关键字 (Keywords) 🔑

关键字是 Java 语言**预先定义好的、具有特殊含义的单词**。它们是 Java 语法的一部分，你不能把它们用作其他目的（比如变量名）。
Java 的关键字都是小写的。
常见的关键字有：public, class, static, void, int, float, if, else, for, while, new, this, super, package, import, final, abstract, interface 等等。
注意： true, false, null 虽然看起来像关键字，但严格来说它们是字面量 (Literals)，但你同样不能把它们用作标识符。

记忆技巧： 关键字就像编程语言里的“专用词汇”，有固定用法，不能乱用。

2. 标识符 (Identifiers) 🏷️

标识符就是你 自己起的名字，用来标识程序中的各个元素，比如：
- 类名 (e.g., MathUtils, SuperMan)
- 接口名 (e.g., Flyable, Logger)
- 方法名 (e.g., add, fly, logInfo)
- 变量名 (e.g., age, num1, consoleLogger)
- 常量名 (e.g., MAX_USERS, DEFAULT_THEME)
- 包名 (e.g., java.util, com.mycompany.project)
命名规则 (必须遵守！否则编译不通过 ❌)：
- 可以由字母、数字、下划线 (_)、美元符号 ($) 组成。
- 不能以数字开头。
- 不能是 Java 关键字。
- 严格 区分大小写 (age 和 Age 是两个不同的标识符)。
命名规范 (强烈建议遵守！代码更专业、易读 ✅)：
- 包名 (Package): 全部小写，多单词用点 . 分隔 (e.g., com.ivan.utils)。
- 类名 & 接口名 (Class & Interface): 大驼峰命名法 (UpperCamelCase)，每个单词首字母大写 (e.g., MyClass, Flyable, UserService)。
- 方法名 & 变量名 (Method & Variable): 小驼峰命名法 (lowerCamelCase)，第一个单词首字母小写，后续单词首字母大写 (e.g., getUserName, calculateTotalAmount, studentAge)。
- 常量名 (Constant): 全部大写，多单词用下划线 _ 分隔 (e.g., MAX_CONNECTIONS, DEFAULT_ENCODING)。

记住： 好的命名是好代码的开始！要做到 见名知意。

三、数据类型：存储数据的“容器” 📦

程序需要处理各种各样的数据，比如数字、文字、真假值等。数据类型就是用来定义这些数据 可以存储哪种类型的数据 以及 占用多少内存空间。

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

1. 基本数据类型 (Primitive Types) 🧱

这是 Java 语言 内置的、最基础 的数据类型。它们直接存储 数据值 本身。

共有 8 种：

类型	关键字	大小 (字节)	范围/描述	例子	常用场景
字节型	`byte`	1	-128 到 127	`byte b = 100;`	处理字节流、节省空间
短整型	`short`	2	-32,768 到 32,767	`short s = 30000;`	较少使用，节省空间
整型	`int`	4	约 -21 亿到 21 亿	`int i = 123456;`	最常用的整数类型
长整型	`long`	8	非常大的整数范围	`long l = 99L;`	需要表示很大整数时
单精度	`float`	4	大约 6-7 位有效数字的浮点数	`float f = 3.14f;`	需要小数，精度要求不高
双精度	`double`	8	大约 15 位有效数字的浮点数	`double d = 3.14159;`	最常用的小数类型
字符型	`char`	2	单个 Unicode 字符	`char c = 'A';`	表示单个字符
布尔型	`boolean`	1 (逻辑上)	只有 `true` 或 `false` 两个值	`boolean flag = true;`	条件判断、逻辑运算

❗❗ 注意：

long 类型的值后面要加 L 或 l (推荐 L，避免与数字 1 混淆)。
float 类型的值后面要加 F 或 f。
Java 中的整数默认是 int 类型，小数默认是 double 类型。
char 使用单引号 ' ' 包裹。

2. 引用数据类型 (Reference Types) 🔗

除了 8 种基本类型外，其他的都是引用类型。
它们不直接存储数据值，而是存储 对象在内存中的地址引用 (可以想象成存储了一个“门牌号”)。
常见的引用类型包括：
- 类 (Class): 如 String, Scanner, 我们自己定义的 SuperMan, MathUtils 等。
- 接口 (Interface): 如 Flyable, Runnable, List 等。
- 数组 (Array): 如 int[], String[], double[][] 等。
引用类型的变量通常需要通过 new 关键字来创建对象实例（String 有特殊处理）。
引用类型的默认值是 null，表示不指向任何对象。

String name = "IvanCodes"; // String 是一个类 (引用类型)
int[] scores = new int[10]; // 数组是引用类型
Flyable flyer = new SuperMan(); // 接口类型变量引用实现类的对象
Scanner input = new Scanner(System.in); // Scanner 是一个类

核心区别： 基本类型存值，引用类型存地址。

四、变量与常量：存储数据的“命名空间” 🏷️➡️📦

1. 变量 (Variables) 🔄

变量就像一个 可以贴标签、并且里面东西可以更换的盒子。
它的 值是可以改变 的。
使用步骤：
1. 声明 (Declare): 指定变量的类型和名称。告诉编译器：“我要预定一个这样类型的、叫这个名字的盒子”。
2. 初始化 (Initialize): 给变量赋一个初始值。往盒子里第一次放东西。

// 声明变量 (预定盒子)
int age;
double salary;
String username;// 初始化变量 (第一次放东西)
age = 18;
salary = 5000.50;
username = "Alice";// 也可以声明和初始化合并在一行
char gender = 'F';
boolean isStudent = true;// 变量的值可以改变 (更换盒子里的东西)
age = 19; // 年龄增长了
salary = salary + 1000; // 涨工资了
System.out.println("年龄: " + age); // 输出: 年龄: 19

变量必须先声明、后使用。
变量只有在初始化（赋值）之后才能读取它的值。

2. 常量 (Constants) 🔒

常量就像一个 贴上标签后就被封死的盒子，里面的东西放进去后就 永远不能再改变 了。
使用 final 关键字定义常量。
常量名 强烈建议 全部大写，单词间用下划线分隔（规范）。
常量 必须在声明时或构造方法中初始化，之后不能再赋值。

// 定义常量 (声明并初始化一个封死的盒子)
final double PI = 3.14159;
final int MAX_LOGIN_ATTEMPTS = 5;
final String COMPANY_NAME = "My Awesome Company";// 尝试修改常量的值会导致编译错误 ❌
// PI = 3.14; // Error: Cannot assign a value to final variable 'PI'System.out.println("圆周率约等于: " + PI);

使用场景： 当某个值在程序运行期间是不变的，并且具有明确含义时，应定义为常量，可以提高代码的可读性和可维护性（比如修改时只需要改一处定义）。

五、类型转换：数据“变形记” 🪄

有时候，我们需要将一种数据类型的值赋给另一种数据类型的变量，这就需要进行类型转换。

1. 自动类型转换 (Implicit Conversion / Widening Conversion) 👍

当把一个 表示范围小 的数据类型的值，赋给一个 表示范围大 的数据类型的变量时，Java 会自动进行转换。
这通常是安全的，不会丢失信息。
可以想象成 把小盒子里的东西放到大盒子里，肯定放得下。
转换规则（箭头表示可以自动转换的方向）：
byte -> short -> int -> long -> float -> double
char -> int … (char 可以转换为 int 等整数类型)

byte b = 10;
short s = b; // byte -> short (自动)
int i = s;   // short -> int (自动)
long l = i;  // int -> long (自动)
float f = l; // long -> float (自动，可能损失精度)
double d = f; // float -> double (自动)char c = 'A';
int charValue = c; // char -> int (自动, 'A' 对应的 ASCII/Unicode 值 65)System.out.println("Double value: " + d); // 输出: Double value: 10.0
System.out.println("Char to int: " + charValue); // 输出: Char to int: 65

2. 强制类型转换 (Explicit Conversion / Narrowing Conversion) ⚠️

当把一个 表示范围大 的数据类型的值，赋给一个 表示范围小 的数据类型的变量时，需要进行强制类型转换。
语法：(目标类型) 值;
这可能 不安全，可能会导致 数据丢失 或 精度损失！
可以想象成 试图把大盒子里的东西硬塞进小盒子里，可能塞不下或者东西会坏掉。

double preciseValue = 99.99;
// int integerPart = preciseValue; // 编译错误！不能自动从 double 转 int ❌int integerPart = (int) preciseValue; // 强制转换 (显式告知编译器我要转)
System.out.println("Integer part: " + integerPart); // 输出: Integer part: 99 (小数部分被截断，数据丢失！)long bigNum = 10000000000L; // 一个很大的 long 值
// int smallNum = bigNum; // 编译错误！❌
int smallNum = (int) bigNum; // 强制转换
System.out.println("Small num: " + smallNum); // 输出: Small num: 1410065408 (数据溢出导致结果错误！)int number = 65;
char letter = (char) number; // 强制转换 int -> char
System.out.println("Letter: " + letter); // 输出: Letter: A (这里转换是符合预期的)