这是一个标准的Maven项目：

而我使用Jetbrains的IntelliJ构建系统作为学习，它的默认项目结构长这样：

它的优势在于与IDEA深度集成，简单易用，但是功能性不如 Gradle / Maven ，适合初学者使用。

我们可以看到，IDEA已经帮我们创建好了Main.java这个文件。

让我们开始吧。

文件命名规范

核心规则只有一条，但非常重要：

如果一个 .java 源文件中包含一个 public 的类，那么这个源文件的文件名必须与该 public 类的名称完全相同，并且区分大小写。

我们来拆解一下：

1. public class 是关键：这条规则只针对被 public 关键字修饰的类。

2. 完全相同：意味着 MyClass 和 myclass 是不同的。如果你的类是 public class MyWebApp，那么文件名必须是 MyWebApp.java，不能是 mywebapp.java 或任何其他名字。

为什么有这个强制规定？

这和 Java 的编译和类加载机制有关。它保证了编译器和 Java 虚拟机 (JVM) 可以通过一个统一的规则，快速地从类名直接定位到对应的文件。这是一种“约定优于配置”的设计，强制了代码的高度组织性。

如果没有 public 类呢？ 一个 .java 文件中可以不包含任何 public 类。在这种情况下：

• 文件名可以任意命名。

• 文件内可以有多个非 public 的类。

但是，这在实际工程中是极不推荐的做法。良好的编程实践是：

一个 .java 文件只放一个类，并且文件名与类名保持一致。

程序的入口

Java 程序的入口是一个固定格式的 main 方法。

它的完整写法是：

1
2
3

public static void main(String[] args) {
    // 你的代码从这里开始执行
}

简单解释一下为什么是这样：

• public: 因为这个方法需要被 Java 虚拟机 (JVM) 从外部调用，所以它必须是公开的。
• static: JVM 启动程序时，不会先去创建这个类的对象，而是直接通过类名来调用这个方法，所以它必须是静态的。
• void: 程序执行结束后，不需要返回任何值给 JVM。
• main: 这是 Java 规定的、固定的方法名。
• String[] args: 这是用来接收你在运行程序时从命令行传入的参数。

它必须位于一个类 (class) 的内部。

一个 Java 程序可以包含很多个类，但只有包含了 public static void main(String[] args) 这个方法的类，才能被 Java 虚拟机 (JVM) 作为程序的起点来执行。

你可以把任何一个类作为你程序的入口，只要它包含了这个 main 方法。

例如：

1
2
3
4
5
6
7

// 文件名: MyProgram.java
public class MyProgram {
    // main 方法位于 MyProgram 这个类里面
    public static void main(String[] args) {
        System.out.println("程序从这里启动！");
    }
}

当你运行这个程序时（例如，在命令行中输入 java MyProgram），JVM 就会去寻找 MyProgram 这个类，并执行它里面的 main 方法。

不过我们一般会把他放在 Main 这个类里。

包

package 语句是用来组织和管理 Java 类的，它主要有两个作用：

1. 防止命名冲突： 就像在 C++ 中使用 namespace 或者在 Python 中使用模块一样。如果你和你的同事都写了一个名为 Utils 的类，只要它们在不同的 package 里（例如 com.myproject.utils 和 com.anotherproject.helpers），它们就不会冲突。

2. 控制访问权限： 它可以帮助你控制哪些类可以被其他类访问。

最重要的一点是，package 的名字必须和你的文件系统中的文件夹路径完全对应。

例如，如果一个类的开头写着： package com.mycompany.app;

那么这个类的 .java 文件就必须存放在 .../src/main/java/com/mycompany/app/ （Maven） 这个目录下。我使用的 IntelliJ 则是在这个地方：.../src/com/mycompany/app/

需要注意的是IDEA非常智能，它会隐藏掉一些东西，比如

这个org.example在实际文件系统内是org文件夹下的example文件夹，而在新建文件时

这么多不同的类型，实际都是.java文件，只是里面预制的结构不太一样。

语句

在 Java 中，这个规则和 C/C++ 几乎完全一样。

基本上，所有表达一个完整操作的独立语句，都需要用分号 ; 结尾。

以下是一些必须使用分号的常见情况：

1. 变量声明和赋值语句:

   1 2	int age = 20; String name = "Java";

2. 方法调用语句:

   1 2	System.out.println("Hello, World!"); myDog.bark();

3. 对象创建语句:

   1	Dog myDog = new Dog();

4. return, break, continue 等跳转语句:

   1 2	return; break;

5. package 和 import 语句:

   1 2	package com.example; import java.util.List;

这些情况通常不需要分号

