我在VScode学Java（Java方法method）

我的个人博客主页：如果’'真能转义1️⃣说1️⃣的博客主页
关于Java基本语法学习---->可以参考我的这篇博客：《我在VScode学Java》

类似于C语言中的宏定义：

静态成员： Java 中的静态成员可以在类加载时进行初始化，然后在整个应用程序中共享。类似于 C 语言中的宏，你可以使用静态成员来实现一些预定义的值或函数。例如：

public class Constants {
    public static final int MAX_VALUE = 100;
    public static final String APP_NAME = "MyWrJava";
}

1
2
3
4
5

名词：

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)：

格式：返回类型 方法名(参数类型1 参数名1, 参数类型2 参数名2, ...)、

方法签名用于区分不同的方法，并且在Java中是识别方法的的唯一标识。它由方法的名称和参数列表组成。
1

方法名称：用于标识方法的操作或行为。
参数列表（parameter list）：包含了方法接受的输入参数的类型、顺序和数量。

使用方法签名可以实现方法的重载。
【即：同一个类中可以定义多个具有相同名称但参数列表不同的方法。编译器可以通过比较从而确定调用哪个方法。】

实参必须与方法签名中定义的参数在次序和数量上匹配，在类型上兼容。

方法调用时在次序和数量上提供的实际参数（actual parameter，即传递给方法的值）必须与方法签名中定义的参数在次序和数量上匹配并且它们之间在类型上也要兼容。

类型兼容是指不需要经过显式的类型转换，实参的值就可以传递给形参，传递给方法的实参的类型应该与方法签名中定义的参数的类型兼容。

例如：可以将int类型的实参值传递【通过值传递(pass-by- value)】给double类型的形参，因为double类型可以容纳更广范围的数值，所以不需要显式的类型转换。

然而，如果实参的类型无法通过隐式类型转换与形参的类型兼容【即：顺序或数量上的不匹配】，那么编译器将会报错。
在这种情况下，需要进行显式的类型转换，将实参的类型转换为形参所需的类型，以使其兼容。

方法(method) --> 一段封装了特定功能的可重用代码块

在Java中，方法通常被定义在类中，并且可以被其他类和方法调用。这使得程序员可以将常用可重用功能代码封装成方法。大大提高了代码的复用性、可读性和可维护性；以便在程序中多次使用，能够被独立地编写、测试和维护。

在Java中，方法是一种更高层次的代码组织方式下的一个功能模块，它可以将多个语句和表达式组成的独立代码块【而不是最小的执行单元】，并通过给定的输入参数和返回值(return value)来与其他代码进行交互。

通过访问修饰符（public、private、protected等）来限制方法的访问权限。默认情况下，在同一个包中的其他类可以访问该方法。
Java方法可以被重载，这意味着可以定义具有相同名称但不同参数列表的多个方法。
	根据传递给方法的参数的类型、数量，Java编译器将自动确定要调用哪个方法。

Java中，方法可以是静态的或实例化的。静态方法属于类本身，而不是类的任何特定实例。
	因此，它们不能访问非静态成员变量或非静态方法。
	实例化方法属于类的实例，它们可以访问实例变量和其他实例化方法。

Java中，方法可以递归调用，即方法调用自身。递归通常用于解决可以分解为更小子问题。
	例如计算斐波那契数列或树形数据结构的遍历等。
1
2
3
4
5
6
7
8
9
10

方法的定义通常包括方法名、输入参数列表、返回类型和方法体。方法的调用可以通过使用方法名和传递参数来实现，并且可以在方法体中使用参数列表中的参数。

此外，Java方法还可以接收参数和返回值，这使得方法可以根据实际情况中不同的输入参数执行不同的操作并返回不同的结果，从而提高了程序的灵活性和可扩展性。
方法可以有返回值，返回值类型(return type)必须在方法声明时指定。 如果方法没有返回值，则返回类型应该用void表示。

