void 关键字本节说明如何声明和调用一个void方法。 下面的例子声明了一个名为printGrade的方法，并且调用它来打印给定的分数。
示例
public class TestVoidMethod {
public static void main(String[] args)
{ printGrade(78.5); }
public static void printGrade(double score) {
if (score >= 90.0) { System.out.println('A'); }
else if (score >= 80.0) { System.out.println('B'); }
else if (score >= 70.0) { System.out.println('C'); }
else if (score >= 60.0) { System.out.println('D'); }
else { System.out.println('F'); }
}}以上实例编译运行结果如下： C 这里printGrade方法是一个void类型方法，它不返回值。 一个void方法的调用一定是一个语句。 所以，它被在main方法第三行以语句形式调用。就像任何以分号结束的语句一样。 通过值传递参数 调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。 例如，下面的方法连续n次打印一个消息：
public static void nPrintln(String message, int n)
{
for (int i = 0; i < n; i++) System.out.println(message);
}示例 下面的例子演示按值传递的效果。 该程序创建一个方法，该方法用于交换两个变量。
public class TestPassByValue {
public static void main(String[] args) {
int num1 = 1;
int num2 = 2;
System.out.println("Before swap method, num1 is " + num1 + " and num2 is " + num2);
// 调用swap方法
swap(num1, num2);
System.out.println("After swap method, num1 is " + num1 + " and num2 is " + num2); }
/** 交换两个变量的方法 */
public static void swap(int n1, int n2) {
System.out.println("\tInside the swap method");
System.out.println("\t\tBefore swapping n1 is " + n1 + " n2 is " + n2);
// 交换 n1 与 n2的值
int temp = n1;
n1 = n2;
n2 = temp;
System.out.println("\t\tAfter swapping n1 is " + n1 + " n2 is " + n2);
}}以上实例编译运行结果如下：
Before swap method, num1 is 1 and num2 is 2 Inside the swap method Before swapping n1 is 1 n2 is 2 After swapping n1 is 2 n2 is 1After swap method, num1 is 1 and num2 is 2
传递两个参数调用swap方法。有趣的是，方法被调用后，实参的值并没有改变。 方法的重载 上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢 解决方法是创建另一个有相同名字但参数不同的方法，如下面代码所示：
public static double max(double num1, double num2) { if (num1 > num2) return num1; else return num2;}如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用； 如果传递的事double型参数，则double类型的max方法体会被调用，这叫做方法重载； 就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。 Java编译器根据方法签名判断哪个方法应该被调用。 方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。 重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
变量作用域变量的范围是程序中该变量可以被引用的部分。 方法内定义的变量被称为局部变量。 局部变量的作用范围从声明开始，直到包含它的块结束。 局部变量必须声明才可以使用。 方法的参数范围涵盖整个方法。参数实际上是一个局部变量。 for循环的初始化部分声明的变量，其作用范围在整个循环。 但循环体内声明的变量其适用范围是从它声明到循环体结束。它包含如下所示的变量声明： 你可以在一个方法里，不同的非嵌套块中多次声明一个具有相同的名称局部变量，但你不能在嵌套块内两次声明局部变量。命令行参数的使用 有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。 命令行参数是在执行程序时候紧跟在程序名字后面的信息。
实例 下面的程序打印所有的命令行参数：
public class CommandLine { public static void main(String args[]){
for(int i=0; i<args.length; i++){
System.out.println("args[" + i + "]: " +
args[i]);如下所示，运行这个程序：
java CommandLine this is a command line 200 -100
运行结果如下：
args[0]: thisargs[1]: isargs[2]: a args[3]: command args[4]: line args[5]: 200args[6]: -100
实例
下面是一个使用构造方法的例子：
// 一个简单的构造函数class MyClass {
int x;
// 以下是构造函数
MyClass() {
x = 10;
}}你可以像下面这样调用构造方法来初始化一个对象：
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.x + " " + t2.x);
}
}大多时候需要一个有参数的构造方法。
实例 下面是一个使用构造方法的例子：
// 一个简单的构造函数
class MyClass {
int x; // 以下是构造函数
MyClass(int i )
{
x = i;
}
}你可以像下面这样调用构造方法来初始化一个对象：
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass( 10 );
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + " " + t2.x); }}运行结果如下： 10 20
可变参数
JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。 方法的可变参数的声明如下所示： typeName... parameterName 在方法声明中，在指定参数类型后加一个省略号(...) 。 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
实例
public class VarargsDemo {
public static void main(String args[]) {
// 调用可变参数的方法
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3}); }
public static void printMax( double... numbers) {
if (numbers.length == 0) { System.out.println("No argument passed"); return; }
double result = numbers[0];
for (int i = 1; i < numbers.length; i++)
if (numbers[i] > result)
result = numbers[i];
System.out.println("The max value is " + result);
}
}以上实例编译运行结果如下：
The max value is 56.5The max value is 3.0
finalize() 方法Java允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做finalize( )，它用来清除回收对象。 例如，你可以使用finalize()来确保一个对象打开的文件被关闭了。 在finalize()方法里，你必须指定在对象销毁时候要执行的操作。 finalize()一般格式是： protected void finalize(){ // 在这里终结代码} 关键字protected是一个限定符，它确保finalize() 方法不会被该类以外的代码调用。 当然，Java的内存回收可以由JVM来自动完成。如果你手动使用，则可以使用上面的方法
实例
public class FinalizationDemo {
public static void main(String[] args) {
Cake c1 = new Cake(1);
Cake c2 = new Cake(2);
Cake c3 = new Cake(3);
c2 = c3 = null;
System.gc(); //调用Java垃圾收集器
}
}
class Cake extends Object {
private int id;
public Cake(int id) {
this.id = id;
System.out.println("Cake Object " + id + "is created");
}
protected void finalize() throws java.lang.Throwable { super.finalize();
System.out.println("Cake Object " + id + "is disposed");
}
}运行以上代码，输出结果如下：
C:\1>java FinalizationDemo Cake Object 1is created Cake Object 2is created Cake Object 3is created Cake Object 3is disposed Cake Object 2is disposed
以上就是【卓越教程】Java 方法（2）的内容，更多相关内容请关注PHP中文网（m.sbmmt.com）！
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
