菜鸟学Java public static void main(String[] args) 是什么意思？

绝地灬酷狼 2023-10-12 20:59 14阅读 0赞

#### 目录 ####

*   *  1、经典程序解析
     *  2、包里面的多个类
     *   *  2.1 全限定名调用程序
         *  2.2 包名的层数
         *  2.3 类中main位置的选择
         *  2.4 不同包中类的调用
     *  3、void位置返回值
     *  4、同一个包内的类调用
     *  5、public位置选择
     *  6、String\[\] args类型选择
     *   *  6.1 main方法
         *  6.2 非main方法
     *  7、import调用包
     *  8、下载第三方库/框架包

### 1、经典程序解析 ###

这是一个经典的`Java`程序，它使用了面向对象的编程风格：

public class HelloWorld {
        
        public static void main(String[] args) {
        
            System.out.println("Hello World");
        }
    }

第一行代码：

public class HelloWorld {

这行代码定义了一个名为`HelloWorld`的公共类（`public class`），该类是程序的入口点。`Java`程序中的每个类都必须以一个公共类来定义。文件名必须与公共类的名称相同，并以`.java`作为文件扩展名。

> 注：`String args[]` 与 `String[] args` 都可以执行，但推荐使用 `String[] args`，这样可以避免歧义和误读。

public static void main(String[] args)

这行代码定义了一个公共静态方法`（public static method）main`，它是`Java`程序的起点。在程序执行时，从`main`方法开始执行。`main`方法是程序的入口，可以执行程序中的其他代码。

`main`方法的参数是一个字符串数组`String[] args`，它允许在命令行中传递参数给程序。`args`数组在程序运行时可以用来接收命令行参数。

这是 `Java` 程序的入口地址，`Java` 虚拟机运行程序的时候首先找的就是 `main` 方法。跟 `C` 语言里面的 `main()` 函数的作用是一样的。只有有 main() 方法的 `Java` 程序才能够被 `Java` 虚拟机运行，可理解为规定的格式。

对于里面的参数及修饰符：

*  `public`：表示的这个程序的访问权限，表示的是任何的场合可以被引用，这样 `Java` 虚拟机就可以找到 `main()` 方法,从而来运行 `javac` 程序。
 *  `static`： 表明方法是静态的，不依赖类的对象的，是属于类的，在类加载的时候 main() 方法也随着加载到内存中去。
 *  `void`：方法是不需要返回值的。
 *  `main`：约定俗成，规定的。
 *  `String[] args`：从控制台接收参数。

> 为什么是 `String[] args`，这个 `args` 是干嘛的？

`String[] args` 可以看出来它是一个数组。在命令行中比如运行 `Test.class` 文件,你可以这样写：

java Test runoob

相当于给数组传入了一个 `runoob` 字符串。也可以打印出来，可以作为简单的输入。

例如：

public class Test {
        
        public static void main(String[] args) {
        
            System.out.println(args[0]);
        }
    }

$ javac Test.java
    $ java Test runoob
    runoob

此处注意，`main` 是一个程序的入口，一个 `java` 程序运行必须而且有且仅有一个 `main` 方法。

`args[0]` 是你传入的第一个参数，`args[1]`是传入的第二个参数，以此类推。

> `String[] args` 还有一种等价的写法： `String... args`

前者为数组形式, 后者为可变参数形式。

前者用得较多, 但是看到后者也应认识。

> `Java` 程序利用 `main` 函数中 `args` 参数实现参数的传递(传递空格处理)

public class Test
    {
        
