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

- 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环境完全兼容。

文章出处登录后可见！

已经登录？立即刷新