名词：
《1》组
- 实际参数 (actual parameter)：在方法调用中实际传递给方法的值，也称为实参。
- 歧义调用 (ambiguous invocation)：当存在多个方法具有相同名称和参数类型，但返回类型不同或者无法准确匹配时，编译器无法确定要调用哪个方法，从而导致歧义调用。
- 分治 (divide and conquer)：一种问题解决方法，将问题划分为更小的子问题并逐步解决，然后将解决方案合并以获得原始问题的解决方案。
- 形式参数 (formal parameter)：在方法定义中声明的参数，也称为形参。它们是方法签名的一部分，用于接收方法调用中传递的实际参数的值。
- 信息隐藏 (information hiding)：一种面向对象编程的原则，通过封装将对象的内部状态和实现细节隐藏起来，只暴露必要的公共接口，以提高代码的可维护性和安全性。
- 方法 (method)：在面向对象编程中，一个方法是类或对象中执行特定任务的代码块。它用于封装操作和功能，并可以被其他代码重复使用。
- 方法抽象 (method abstraction)：一种将方法从其具体实现中分离出来的概念。它强调关注方法的目标、功能和行为，而不关注具体的实现细节。
- 方法重载 (method overloading)：在同一个类中定义多个具有相同名称但参数列表不同的方法。通过方法重载，可以根据传递给方法的参数的不同来选择调用哪个方法，以提供更灵活的方法调用。
《2》组
- 方法签名 (method signature)：方法的唯一标识，包括方法名称和参数列表。方法签名用于区分不同的方法。
- 修饰符 (modifier)：在Java中，修饰符用于修改类、方法、变量等的行为和属性。例如，
public、private、static等都是修饰符。 - 按值传递 (pass-by-value)：一种参数传递方式，在方法调用时，实参的值被复制到形参中，方法使用的是形参的副本而不是原始实参的引用。
- 参数 (parameter)：方法定义中的占位符，用于接收传递给方法的值。参数用于向方法提供输入，并在方法内部进行处理。
- 返回值类型 (return type)：方法定义中指定的数据类型，表示方法所返回的结果的类型。例如，
int、double、String等都可以作为返回值类型。 - 返回值 (return value)：方法执行完成后返回的值。根据方法定义的返回类型，方法可以通过使用
return语句来返回相应的值。 - 变量的作用域 (scope of variable)：变量的可见性和访问范围。变量的作用域决定了在何处可以访问和使用该变量。
- 待完善方法 (stub)：一个简单的、空的或未完全实现的方法，在软件开发中用作占位符，待后续完善其具体实现。通常用于测试、框架搭建等场景。
什么是方法签名(method signature)：
方法签名是指方法的唯一标识，它由方法的名称和参数列表组成。
方法签名用于区分不同的方法，并且在Java中是必须唯一的。
方法签名包括以下几个方面：
- 方法名称：方法的名称用于标识方法的操作或行为。
- 参数 (parameter)列表：参数列表包含了方法接受的输入参数的类型、顺序和数量。
使用方法签名可以实现方法的重载，即在同一个类中可以定义多个具有相同名称但参数列表不同的方法。通过对方法签名进行比较，编译器可以确定调用哪个方法。
以下是一个示例方法签名的格式：
返回类型 方法名(参数类型1 参数名1, 参数类型2 参数名2, ...)
**实参必须与方法签名中定义的参数在次序和数量上匹配，在类型上兼容。
类型兼容是指不需要经过显式的类型转换，实参的值就可以传递给形参
例如，将int型的实参值传递给double型形参。**：
方法调用时提供的实际参数（即传递给方法的值）必须与方法签名中定义的参数在次序和数量上匹配，并且它们之间在类型上也要兼容。
在次序和数量上匹配是指方法调用时实际参数 (actual parameter)的顺序和数量必须与方法定义中参数列表的顺序和数量一致。如果参数的次序或数量不匹配，编译器将会报错。
类型兼容是指传递给方法的实参的类型应该与方法签名中定义的参数的类型兼容。如果实参的类型与形参的类型不匹配，编译器通常会尝试进行隐式类型转换来使其兼容。例如，可以将int类型的实参值传递【通过值传递(pass-by- value)】给double类型的形参，因为double类型可以容纳更广范围的数值，所以不需要显式的类型转换。
然而，如果实参的类型无法通过隐式类型转换与形参的类型兼容，那么编译器将会报错。在这种情况下，需要进行显式的类型转换，将实参的类型转换为形参所需的类型，以使其兼容。
总结起来，警告表示在方法调用时，实参必须与方法签名中定义的参数在次序和数量上匹配，并且它们之间在类型上也要兼容，除非需要进行显式的类型转换。
Java方法method
参数列表：参数列表是方法的输入。每个参数都应该有一个类型和一个名称。参数列表用括号括起来，参数之间用逗号分隔。
返回类型：返回类型是方法的输出。如果方法不返回任何内容，则返回类型应该为void。否则，返回类型应该是方法返回的值的类型。
方法体：方法体是方法的实际代码。它应该包含在花括号中。
方法(method)—>一段封装了特定功能的可重用代码块
在Java中，方法是一种更高层次的代码组织方式，它可以将多个语句和表达式组合成一个独立的代码块，并通过输入参数和返回值(return value)来与其他代码进行交互。方法可以被看作是程序中的一个功能模块，它由多个语句和表达式组成，而不是最小的执行单元。【方法可以被看作是程序中的一个功能模块，它由多个语句和表达式组成，而不是最小的执行单元。】
Java方法可以带有参数列表，并且可以在方法体中使用这些参数。
方法可以有返回值，返回值类型(return type)必须在方法声明时指定。如果方法没有返回值，则返回类型应该用void表示。
通过访问修饰符（public、private、protected等）来限制方法的访问权限。默认情况下，在同一个包中的其他类可以访问该方法。
Java方法可以被重载，这意味着你可以定义具有相同名称但不同参数列表的多个方法。根据传递给方法的参数类型和数量，Java编译器将自动确定要调用哪个方法。
在Java中，方法可以是静态的或实例化的。静态方法属于类本身，而不是类的任何特定实例。因此，它们不能访问非静态成员变量或非静态方法。实例化方法属于类的实例，它们可以访问实例变量和其他实例化方法。
Java中的方法可以递归调用，即方法调用自身。递归通常用于解决可以分解为更小子问题的问题，例如计算斐波那契数列或树形数据结构的遍历等。
Java的方法起到了封装可重用代码的作用，大大提高了代码的。在Java中，方法可以被其他类和方法调用，这使得程序员可以将常用的功能封装成方法，以便在程序中多次使用。
使用方法还有助于提高程序的可读性和可维护性，因为方法的代码块可以被独立地编写、测试和维护。
此外，Java方法还可以接收参数和返回值，这使得方法可以根据不同的输入参数执行不同的操作并返回不同的结果，从而提高了程序的灵活性和可扩展性。
public int add(int x, int y) {
return x + y;
}
int result = add(3, 5);
在Java中，方法通常被定义在类中，并且可以被其他类和方法调用。方法的定义通常包括方法名、输入参数列表、返回类型和方法体。方法的调用可以通过使用方法名和传递参数来实现。
【1】主方法；访问控制权限是公有的（public），是静态的，没有返回值，只能使用 void，一个类只能有一个 main() 方法。【没有main方法是不能运行的;】
（1）在Java中，main方法是程序的入口点。当您运行Java应用程序时，JVM会查找main方法并从那里开始执行程序public static void main(String[] args)
其中，public表示该方法可以从任何地方访问，static表示该方法属于类而不是对象，void表示该方法不返回任何值，main是方法名，String[] args是一个字符串数组，它包含命令行参数。
（2）在Java中，主方法是指在一个类中定义的main方法。每个Java应用程序都必须有一个主方法，否则JVM将无法运行应用程序。在一个Java应用程序中，可以有多个类，但只能有一个类包含main方法。
【2】方法调用
在Java中，方法调用是指在程序中调用方法以执行特定任务的过程。当程序执行到方法调用语句时，它会跳转到方法的定义并执行方法中的代码。当方法完成后，程序将返回到方法调用语句并继续执行下一条语句。
methodName(argument1, argument2, ..., argumentN);
methodName是要调用的方法的名称，argument1, argument2, …, argumentN是传递给方法的参数。如果方法不需要参数，则括号中不需要包含任何内容。
在Java中，方法可以返回一个值或不返回任何值。如果方法返回一个值，则必须在方法定义中指定返回类型。返回类型可以是任何Java数据类型，例如int，double，String等。如果方法不返回任何值，则返回类型必须为void。
public class MyClass {
public static void main(String[] args) {
int result = add(5, 10);
System.out.println(result);
}
public static int add(int a, int b) {
int sum = a + b;
return sum;
}
}
我们定义了一个名为addNumbers的方法，该方法接受两个整数参数并返回它们的和。在main方法中，我们调用addNumbers方法并将其返回值存储在result变量中，然后将其打印到控制台上。
【3】方法的格式
方法名称：方法的名称应该能够清楚地描述该方法的功能。方法名称通常以小写字母开头，并使用驼峰式命名法。
参数列表：参数是方法接受的输入。参数列表是用括号括起来的，其中包含零个或多个参数。每个参数由其类型和名称组成，中间用空格分隔。参数之间用逗号分隔。
返回类型：方法可以返回一个值。返回类型指定了返回值的类型。如果方法不返回任何值，则返回类型为 void。
方法体：方法体包含了方法的实际代码。方法体由一对花括号括起来。
public int add(int a, int b) {
int sum = a + b;
return sum;
}
//在这个例子中，方法名称是 add，参数列表是 (int a, int b)，返回类型是 int，方法体是包含了两个整数相加的代码块。
[ 0 ]J ava中main()方法的格式为什么是固定不变的？
Java中main()方法的格式被固定为`public static void main(String[] args)`是因为这是Java虚拟机（JVM）在执行Java程序时的入口方法约定。
具体原因如下：
-
方法名必须为"main"：JVM在执行Java程序时，会从指定的类中查找名为"main"的方法作为程序的入口点。如果没有名为"main"的方法，JVM就无法启动程序。
-
返回值类型为void：main()方法的返回值类型必须为void，即不返回任何结果。这是因为JVM在执行main()方法后，并不关注其返回结果，而是根据程序中的其他代码逻辑来决定程序的执行流程。
-
参数列表为String数组：main()方法的参数列表中只有一个参数，即String数组。这个参数用于接收命令行传递给程序的参数，例如运行
java MyProgram arg1 arg2时，arg1和arg2将被作为String数组的元素传递给main()方法的参数args。 -
方法修饰符为public和static：由于main()方法作为程序的入口方法，需要被JVM直接调用，所以必须使用public修饰符使其对外可见。另外，JVM在执行main()方法时，并不需要创建类的实例，因此main()方法必须声明为static静态方法。
综上所述，Java中main()方法的格式被固定为public static void main(String[] args)是为了满足JVM对程序入口点的要求，并使得程序能够被正确地执行。这种格式的统一规定也方便开发者编写和维护Java程序。
[ 1 ] 普通方法的定义与调用格式---->注意:方法必须先定义后调用，否则程序将报错
//方法定义
public static void 方法名(){
方法体(就是打包起来的代码);}
//方法调用
方法名();
[ 2 ]带参数的方法定义和调用
（1）带参数的方法定义和调用有以下几个好处：
代码重用性：带参数的方法定义和调用可以使您编写可重用的代码。您可以编写一个方法，该方法接受参数并执行某些操作。然后，您可以在程序中的多个位置调用该方法，并将不同的参数传递给它。
代码可读性：带参数的方法定义和调用可以使您的代码更易于阅读和理解。通过在方法定义中包含参数，您可以清楚地表达该方法的目的和预期输入。在调用该方法时，您可以清楚地看到传递给该方法的值。
代码灵活性：带参数的方法定义和调用可以使您的代码更加灵活。通过在方法定义中包含参数，您可以轻松地更改该方法的行为，而无需更改方法的实现。通过在调用该方法时传递不同的参数，您可以轻松地更改该方法的行为，以适应不同的情况。
（2）java回传参数是不需要类型的吗
根据Java的语法，方法的参数需要指定类型。这是为了确保编译器可以在编译时检查参数的类型是否正确。如果您想要在方法中返回一个值，您需要指定返回值的类型。
（3）举例
public static void method(int num1,int num2）{
int result = num1 + num2;
System.out.printIn(result);}
（4）格式
//方法定义（单个参数）
public static void 方法名( 参数) ... ...
public static void method(int number){ ...}
//多个参数
public static void 方法名( 参数1，参数2,..。 ...）{....}
public static void getSum(int number1, intnumber2 ){。。。}
//方法使用（单个参数）
方法名( 参数)；
method(变量);
（多个参数）
getSum(变量1，变量2)
注意:
方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应，否则程序将报错。
（5）形参和实参
形参:全称形式参数 (formal parameter)，是指方法定义中的参数
实参:全称实际参数 (actual parameter)，方法调用中的参数
注意:方法调用时，形参和实参必须一一对应，否则程序将报错。
（6）带返回值方法的定义和调用
public static 返回值类型 方法名 (参数){
方法体;
return 返回值;
}
public static int getSum(int a, int b) {
int c=a+b;
return c;}
（7）带返回值方法的调用f方式
直接调用：方法名(实参);
赋值调用:整数类型 变量名 = 方法名 (实参);
输出调用:System.out.println(方法名 (实参));
【4】方法的完整定义格式
public static返回值类型方法名 (参数) [
方法体;
return 返回值:
}
【5】方法的注意事项
-
如果您不调用方法，它将不会执行。因此，如果您编写了一个方法但从未调用它，它将不会对程序产生任何影响。
-
在Java中，方法与方法之间是平级关系，不能互相嵌套定义。如果您需要在一个方法中调用另一个方法，您可以在该方法中调用该方法。
-
方法的编写顺序和执行顺序无关。您可以在程序中的任何位置编写方法，并且可以在程序的任何位置调用它们。
-
方法的返回值类型(return type)为void，表示该方法没有返回值。如果您的方法不需要返回任何值，则应将其返回类型设置为void。在这种情况下，您可以省略return语句不写。如果您要编写return语句，则不能跟具体的数据。
-
return语句下面，不能编写代码，因为永远执行不到，属于无效的代码。如果您在return语句下面编写了代码，它将永远不会执行。
高质量的Java方法
方法名称应该清晰明了，能够准确地描述该方法的功能。
方法应该只做一件事情，并且应该尽可能短小精悍。如果方法太长或太复杂，就应该考虑将其拆分成更小的方法。
方法应该具有良好的可读性和可维护性。这意味着您应该使用有意义的变量名和注释，以便其他人可以轻松地理解您的代码。
方法应该具有良好的错误处理机制。这意味着您应该考虑可能出现的错误情况，并编写代码来处理这些情况。
方法应该具有良好的性能。这意味着您应该避免使用过多的循环或递归，并尽可能使用高效的算法和数据结构。
其他
始终使用驼峰命名法来命名变量、方法和类。
始终在代码块中使用大括号，即使代码块只有一行。
始终使用final关键字来声明不可变变量。
始终使用try-catch块来处理可能出现的异常。
始终使用Java标准库中提供的数据结构和算法，以便获得最佳性能和可读性。
return关键字
1.在Java中，return关键字用于结束方法并返回结果。如果一个方法没有返回值，你可以省略不写return关键字。但是，如果一个方法有返回值，你必须要写return关键字来表示结束方法和返回结果。
2.需要注意的是，如果一个方法有返回值，但是你没有在方法体中使用return关键字返回结果，Java会默认返回一个默认值。
方法的重载—>同一个类中，方法名相同，参数不同的方法。与返回值无关参数不同:个数不同、类型不同、顺序不同
方法的重载是指在==同一个类中，可以定义多个方法名相同但参数列表不同的方法。==这样做的好处是可以提高代码的复用性和可读性。
1.在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能
2.每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
【1】在Java中，方法的重载需要满足以下条件
方法名相同
参数列表不同（参数类型、参数个数、参数顺序不同）
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
}
假设我们有一个类Calculator，其中定义了两个方法add，分别接受两个整数和两个浮点数作为参数：
Calculator calculator = new Calculator();
int result1 = calculator.add(1, 2);
double result2 = calculator.add(1.0, 2.0);
需要注意的是，方法的重载只与参数列表有关，与方法的返回值类型(return type)和访问修饰符(modifier)【（public、private、protected等）】无关。因此，下面的代码是不合法的：
public class Calculator {
public int add(int a, int b) {
return a + b;
}
// 编译错误：与上一个方法的参数列表相同
public int add(int x, int y) {
return x + y;
}
}
【2】注意事项：
public class MethodDemo {
public static int sum (int a, int b) {return a + b;
public static int sum (int a, int b, int c) {return a + b + c;}
sum(1， 2a);
sum(1， 20，30);
}
在方法重载 (method overloading)中，需要注意以下几点：
方法名相同，参数列表不同，但是返回值类型(return type)和访问修饰符可以不同。
参数列表不同包括参数类型、参数个数、参数顺序不同。
在调用方法时，编译器会根据传入的参数类型和个数来确定调用哪个方法。
如果两个方法的参数列表只有返回值类型不同，那么这两个方法不能构成重载，会导致编译错误。
除此之外，还需要注意以下几点：
方法的重载只能在同一个类中进行。
方法的重载不能仅仅依靠参数的名称或者参数的修饰符来区分。
方法的重载不能仅仅依靠参数的类型来区分，参数的个数和顺序也是需要考虑的。
在实际编程中，方法的重载可以提高代码的复用性和可读性，但是需要注意不要滥用方法的重载，否则会导致代码难以维护和理解。
方法重载 (method overloading)的优点是：
更好的可读性：方法名是相同的，参数类型和个数不同，会使代码更加清晰易懂；
更好的灵活性：同样的方法名可以使用多次，不同的参数类型和个数可以满足不同的需求；
便于编程：避免了写很多的相似方法，提高了代码的复用性。
当我们创建一个类的对象时，我们实际上是在内存中分配了一块空间来存储该对象的属性和方法。公共方法是与对象实例相关联的，因此只有通过对象才能调用它们。这样做的好处是，我们可以在不同的对象实例之间共享方法的代码，但每个对象实例都可以具有自己的属性值。
相比之下，静态方法是与类本身相关联的，而不是与对象实例相关联的。静态方法可以在不创建类的对象的情况下直接调用。这是因为静态方法在类加载时就已经存在于内存中，不需要对象实例来访问它们。
public class MyClass {
// 静态方法
public static void myStaticMethod() {
System.out.println("这是一个静态方法");
}
// // 公共方法
// public void myPublicMethod() {
// System.out.println("这是一个公共方法");
// }
public static void main(String[] args) {
myStaticMethod(); // 可以直接调用静态方法
// MyClass myObj = new MyClass(); // 创建一个对象
// myObj.myPublicMethod(); // 通过对象调用公共方法
}
}
对比得出：
// 静态方法可以在不创建类的对象的情况下直接调用，这是因为静态方法在类加载时就已经存在于内存中，不需要对象实例来访问它们。
// 在Java中，当类被加载到内存中时，静态方法也会被加载并存储在内存中。这意味着无需创建类的对象，就可以直接通过类名来调用静态方法。这是因为静态方法不依赖于对象的实例，而是与类本身相关联。
静态方法的存在有以下几个优点：
// 直接通过类名调用：由于静态方法与类本身相关联，而不是与对象实例相关联，因此可以直接通过类名调用静态方法，而无需创建类的对象。
// 共享代码：静态方法可以在不同的对象实例之间共享代码。这意味着多个对象实例可以使用相同的静态方法，而无需每个对象实例都拥有自己的方法副本。
// 无需访问对象属性：静态方法不可以访问对象的属性，因为它们不依赖于对象实例。这使得静态方法更加独立和可靠，可以在不考虑对象状态的情况下执行。
// 然而，需要注意的是，静态方法不能访问非静态成员变量和非静态方法，因为它们只能访问静态成员变量和静态方法。
方法怎么存储
在Java中，方法存储在类文件中。当您编写Java代码并将其编译时，编译器将生成一个类文件，其中包含该类的所有方法的字节码。这些字节码指示JVM在运行时如何执行方法。
如果您想查看类文件中的方法字节码，可以使用Java反编译器。例如，您可以使用javap命令来反编译类文件并查看其中的方法。
CursorCode给出的
以下是一个示例类文件的方法字节码：
public class Example {
public static void main(String[] args) {
System.out.println("Hello, world!");
}
}
反编译后的字节码：
public class Example {
public static void main(java.lang.String[]);
Code:
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String Hello, world!
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return}
基本数据类型与引用数据类型
基本数据类型：
##整数类型、浮点数类型、布尔类型、字符类型。
在Java中，==基本数据类型是按值存储的。==这意味着当你声明一个基本数据类型的变量时，计算机会为该变量分配一定的内存空间来存储它的值。这些基本数据类型包括：byte、short、int、long、float、double、char和boolean。
每个基本数据类型都有一个默认值，如果你没有为变量赋值，它将被初始化为其默认值。例如，int类型的默认值为0，boolean类型的默认值为false。
从内存的角度来看
基本数据类型的值直接存储在栈中，而不是在堆中。这使得基本数据类型的访问速度更快，因为它们不需要通过引用来访问它们的值。
在Java中，这些基本数据类型都有对应的包装类，如Byte、Short、Integer、Long、Float、Double、Boolean和Character。这些包装类提供了许多有用的方法，例如将基本数据类型转换为字符串，以及将字符串转换为基本数据类型。
int myInt = 42;
double myDouble = 3.14159;
boolean myBoolean = true;
char myChar = 'a';
引用数据类型： new出来的东西,地址值
引用数据类型包括类、接口、数组等。
引用数据类型的变量存储的是对象的引用，而不是对象本身。这意味着，当我们创建一个对象时，实际上是在堆内存中分配了一块空间，并返回了一个指向该空间的引用。因此，引用数据类型的变量实际上存储的是对象在内存中的地址。
怎么存储的
当我们声明一个引用类型变量时，Java会为该变量分配一块内存空间，用于存储对象的引用。当我们创建一个对象时，Java会在堆内存中为该对象分配一块空间，并返回一个指向该空间的引用。我们可以将该引用赋值给变量，从而使变量指向该对象。当我们使用该变量时，Java会根据变量中存储的引用，找到该对象在内存中的位置，并对其进行操作。
怎么理解引用数据类型的数据值是存储在其他空间中自己空间中存储的是地址值。
根据Java的规定，基本数据类型的变量直接存储值，而引用数据类型的变量存储的是对象的地址值。这意味着，当我们创建一个对象时，Java会在堆内存中为该对象分配空间，并返回该对象的地址值。然后，我们可以使用该地址值来访问该对象。因此，引用数据类型的数据值存储在堆内存中，而变量本身只是存储了该对象的地址值。
//以下是一个示例，说明如何创建一个对象并访问其属性：
public class Person {
String name;
int age;
}
public class Main {
public static void main(String[] args) {
// 创建一个Person对象
Person person = new Person();
person.name = "Alice";
person.age = 25;
// 访问该对象的属性
System.out.println("Name: " + person.name);
System.out.println("Age: " + person.age);
}
}
在上面的示例中，我们创建了一个名为“person”的Person对象，并将其名称和年龄属性设置为“Alice”和25。然后，我们使用该对象的地址值来访问其属性。因此，引用数据类型的数据值存储在堆内存中，而变量本身只是存储了该对象的地址值。
从内存的角度来看—》数据值是存储在其他空间中，自己空间中存储的是地址值。
引用数据类型的值存储在堆中，而不是在栈中。这意味着访问引用数据类型的值需要通过引用来访问，而不是直接访问。因此，访问引用数据类型的速度比访问基本数据类型的速度慢。
String myString = "Hello World";
Object myObject = new Object();
int[] myArray = {1, 2, 3, 4, 5};
在这个示例中，myString是一个String类型的引用数据类型，myObject是一个Object类型的引用数据类型，myArray是一个int类型的数组，也是一个引用数据类型。
方法的值传递—>从内存角度看方法的值传递：Java中的参数传递是值传递，即方法中对参数的修改不会影响到原始变量的值
（1）根据Java的规则，所有参数都是通过值传递的。这意味着，当将一个原始类型或对象类型作为参数传递给方法时，实际上传递的是该值的副本。因此，如果在方法内部更改参数的值，则不会更改原始值。如果传递的参数是对象，则副本和原始对象引用相同的对象。因此，如果在方法内部更改对象的状态，则更改将反映在原始对象中。
（2）Java中的参数传递是值传递。从内存角度来看，当一个方法被调用时，会在栈内存中为该方法创建一个新的栈帧。该栈帧包含了该方法的参数、局部变量和返回值等信息。当参数被传递给方法时，实际上是将参数的值复制一份传递给方法，而不是将参数本身传递给方法。因此，方法中对参数的修改不会影响到原始变量的值。
举例几个代码：
GCD
public class PrimeNumbers {
public static int gcd(int a, int b) {
return b != 0 ? gcd(b, a % b) : a;
}
}
LCM
public class PrimeNumbers {
public static int gcd(int a, int b) {
return b != 0 ? gcd(b, a % b) : a;
}
public static int lcm(int a, int b) {
return a / gcd(a, b) * b;
}
public static void main(String[] args) {
System.out.println(gcd(12, 123));
}
}
埃氏筛：
import java.util.Scanner;
public class PrimeNumbers {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int max = 100000001;
int[] arr = new int[max];
int n = scanner.nextInt();
int cnt = 0;
for (int i = 1; i < max; i++) {
arr[i] = 1;
}
for (int i = 2; i <= n; i++) {
if (arr[i] == 1) {
System.out.println(i);
cnt++;
}
for (int j = i * i; j <= n; j += i) {
arr[j] = 0;
}
}
System.out.println(cnt);
}
}