        public static void main(String []args)
        {
        
            System.out.println(args[0]);
            System.out.println(args[1]);
            System.out.println(args[2]);
        }
    }

用控制台编译运行：

$ javac Test.java
    $ java Test aaa bbb ccc 
    aaa
    bbb
    ccc

注意：三个参数之间用空格隔开！

如果要输出空格怎么办？

只需要在包含空格的参数上，使用双引号 `""` 即可。

实例运行：

$ java Test aaa "b   bb" ccc
    aaa
    b   bb
    ccc

### 2、包里面的多个类 ###

> 一个包里面可以有多个`java`类吗?

是的，一个包`（package）`可以包含多个`Java`类。在`Java`中，包是一种组织代码的方式，它可以将相关的类和其他资源放在一起，使代码更有结构和可维护性。

一个包可以包含多个`Java`类文件，并且这些类可以相互引用和访问。这种组织结构有助于避免类名冲突，并使代码更易于组织和管理。

要在一个包中创建多个Java类，你可以将这些类放在同一个包目录下，并确保每个类的文件名与类名相匹配。例如，假设你有一个名为`com.example`的包，你可以在该包下创建多个`Java`类文件，如`ClassA.java`、`ClassB.java`等。

com/
       example/
          ClassA.java
          ClassB.java

在这个例子中，`com.example`是包的名称，`ClassA.java`和`ClassB.java`是位于该包下的两个`Java`类文件。

#### 2.1 全限定名调用程序 ####

在`Java`代码中引用包中的其他类时，你需要使用类的全限定名`（fully qualified name）`，即包名加类名。例如，在`ClassA.java`中引用`ClassB`的话，你需要使用`com.example.ClassB`作为类的名称。

package com.example;
    
    public class ClassA {
        
        // 引用ClassB
        com.example.ClassB b = new com.example.ClassB();
        // ...
    }

一个包可以包含多个`Java`类文件，并且这些类可以相互引用。这种组织方式有助于将相关的类组织在一起，提高代码的可读性和可维护性。

#### 2.2 包名的层数 ####

> 在上面的结构中，`com.example`是一个包名，需要限定包名的层数吗？可不可以没有`example`这一层？

在`Java`中，包名是按照一定的命名约定来组织和识别代码的。包名通常以域名的倒序形式命名，以确保包名的唯一性和可读性。

对于包的层数并没有硬性的限制要求，你可以根据自己的需要来组织包的层次结构。每个层级在包名中通过.进行分隔。

在你提供的示例中，`com.example`是一个包名，其中`com`是顶级包，`example`是子包。这种层次结构有助于将相关的类组织在一起，并提供更好的可读性和可维护性。当多个开发者共同开发项目时，按照这种约定命名包可以减少类名冲突的可能性。

根据`Java`的命名约定，建议使用类似域名的包名结构，但并不是强制要求。你可以根据你的项目需求和个人喜好来命名包。

因此，可以有不同的包层级结构，如只有一个层级的包名`com`、两个层级的包名`com.example`，或者更多层级的包名`com.example.subpackage`，以满足你的项目需求。

包名的层数没有硬性的限制要求，你可以根据需要组织包的层次结构。通常建议使用类似域名的包名结构，但并不是强制要求，可以根据项目需求和个人喜好来命名包。

#### 2.3 类中main位置的选择 ####

> 在一个包中，有多个`java`类，每一个类中都是`public static void main(String[] args) { ...}`这样的代码吗？

在一个包中，每个类都可以有一个`public static void main(String[] args)`方法，但只能有一个类被指定为程序的入口点，即只能有一个类的`main`方法被执行。

当你运行`Java`程序时，你需要指定要执行的类，`Java`虚拟机（`JVM`）会从该类的`main`方法开始执行。其他类中的`main`方法只是普通的方法，除非被显式调用，否则不会被执行。

如果一个包中有多个类，每个类中都有`main`方法，你需要在运行程序时明确指定要执行的类。使用`Java`命令来执行程序时，通过提供完整的类名来指定要执行的类。例如：

java com.example.ClassA

在这个例子中，`com.example.ClassA`是包`com.example`中的一个类，它的`main`方法将被执行。其他类中的`main`方法将不会被自动执行。

在一个包中可以有多个类，每个类都可以有自己的`main`方法，但只能指定一个类作为程序的入口点。其他类中的`main`方法需要通过显式调用来执行。

#### 2.4 不同包中类的调用 ####

> 既然一个包执行只会执行一个`main`,那么其他类里面没有`main`,怎么写代码呢？又如何被调用呢？

如果一个包中的类没有`main`方法，它们可以包含其他方法和属性，并且可以被其他类调用和使用。这些类可以用于实现特定的功能、定义对象、提供工具方法等。

如果你想调用其他包中的类，你需要在你的代码中引用这些类。在`Java`中，你可以使用`import`语句来引入其他包中的类，然后通过类名来访问这些类的方法和属性。

假设你有两个包：`com.example.package1`和`com.example.package2`。如果你想在`package1`中的一个类中使用`package2`中的类，你可以按照以下方式进行引用：

package com.example.package1;
    