public int add(int x, int y) {
    return x + y;
}
int result = add(3, 5);
1
2
3
4

【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;
  }
}
1
2
3
4
5
6
7
8
9
10
11

我们定义了一个名为add的方法，该方法接受两个整数参数并返回它们的和。在main方法中，调用add方法并将其返回值存储在result变量中，然后将其打印到控制台上。

【3】方法的格式

在上面的例子中，方法名称是 add，参数列表是 (int a, int b)，返回类型是 int，方法体是包含了两个整数相加的代码块。
1

方法名称：方法的名称应该能够清楚地描述该方法的功能。方法名称通常以小写字母开头，并使用驼峰式命名法。

参数列表：参数是方法接受的输入。参数列表是用圆括号括起来的，其中包含零个或多个参数。每个参数有其类型和名称组成，参数之间用逗号分隔。

返回类型：方法的输出，方法可以返回一个值。返回类型指定了返回值的类型。 如果方法没有返回值，则返回类型为 void。

方法体：方法体包含了方法的实际代码。方法体由一对花括号括起来。

[ 0 ] Java中main()方法的格式为什么是固定不变的？

Java中main()方法的格式_固定为 public static void main(String[] args)
	是因为这是Java虚拟机（JVM）在执行Java程序时的入口方法约定。
1
2

具体原因如下：

1. 方法名必须为"main"：JVM在执行Java程序时，会从指定的类中查找名为"main"的方法作为程序的入口点。如果没有名为"main"的方法，JVM就无法启动程序。

2. 返回值类型为void：main()方法的返回值类型必须为void，即不返回任何结果。这是因为JVM在执行main()方法后，并不关注其返回结果，而是根据程序中的其他代码逻辑来决定程序的执行流程。

3. 参数列表为String数组：main()方法的参数列表中只有一个参数，即String数组。这个参数用于接收命令行传递给程序的参数，例如运行java MyProgram arg1 arg2时，arg1和arg2将被作为String数组的元素传递给main()方法的参数args。

4. 方法修饰符为public和static：由于main()方法作为程序的入口方法，需要被JVM直接调用，所以必须使用public修饰符使其对外可见。另外，JVM在执行main()方法时，并不需要创建类的实例，因此main()方法必须声明为static静态方法。

综上所述，Java中main()方法的格式被固定为public static void main(String[] args)是为了满足JVM对程序入口点的要求，并使得程序能够被正确地执行。这种格式的统一规定也方便开发者编写和维护Java程序。

[ 1 ] 普通方法的定义与调用格式–>注意:方法必须先定义后调用，否则程序将报错

//方法定义
public static void 方法名(){
	方法体(就是打包起来的代码);
}
//方法调用
方法名();
1
2
3
4
5
6

[ 2 ]带参数的方法定义和调用

（1）带参数的方法定义和调用有以下几个好处：

代码重用性：确定好方法如何定义和调用编写好可重用的代码。当该方法接受参数并执行指定操作，其在程序中的多个位置可以调用该方法，并将不同的参数传递给它。

代码可读性：带参数的方法定义和调用可以使代码更易于阅读和理解。通过在方法定义中包含参数，清楚地表达该方法的目的和预期输入；清楚地看到传递给该方法的值。

代码灵活性：带参数的方法定义和调用可以使代码更加灵活。通过在方法定义中包含参数，轻松地更改该方法的行为，而无需更改方法的实现。通过在调用该方法时传递不同的参数，轻松地更改该方法的行为，以适应不同的情况。

（2）Java回传参数是不需要类型的吗

根据Java的语法，方法的参数需要指定类型。这是为了确保编译器可以在编译时检查参数的类型是否正确。想要在方法中返回一个值，需要指定返回值的类型。

（3）举例

public static void method(int num1,int num2）{
	int result = num1 + num2;
	System.out.printIn(result);
}
1
2
3
4

（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)
1
2
3
4
5
6
7
8
9
10
11
12
13

完整格式：

