Java 程序结构与 main 方法

1. 引言

刚开始学编程时，似乎只要一行一行把代码写下去，一切就会正常运行。但只要程序一复杂，脑子里就会开始打结：各部分在哪里、为什么要这么写、如果需要改一行——那一行究竟在哪儿？

因此，Java 和大多数现代语言一样，提供了一种把代码“分门别类”的方式，让我们随时都能弄清程序在做什么，并能快速定位到需要的位置。

想象一家公司：有人力资源部、财务部、IT 部门、物流部等等。每个部门都有自己的职责、员工和任务。

在 Java 程序里，每一个这样的“部门”就是一个类。一个类负责处理用户，另一个负责计算，还有一个负责文件操作。

下面是一个简单项目的典型结构：

• Main.java — 总部：这里放着“入口点”，一切从这里开始。
• User.java — 负责存储和处理用户数据的部门。
• Calculator.java — 计算部门。
• FileHelper.java — 文件方面的专员。

即便是很小的程序，通常也至少有一个类。而大型项目就是由上百个类构成的整座“摩天大楼”！

2. 类就是一个工具箱

Java 是一种面向对象的语言，其中一切皆对象。对象的类型称为类。

类就像一个盒子或小柜子，我们把需要的东西放进去：变量、方法。想象一个写着“锤子”的盒子：里面只放与锤子相关的工具。

class Example 
{
    // 这里放我们的工具：变量和方法
}

类通常包含变量和函数。在 Java 中，类的变量通常称为字段，类的函数称为方法，但本质不变。

还记得我们的第一段代码吗？

System.out.println("大家好！");

这段代码里既有类也有方法：

• System — 一个类，里面包含用于与系统交互的方法。
• out — 一个字段，它是 PrintStream 类的对象。
• println — PrintStream 类的方法，用于把文本输出到屏幕。

从某种意义上讲，编程就是编写自己的类和方法，并在其中调用其他类的方法。

3. main() 方法的简写

实际上，最小的 Java 程序长这样：

class Program 
{
    public static void main(String[] args) 
    {
        // 在这里编写你的代码
    }
}

它至少包含一个类，并且该类必须包含如下签名（signature）的 main 方法：

public static void main(String[] args)

不过，在 Java 21 中，可以用简写方式编写 main() 方法。Java 编译器随后（在编译时）会把它转换为规范的 main() 方法。

因此，每当你写出如下这种代码时：

void main() 
{
    Scanner console = new Scanner(System.in);
    int age = console.nextInt();
    System.out.println("年龄：" + age);
}

Java 编译器会把它转换为：

class Program 
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);
        int age = console.nextInt();
        System.out.println("年龄：" + age);
    }
}

4. 一个典型的 Java 类

一个典型的 Java 类大致如下：

public class MathUtils 
{
    // 静态变量（类的全局变量）
    static final double PI = 3.14159;
    static int callCounter = 0;

    // 静态方法：计算圆的面积
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }

    // 静态方法：求两个数的最大值
    public static int max(int a, int b) 
    {
        callCounter++;
        return (a > b) ? a : b;
    }

    // 静态方法：统计方法被调用的次数
    public static int getCallCount() 
    {
        return callCounter;
    }

    // 在 main() 中访问字段和方法 
    public static void main(String[] args) 
    {
        System.out.println("圆的面积：" + circleArea(5));
        System.out.println("最大值：" + max(10, 42));
        System.out.println("方法被调用了 " + getCallCount() + " 次");
    }
}

我们可以观察到：

• 一个类可以有很多方法。
• 一个类可以有自己的变量。
• 类的方法可以相互调用。
• 类的方法可以访问公共的变量。
• 每个方法前面都有一组相同的“魔法词”，例如：public static。
• 每个方法前面都有返回类型，如：int、double、void。

下面我们会逐一解释这些细节。

5. 类的字段（变量）就是它的记忆

在类的内部可以保存变量，常称为字段（fields）。它们就像内存格子，用来存放一些数据。

public class MathUtils 
{
    // 静态变量（类的全局变量）
    static final double PI = 3.14159;
    static int callCounter = 0;
}    

字段让类能够在不同方法调用之间“记住”一些东西。例如，统计点击按钮的次数，或者统计某个方法被调用了多少次（callCounter）。字段的数量没有限制。

6. 方法——类能执行的动作

方法就是类的“本领”。如果把类看成员工，方法就是他的技能：他能做什么。

例如，方法可以：

• 把内容输出到屏幕，
• 计算两个数的和，
• 接收输入数据并返回结果。

方法的结构：

1. 返回值类型（例如，void —— 如果不返回任何值；或 int —— 如果返回一个整数）。
2. 方法名（例如，circleArea）。
3. 括号中的参数（可以没有）。
4. 花括号 { ... } —— 方法体。

public class MathUtils 
{
    // 静态方法：计算圆的面积
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }

    // 静态方法：求两个数的最大值
    public static int max(int a, int b) 
    {
        callCounter++;
        return (a > b) ? a : b;
    }
}    

关于方法及其相关细节，我们会在接下来的课程中详细讲解。

7. 访问修饰符

在 Java 中，我们可以控制类的哪些部分可以被其他类访问，哪些只用于内部。这就要用到访问修饰符。

• public — 对所有人可见。这样的字段和方法可以在程序的任何地方使用或调用。
• private — 仅在类内部可见。这些是内部细节，不应被外部访问，就好像它们根本不存在。

public class MathUtils 
{
    // 静态变量（类的全局变量）
    private static final double PI = 3.14159;
    private static int callCounter = 0;

    // 静态方法：计算圆的面积
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }
}    

黄金法则：通常把字段设为 private，只把真正需要对外提供的功能作为带有 public 的方法“暴露”出去。关于可见性修饰符的更多内容，我们会在后续课程中介绍。

8. 静态方法与静态变量

通常在 Java 中，类用作创建对象的模板。你先编写类，然后用关键字 new 创建该类的对象，之后再调用对象的方法。

不过，还有另一种使用类的方式——把它当成一个容器，存放全局变量和可以在程序任意位置调用的方法。关键字 static 就是为此而生的。它告诉 Java 编译器，这些方法和字段隶属于类本身，而不是某个对象，因此无需创建对象就能调用它们。

事实上，你经常会使用这样的静态方法：

Integer.parseInt();     // 类 Integer 的静态方法 parseInt()
String.valueOf();       // 类 String 的静态方法 valueOf() 
Double.isInfinite();    // 类 Double 的静态方法 isInfinite() 
Arrays.copy();          // 类 Arrays 的静态方法 copy() 

main() 方法总是被声明为静态的，因为 Java 程序的执行从它开始。在创建任何对象之前。

9. IDEA 小技巧

main() 方法的完整签名如下：

public static void main(String[] args) 

为了避免每次都手敲，在 IntelliJ IDEA 中有相应的快捷方式。只需输入 psvm 并按下 Tab，IntelliJ IDEA 就会自动生成如下代码：

public static void main(String[] args) 
{
    
}

很容易记住 —— psvm —— 是 public static void main 的首字母组合。