    import com.example.package2.ClassB;
    
    public class ClassA {
        
        public void doSomething() {
        
            ClassB b = new ClassB();
            // 使用ClassB的方法或属性
            b.methodName();
            // ...
        }
    }

在这个例子中，`ClassA`位于`com.example.package1`包中，它通过`import`语句引入了`com.example.package2.ClassB`类。然后，你可以在`ClassA`中创建`ClassB`的实例并使用其方法和属性。

当你在其他类中引用某个包中的类时，你需要使用类的全限定名`（fully qualified name）`，即包名加类名。通过这种方式，你可以在一个包中使用另一个包中的类。

需要注意的是，如果要在命令行中执行某个包中的类，你需要指定该类的全限定名作为程序的入口点，即在该类中包含`main`方法。

一个包中的类可以被其他类调用和使用，即使它们没有`main`方法。你可以通过`import`语句引入其他包中的类，并使用类的全限定名来访问它们的方法和属性。要在命令行中执行某个包中的类，需要指定该类的全限定名作为程序的入口点。

> 详细解释上面的`public void doSomething()`

*  `public void doSomething()` 是一个方法的定义。让我逐步解释每个部分的含义：
 *  `public`: 这是方法的访问修饰符（`access modifier`），它指示该方法可以从任何地方访问。`public`修饰符表示该方法对外部可见，其他类可以直接调用该方法。
 *  `void`: 这是方法的返回类型（`return type`）。`void`表示该方法不返回任何值。当方法不需要返回结果时，可以将其返回类型设置为`void`。
 *  `doSomething`: 这是方法的名称，你可以根据需要选择一个描述性的名称。方法名应该具有描述性，以便能够清楚地表达方法的功能。
 *  `()`: 这是方法的参数列表（`parameter list`）。在这个例子中，该方法没有接受任何参数，因此参数列表为空。如果方法需要接受参数，你可以在括号内指定参数的类型和名称。
 *  `{ ... }` : 这是方法体（`method body`），包含了方法要执行的代码块。在这个例子中，方法体内部没有给出具体的代码，你可以在这个代码块中添加你要执行的操作。

public void doSomething() {
        
        // 执行具体的操作
        // ...
    }

在这个示例中，`doSomething`方法被定义为公共方法（可以被其他类访问），它不返回任何值（`void`），并且没有接受任何参数。你可以在方法体中编写代码来执行特定的任务，可以是打印信息、计算结果、调用其他方法等。

例如，你可以在`doSomething`方法中实现某种功能，比如打印一条消息：

public void doSomething() {
        
        System.out.println("Doing something...");
    }

当其他类实例化`ClassA`对象并调用`doSomething`方法时，该方法内的代码将被执行，并在控制台上打印出"Doing something…"。

`public void doSomething()` 是一个方法的定义，它具有指定的访问修饰符、返回类型、方法名、参数列表和方法体。你可以根据需要自定义方法的名称、参数和实现，以便执行特定的功能或操作。

### 3、void位置返回值 ###

> 倘若我需要返回一个值，那么上面的代码如何修改？

对于`java中的main`方法，`jvm`有限制，不能有返回值，因此返回值类型为`void`。

如果你需要在`非main`方法中返回一个值，你可以将方法的返回类型从`void`修改为你希望返回的数据类型。在`Java`中，你可以使用各种数据类型作为方法的返回类型，例如`int、double、String、自定义类`等。

下面是一个示例，将`doSomething`方法的返回类型修改为`int`，并返回一个整数值：

public int doSomething() {
        
        // 执行具体的操作
        int result = 42;  // 假设执行操作后得到的结果是42
        return result;   // 返回结果
    }

在这个例子中，`doSomething`方法的返回类型是`int`，它执行一些操作并将结果存储在`result`变量中。然后，使用`return`关键字将结果返回给调用者。

当其他类调用`doSomething`方法时，可以接收返回的结果并将其存储在一个变量中：

int value = doSomething();
    System.out.println("Returned value: " + value);

在这个例子中，将`doSomething`方法的返回值存储在`value`变量中，并在控制台上打印出返回的值。

请注意，方法可以有不同的返回类型，具体取决于你希望返回的数据类型。你可以根据需要选择适当的返回类型，并在方法体中使用`return`语句返回相应的值。

如果你需要在方法中返回一个值，你可以将方法的返回类型从`void`修改为你希望返回的数据类型，并在方法体中使用`return`语句返回相应的值。调用该方法时，可以接收返回的结果并进行进一步处理。

### 4、同一个包内的类调用 ###

> 假设在一个包中有`A.java`以及`B.java`, 在`A.java`中有`main`, `B` 中没有`main`, `A`如何调用`B`，详细解释并给出案例

要在一个类中调用另一个类，你需要先确保两个类在同一个包中，或者使用适当的`import`语句引入其他包中的类。

假设你有两个类：`A.java`和`B.java`，它们都在同一个包中。以下是一个示例，展示了在`A.java`中如何调用`B.java`：

在文件`A.java`中：

package com.example;
    