public static 返回值类型 方法名 (参数){
    方法体;
return 返回值;
}
1
2
3
4

（5）形参和实参

注意:方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应，否则程序将报错。
	区别于Python的方法调用Java是不能通过关键字参数【键--值】调用方法
1
2

形参: _形式参数 (formal parameter)，是指方法定义中的参数
实参:_实际参数 (actual parameter)，方法调用中的参数

（6）带返回值方法的定义和调用

public static int getSum(int a, int b) {
	int c=a+b;
	return c;
}
1
2
3
4

（7）带返回值方法的调用f方式

直接调用：方法名(实参);
赋值调用:整数类型 变量名 = 方法名 (实参);
输出调用:System.out.println(方法名 (实参));

【5】方法的注意事项

1. 如果不调用方法，它将不会执行。因此，如果您编写了一个方法但从未调用它，它将不会对程序产生任何影响。
2. 在Java中，方法与方法之间是平级关系，不能互相嵌套定义。如果您需要在一个方法中调用另一个方法，可以在该方法中调用该方法。
3. 方法的编写顺序和执行顺序无关。您可以在程序中的任何位置编写方法，并且可以在程序的任何位置调用它们。
4. 方法的返回值类型(return type)为void，表示该方法没有返回值。如果您的方法不需要返回任何值，则应将其返回类型设置为void。在这种情况下，可以省略return语句不写。如果您要编写return语句，则不能跟具体的数据。
5. 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;
    }
}
1
2
3
4
5
6
7
8
9

假设我们有一个类Calculator，其中定义了两个方法add，分别接受两个整数和两个浮点数作为参数：

Calculator calculator = new Calculator();
int result1 = calculator.add(1, 2);
double result2 = calculator.add(1.0, 2.0);
1
2
3

需要注意的是，方法的重载只与参数列表有关，与方法的返回值类型(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;
    }
}
1
2
3
4
5
6
7
8
9
10

【2】注意事项：

Java虚拟机会通过参数的不同来区分同名的方法

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， 2);
	sum(1， 20， 30);
}
1
2
3
4
5
6

在方法重载 (method overloading)中，需要注意以下几点：

参数列表不同包括参数的类型、个数、顺序不同。
1

方法名相同，参数列表不同，但是返回值类型(return type)和访问修饰符可以不同。
在调用方法时，编译器会根据传入的参数列表的不同来确定调用哪个方法。
如果两个方法的参数列表只有返回值类型不同，那么这两个方法不能构成重载，会导致编译错误。

除此之外，还需要注意以下几点：

方法的重载只能在同一个类中进行。
方法的重载不能仅仅依靠参数的名称或者参数的类型、修饰符来区分。参数的个数和顺序也是需要考虑的。

方法的重载可以提高代码的复用性和可读性，但是需要注意不要滥用方法的重载，
	否则会导致代码难以维护和理解。
1
2
3
4
5

方法重载 (method overloading)的优点是：

更好的可读性：方法名是相同的，参数类型和个数不同，会使代码更加清晰易懂；
更好的灵活性：同样的方法名可以使用多次，不同的参数类型和个数可以满足不同的需求；
便于编程：避免了写很多的相似方法，提高了代码的复用性。

公共的（public）or静态的（static）

当我们创建一个类的对象时，实际上是在内存中分配了一块空间来存储该对象的属性和方法。公共方法是与对象实例相关联的，因此只有通过对象才能调用它们。这样做的好处是，我们可以在不同的对象实例之间共享方法的代码，但每个对象实例都可以具有自己的属性值。

相比之下，静态方法是与类本身相关联的，而不是与对象实例相关联的。静态方法可以在不创建类的对象的情况下直接调用。这是因为静态方法在类加载时就已经存在于内存中，不需要对象实例来访问它们。

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(); // 通过对象调用公共方法
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

对比得出：

静态方法可以在不创建类的对象的情况下直接调用，这是因为静态方法在类加载时就已经存在于内存中，不需要对象实例来访问它们。