• 类、方法、接口的定义（因为它们使用 {} 来定义一个代码块，而不是一个语句）。

  1 2 3 4 5 6

  public class MyClass { // 这里没有分号 // ... } public void myMethod() { // 这里没有分号 // ... }

• if, for, while 等控制流结构的头部。

  1 2 3 4 5 6

  if (condition) { // 这里没有分号 // ... } for (int i = 0; i < 5; i++) { // 这里没有分号 // ... }

有一个小特例是 do-while 循环，它的 while 部分需要分号：

1
2
3

do {
   // ...
} while (condition); // 注意这里的分号

类与对象

这是 Java 的核心。一切皆对象，而类是创建对象的蓝图。

这部分与大部分面向对象的编程语言一致。

 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

// 定义一个 Dog 类
public class Dog {
    // 实例变量 (Instance Variable)，描述属性
    String breed;
    int age;

    // 方法 (Method)，描述行为
    void bark() {
        System.out.println("Woof!");
    }
}

// 创建和使用 Dog 对象
public class Main {
    public static void main(String[] args) {
        // 创建一个 Dog 对象（实例化）
        Dog myDog = new Dog();

        // 设置对象的属性
        myDog.breed = "Beagle";
        myDog.age = 5;

        // 调用对象的方法
        myDog.bark(); // 输出: Woof!
    }
}

数据类型

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

基本数据类型 (Primitive Types):

这些不是对象，直接存储值，类似于 C/C++ 的基本类型。它们有固定的大小，与平台无关。

1. 整型: byte (1字节), short (2字节), int (4字节), long (8字节)

2. 浮点型: float (4字节), double (8字节)

3. 字符型: char (2字节, 使用 Unicode 字符)

4. 布尔型: boolean (只有 true 和 false 两个值)

引用数据类型 (Reference Types):

这些是对象。变量存储的是对象的内存地址（引用），类似于 C++ 的指针或 Python 中的变量。

1. 所有的类 (如 String, Dog)

2. 所有的接口 (Interface)

3. 所有的数组 (Array)

变量

变量声明的格式为 type name = value;。

1
2
3
4
5
6
7

int a = 10;          // 基本类型
double pi = 3.14;    // 基本类型
char initial = 'J';  // 基本类型
boolean isJavaFun = true; // 基本类型

String greeting = "Hello"; // 引用类型
Dog anotherDog = new Dog();  // 引用类型

运算符

Java 的运算符与 C/C++ 几乎完全相同。

1. 算术运算符: +, -, *, /, % (取模), ++ (自增), – (自减)

2. 关系运算符: ==, !=, >, <, >=, <=

3. 逻辑运算符: && (逻辑与), || (逻辑或), ! (逻辑非)

4. 位运算符: &, |, ^, ~, «, »

5. 赋值运算符: =, +=, -=, *=, /=

控制流

这部分也和 C/C++ 高度一致。

条件语句 (If-Else)

1
2
3
4
5
6
7
8

int score = 85;
if (score >= 90) {
    System.out.println("Excellent");
} else if (score >= 60) {
    System.out.println("Pass");
} else {
    System.out.println("Fail");
}

Switch 语句

(Java 14+ 引入了更简洁的箭头语法，这里是传统语法)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

char grade = 'B';
switch (grade) {
    case 'A':
        System.out.println("Excellent!");
        break;
    case 'B':
        System.out.println("Good");
        break;
    default:
        System.out.println("Invalid grade");
}

这是新的箭头语法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

String day = "MONDAY";

String dayType = switch (day) {
    // 多个 case 可以用逗号合并
    case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" -> "Workday";
    case "SATURDAY", "SUNDAY" -> "Weekend";
    default -> "Invalid day";
}; // 注意：作为表达式时，末尾需要分号

System.out.println(dayType); // 输出: Workday

循环

For 循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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

增强 For 循环 (Enhanced For-Loop): 类似于 Python 的 for...in，用于遍历数组或集合。

int[] numbers = {10, 20, 30};
for (int number : numbers) {
    System.out.println(number);
}

While 循环

1
2
3
4
5

int count = 0;
while (count < 5) {
    System.out.println(count);
    count++;
}

Do-While 循环

1
2
3
4
5

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

跳转语句

break (跳出循环)

continue (跳过本次循环)

数组

在 Java 中，数组是一个定长的对象，用于存储相同类型的元素集合。

声明和初始化:

1
2
3
4
5

// 方式一：声明并指定大小
int[] anArray = new int[10];

// 方式二：声明并直接初始化
String[] names = {"Alice", "Bob", "Charlie"};

访问元素: 通过索引访问，索引从 0 开始。

1
2

System.out.println(names[0]); // 输出: Alice
anArray[0] = 100; // 赋值

获取长度: 使用 .length 属性。

1

System.out.println(names.length); // 输出: 3