    public class A {
        
        public static void main(String[] args) {
        
            B b = new B();  // 创建B的实例
            b.doSomething();  // 调用B的方法
        }
    }

在文件`B.java`中：

package com.example;
    
    public class B {
        
        public void doSomething() {
        
            System.out.println("Doing something in B");
        }
    }

在这个示例中，`A.java`和`B.java`位于同一个包`com.example`中。在`A.java的main`方法中，首先创建了`B`类的一个实例，然后通过该实例调用了`B类中的doSomething`方法。

当你运行`A.java`时，它将输出`Doing something in B`，这是因为在`A类的main`方法中调用了`B`类的`doSomething`方法。

为了在`A.java`中使用`B.java`，你需要确保这两个文件位于同一个包中，并且在`A.java`的顶部使用`import`语句导入`B`类。然而，在同一个包中的类不需要导入，因为它们位于相同的命名空间中。

要在一个类中调用另一个类，需要确保它们在同一个包中或使用适当的`import`语句引入其他包中的类。然后，你可以在调用类的代码中创建该类的实例，并使用该实例来调用相应的方法。

### 5、public位置选择 ###

> `public`是固定的吗？它是公共的是什么意思？还有其他类型的选择吗？比如私有的，或者其他类型？

`public` 是 `Java` 中的一个访问修饰符（`access modifier`），用于控制类、方法、属性等的访问级别。它具有以下特点：

*  `public` 是最高级别的访问修饰符，表示被修饰的类、方法或属性对所有其他类可见，无论这些类是否属于同一个包或不同的包。
 *  使用 `public` 修饰的类可以被其他包中的类直接访问和使用，其方法和属性也可以被其他类调用。
 *  使用 `public` 修饰的方法可以在任何地方调用，无论是同一个类内部还是不同的类。
 *  使用 `public` 修饰的属性可以在任何地方访问和修改。

除了 `public，Java` 还提供了其他访问修饰符，用于控制访问级别和封装性。常见的访问修饰符包括：

*  `private`: 表示私有的访问级别，只有同一个类内部可以访问和修改。被 `private` 修饰的类、方法或属性对其他类都不可见。
 *  `protected:` 表示受保护的访问级别，只有同一个包内的类以及该类的子类可以访问和修改。对于不在同一个包中的类，除非是该类的子类，否则不能直接访问。
 *  默认（`package-private`）: 如果没有指定访问修饰符，即没有使用 `public、private` 或`protected`，则默认为包级访问权限。表示只有同一个包中的类可以访问和修改。  
    这些访问修饰符提供了不同级别的封装性，允许你控制类、方法和属性的可见性和可访问性。根据需求和设计原则，你可以选择适当的访问修饰符来限制对代码的访问。

访问修饰符的选择应根据代码设计和封装性原则进行，以确保良好的代码组织、可维护性和安全性。

`public 是 Java` 中的一个访问修饰符，表示被修饰的类、方法或属性对所有其他类可见。除了 `public`，还有其他访问修饰符，如 `private、protected 和默认`（包级访问权限）。这些修饰符提供了不同级别的封装性，你可以根据需求和设计原则选择适当的修饰符。

### 6、String\[\] args类型选择 ###

#### 6.1 main方法 ####

> 假设`main`中我要求传入的不是`String[] args` ,而是其他类型的呢，有哪些可以传入的类型，给出案例

在`Java中，main 方法`的参数必须是一个 `String` 类型的数组 `String[] args`。这是由`Java`语言规范所定义的，这样设计的目的是为了接收命令行参数。因此，`main` 方法的参数只能是 `String[] args`，而不能直接传入其他类型。

如果你需要在 `main` 方法中使用其他类型的参数，你可以将命令行传入的字符串参数解析为你需要的类型。以下是一些常见的方法参数类型及其解析示例：

*  整数类型（`int`）：

public static void main(String[] args) {
        
        int number = Integer.parseInt(args[0]);
        // 使用 number 进行操作
    }

*  浮点数类型（`double`）：

public static void main(String[] args) {
        
        double value = Double.parseDouble(args[0]);
        // 使用 value 进行操作
    }

*  布尔类型（`boolean`）：

public static void main(String[] args) {
        
        boolean flag = Boolean.parseBoolean(args[0]);
        // 使用 flag 进行操作
    }

*  自定义类型：  
    如果你希望传入自定义类型的参数，你可以将命令行传入的字符串参数解析为该自定义类型的实例。例如，假设你有一个自定义的 `Person` 类：

public class Person {
        