在Java中，当类被加载到内存中时，静态方法也会被加载并存储在内存中。这意味着无需创建类的对象，就可以直接通过类名来调用静态方法。这是因为静态方法不依赖于对象的实例，而是与类本身相关联。

静态方法的存在有以下几个优点：

直接通过类名调用：由于静态方法与类本身相关联，而不是与对象实例相关联，因此可以直接通过类名调用静态方法，而无需创建类的对象。

共享代码：静态方法可以在不同的对象实例之间共享代码。这意味着多个对象实例可以使用相同的静态方法，而无需每个对象实例都拥有自己的方法副本。

无需访问对象属性：静态方法不可以访问对象的属性，因为它们不依赖于对象实例。这使得静态方法更加独立和可靠，可以在不考虑对象状态的情况下执行。

然而，需要注意的是，静态方法不能访问非静态成员变量和非静态方法，因为它们只能访问静态成员变量和静态方法。

方法怎么存储

大多数人都爱说：方法只能定义在类的里面，定义在类的外面那是不在三界之内，五行之中，是不被允许的
1

方法必须在类体里。从内存存储角度来说，java中找对应方法时，都是先找对应类实例，类实例是根据类来初始化内存的。如果方法在类外部，则无法找到该方法。

在Java中，方法存储在类文件中。当编写Java代码并将其编译时，编译器将生成一个类文件，其中包含该类的所有方法的字节码。这些字节码指示JVM在运行时如何执行方法。

如果您想查看类文件中的方法字节码，可以使用Java反编译器。例如，您可以使用javap命令来反编译类文件并查看其中的方法。

CursorCode给出的

以下是一个示例类文件的方法字节码：

public class Example {
  public static void main(String[] args) {
    System.out.println("Hello, world!");
  }
1
2
3
4

反编译后的字节码：

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}
1
2
3
4
5
6
7

基本数据类型与引用数据类型

基本数据类型：

整数类型、浮点数类型、布尔类型、字符类型。
>包括：byte、short、int、long、float、double、char和boolean。
1
2

在Java中，基本数据类型是按值存储的。当声明一个基本数据类型的变量时，计算机会为该变量分配一定的内存空间来存储它的值。

每个基本数据类型都有一个默认值。如果你没有为变量赋值，它将被初始化为其默认值。
例如：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';
1
2
3
4

引用数据类型： new出来的东西>地址值

引用数据类型包括类、接口、数组等。
>引用数据类型的变量实际上存储的是对象在内存中的地址。
1
2

引用数据类型的变量存储的是对象的引用，而不是对象本身。
这意味着，当我们创建一个对象时，实际上是在堆内存中分配了一块空间，并返回了一个指向该空间的引用。

怎么存储的

当我们声明一个引用类型变量时，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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在上面的示例中，我们创建了一个名为“person”的Person对象，并将其名称和年龄属性设置为“Alice”和25。然后，我们使用该对象的地址值来访问其属性。因此，引用数据类型的数据值存储在堆内存中，而变量本身只是存储了该对象的地址值。

从内存的角度来看 -->数据值是存储在其他空间中，自己空间中存储的是地址值。

引用数据类型的值存储在堆中，而不是在栈中。这意味着访问引用数据类型的值需要通过引用来访问，而不是直接访问。因此，访问引用数据类型的速度比访问基本数据类型的速度慢。

String myString = "Hello World";
Object myObject = new Object();
int[] myArray = {1, 2, 3, 4, 5};
1
2
3

在这个示例中，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;
    }
}
1
2
3
4
5

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));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

埃氏筛：

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Object中的成员方法

public boolean equals(Object obj)比较两个对象是否相等
protected object clone(int a)对象克隆

public String tostring(）反回对象的字符串表示形式

java.lang.Object public String toString()
Returns a string representation of the object.

想要看到对象内部的属性值就重写父类object类中的tostring方法