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

目录

1、经典程序解析

这是一个经典的

Java

程序，它使用了面向对象的编程风格：

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

第一行代码：

publicclassHelloWorld{

这行代码定义了一个名为

HelloWorld

的公共类（

public class

），该类是程序的入口点。

Java

程序中的每个类都必须以一个公共类来定义。文件名必须与公共类的名称相同，并以

.java

作为文件扩展名。

注：

String args[]

与

String[] args

都可以执行，但推荐使用

String[] args

，这样可以避免歧义和误读。

publicstaticvoidmain(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

字符串。也可以打印出来，可以作为简单的输入。

例如：

publicclassTest{publicstaticvoidmain(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

参数实现参数的传递(传递空格处理)

publicclassTest{publicstaticvoidmain(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

作为类的名称。

packagecom.example;publicclassClassA{// 引用ClassBcom.example.ClassB b =newcom.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

中的类，你可以按照以下方式进行引用：

packagecom.example.package1;importcom.example.package2.ClassB;publicclassClassA{publicvoiddoSomething(){ClassB b =newClassB();// 使用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），包含了方法要执行的代码块。在这个例子中，方法体内部没有给出具体的代码，你可以在这个代码块中添加你要执行的操作。

publicvoiddoSomething(){// 执行具体的操作// ...}

在这个示例中，

doSomething

方法被定义为公共方法（可以被其他类访问），它不返回任何值（

void

），并且没有接受任何参数。你可以在方法体中编写代码来执行特定的任务，可以是打印信息、计算结果、调用其他方法等。

例如，你可以在

doSomething

方法中实现某种功能，比如打印一条消息：

publicvoiddoSomething(){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

，并返回一个整数值：

publicintdoSomething(){// 执行具体的操作int result =42;// 假设执行操作后得到的结果是42return 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

中：

packagecom.example;publicclassA{publicstaticvoidmain(String[] args){B b =newB();// 创建B的实例
        b.doSomething();// 调用B的方法}}

在文件

B.java

中：

packagecom.example;publicclassB{publicvoiddoSomething(){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）：

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

• 浮点数类型（double）：

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

• 布尔类型（boolean）：

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

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

publicclassPerson{privateString name;// 其他属性和方法publicPerson(String name){this.name = name;}}publicstaticvoidmain(String[] args){String name = args[0];Person person =newPerson(name);// 使用 person 进行操作}

在这个示例中，我们将命令行传入的字符串参数解析为

name

，然后使用

name

创建了一个

Person

对象。

main

方法的参数类型只能是

String[]

，但你可以将命令行传入的字符串参数解析为你需要的其他类型。常见的解析包括整数类型、浮点数类型、布尔类型，以及自定义类型。你可以根据需要解析并使用这些参数，以便在

main

方法中进行相应的操作。

6.2 非main方法

在

Java 的非 main

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

基本类型数组：可以接受

int[]、double[]、boolean[]、char[]

等基本类型的数组。

publicvoidprocessIntArray(int[] array){// 处理 int 数组}

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

publicvoidprocessStringArray(String[] array){// 处理 String 数组}

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

publicvoidprocessTwoDimensionalArray(int[][] array){// 处理二维 int 数组}

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

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