        private String name;
        // 其他属性和方法
    
        public Person(String name) {
        
            this.name = name;
        }
    }
    
    public static void main(String[] args) {
        
        String name = args[0];
        Person person = new Person(name);
        // 使用 person 进行操作
    }

在这个示例中，我们将命令行传入的字符串参数解析为 `name`，然后使用 `name` 创建了一个 `Person` 对象。

`main` 方法的参数类型只能是 `String[]`，但你可以将命令行传入的字符串参数解析为你需要的其他类型。常见的解析包括整数类型、浮点数类型、布尔类型，以及自定义类型。你可以根据需要解析并使用这些参数，以便在 `main` 方法中进行相应的操作。

#### 6.2 非main方法 ####

在 `Java 的非 main` 方法中，可以接受各种类型的数组作为参数。以下是一些常见的数组类型：

基本类型数组：可以接受 `int[]、double[]、boolean[]、char[]` 等基本类型的数组。

public void processIntArray(int[] array) {
        
        // 处理 int 数组
    }

*  引用类型数组：可以接受包括类、接口和数组在内的各种引用类型的数组。

public void processStringArray(String[] array) {
        
        // 处理 String 数组
    }

*  多维数组：可以接受多维数组，如 `int[][]、String[][][]` 等。

public void processTwoDimensionalArray(int[][] array) {
        
        // 处理二维 int 数组
    }

*  泛型数组：可以接受泛型数组，如 `ArrayList<Integer>[]、List<String>[]` 等。

public void processGenericArray(ArrayList<Integer>[] array) {
        
        // 处理泛型数组
    }

在 `Java` 中，数组是传值的，而不是传引用。这意味着在方法中修改传入的数组，不会影响到原始数组。如果需要在方法中修改数组并使其在方法调用结束后保持变化，可以考虑返回一个新的数组或使用类似于 `List` 的可变长度集合。

### 7、import调用包 ###

> 在`java`中调用某一个包，有哪些情况，需要下载这些包吗？

*  `JDK内置包`：`Java Development Kit (JDK)` 内置了许多常用的包，如`java.util、java.io、java.lang`等。你无需下载或安装这些包，可以直接在`Java`程序中引用它们。
 *  标准库包：`Java`标准库提供了大量的功能丰富的包，如`java.net、java.sql、java.awt`等。这些包也是与`JDK`一起提供的，你无需额外下载或安装它们，只需要通过`import`语句引入即可使用。
 *  第三方库/框架包：`Java`社区中有许多开源的第三方库和框架，提供了各种功能的扩展和增强。这些库通常不包含在`JDK或Java`标准库中，你需要从它们的官方网站或`Maven`中央仓库等渠道下载相应的库文件（`JAR`文件）。然后，在`Java`项目中使用构建工具（如`Maven或Gradle`）配置依赖关系，使得项目能够使用这些第三方库。

对于第三方库和框架，你需要确保下载的版本与你的项目兼容，并且遵循相应的使用和许可协议。

在`Java`中调用某个包的情况下，你可能需要下载相关的包文件，具体取决于包所属的类型。对于`JDK`内置包和`Java`标准库包，你无需额外下载，只需要正确引入即可。而对于第三方库和框架包，你需要下载相应的库文件，并在项目中进行配置和引用，以便使用其功能。

### 8、下载第三方库/框架包 ###

> 如何下载第三方库/框架包，有哪些下载地址和下载方法？如何查看下载的包是否和自己的开发环境匹配？

下载第三方库/框架包时，可以通过以下方式进行：

*  官方网站：许多第三方库和框架都会在其官方网站上提供下载链接。你可以访问相应的官方网站，找到并下载所需的库文件。通常，官方网站会提供详细的文档和说明，帮助你了解如何下载、配置和使用该库。
 *  `Maven`中央仓库：`Maven是Java`中常用的项目管理工具之一。`Maven`中央仓库是一个公共的存储库，包含了大量的第三方库和框架。你可以通过`Maven`的配置文件`（pom.xml）`中添加相应的依赖来下载所需的库文件。`Maven`会自动从中央仓库下载并管理依赖。
 *  `Gradle`依赖管理：`Gradle`是另一个常用的项目管理工具，与Maven类似。你可以通过`Gradle`的配置文件`（build.gradle）`中添加相应的依赖来下载所需的库文件。`Gradle`会自动从配置的仓库中下载并管理依赖。

在确定下载地址后，你可以使用以下方法来检查下载的包是否与你的开发环境匹配：

*  版本匹配：确保下载的包的版本与你的项目兼容。一般来说，官方网站或文档会提供相应的版本兼容性信息，你可以参考这些信息选择适合你的项目的版本。
 *  `JDK`版本：检查所下载的包是否与你正在使用的`JDK`版本兼容。通常，库的文档或说明中会指定所需的最低`JDK`版本。确保你的开发环境符合这个要求。
 *  `IDE`集成：如果你使用集成开发环境（`IDE）如Eclipse、IntelliJ IDEA`等，`IDE`通常提供了依赖管理的功能。你可以使用`IDE`的依赖管理工具（如`Maven或Gradle`插件）来下载和管理第三方库。这样可以确保所下载的包与你的项目和`IDE`环境完全兼容。