菜鸟学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.javaClassB.java等。

com/
   example/
      ClassA.java
      ClassB.java

在这个例子中,com.example是包的名称,ClassA.javaClassB.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.package1com.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.javaB.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.javaB.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是固定的吗?它是公共的是什么意思?还有其他类型的选择吗?比如私有的,或者其他类型?

publicJava 中的一个访问修饰符(access modifier),用于控制类、方法、属性等的访问级别。它具有以下特点:

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

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

  • private: 表示私有的访问级别,只有同一个类内部可以访问和修改。被 private 修饰的类、方法或属性对其他类都不可见。

  • protected: 表示受保护的访问级别,只有同一个包内的类以及该类的子类可以访问和修改。对于不在同一个包中的类,除非是该类的子类,否则不能直接访问。

  • 默认(package-private): 如果没有指定访问修饰符,即没有使用 public、privateprotected,则默认为包级访问权限。表示只有同一个包中的类可以访问和修改。
    这些访问修饰符提供了不同级别的封装性,允许你控制类、方法和属性的可见性和可访问性。根据需求和设计原则,你可以选择适当的访问修饰符来限制对代码的访问。

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

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[]、List[] 等。
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环境完全兼容。

你可能感兴趣的:(java学习,java,jvm,开发语言)