1. 首页
  2. 博客
  3. 带参数的方法定义和调用

带参数的方法定义和调用

在 Java 中，可以通过在方法名后面添加参数列表来定义带参数的方法。例如，下面是一个接受两个整数参数并返回它们的和的方法定义：

public int add(int a, int b) {
    return a + b;
}

在调用该方法时，需要传递两个整数作为参数。例如，要计算 2 和 3 的和，可以这样调用该方法：

int sum = add(2, 3);

在这个例子中，参数 a 被赋值为 2，参数 b 被赋值为 3，方法返回 a + b 的结果 5，最后将 5 赋值给变量 sum。

值得注意的是，方法定义中的参数名只是一个标识符，用于在方法体内引用相应的参数值。在调用方法时传递的参数可以是任意的符合参数类型的表达式，不必与方法定义中的参数名相同。例如，下面的调用也是合法的：

int sum = add(2 + 2, 3 * 4);

在这个例子中，参数 a 被赋值为 4，参数 b 被赋值为 12，方法返回 a + b 的结果 16，最后将 16 赋值给变量 sum。

另外，Java 中的方法可以有多个参数，每个参数都必须指定其类型。例如，下面是一个接受一个字符串和一个整数参数的方法定义：

public void printInfo(String name, int age) {
    System.out.println("Name: " + name);
    System.out.println("Age: " + age);
}

在调用该方法时，需要传递一个字符串和一个整数作为参数。例如，要打印出姓名为 "Tom"，年龄为 18 的信息，可以这样调用该方法：

printInfo("Tom", 18);

在这个例子中，参数 name 被赋值为字符串 "Tom"，参数 age 被赋值为整数 18，方法体内的语句输出相应的信息。

如果方法有多个参数，它们必须按照定义顺序依次传递，或者使用参数名指定参数。例如，以下两种调用方式都是合法的：

printInfo("Tom", 18);
printInfo(age=18, name="Tom");

第一种方式按照定义顺序依次传递参数，第二种方式使用参数名指定参数，可以不按照定义顺序传递参数。但需要注意的是，使用参数名指定参数的方式必须指定所有参数，且不能出现多次指定同一个参数的情况。

在方法定义中，参数可以有不同的修饰符，例如 final 修饰符可以用于参数，表示该参数是只读的，不能在方法体内被修改。例如，下面是一个使用 final 修饰符的方法定义：

public void printName(final String name) {
    System.out.println("Name: " + name);
}

在调用该方法时，传递的字符串参数不能在方法体内被修改，例如下面的代码是非法的：

String myName = "Tom";
printName(myName);
myName = "Jerry"; // 编译错误：不能修改 final 参数

除了 final 修饰符外，Java 中还有其他修饰符可以用于参数，例如 final 和 varargs（可变参数）组合使用时的语法：

public void printItems(final String... items) {
    for (final String item : items) {
        System.out.println(item);
    }
}

该方法接受可变数量的字符串参数，并使用 for-each 循环输出每个参数的值。调用该方法时，可以传递任意数量的字符串参数，例如下面的代码：

printItems("apple", "banana", "orange");

在这个例子中，方法接受 3 个字符串参数，依次输出每个参数的值。如果需要，也可以不传递任何参数，此时方法接受一个空的字符串数组作为参数，例如：

printItems();

在这个例子中，方法没有接收任何参数，因此使用空的字符串数组作为参数。

Java 中还有一种特殊的参数叫做可变参数，可以使用 varargs 关键字来定义。可变参数允许方法接受任意数量的同类型参数，并将它们封装为一个数组。例如，下面是一个接受可变数量整数参数的方法定义：

public int sum(int... nums) {
    int result = 0;
    for (int num : nums) {
        result += num;
    }
    return result;
}

在调用该方法时，可以传递任意数量的整数参数，例如下面的代码：

int sum1 = sum(1, 2, 3, 4, 5);
int sum2 = sum(2, 4, 6);

在这个例子中，sum 方法接受任意数量的整数参数，并将它们封装为一个整数数组。方法体内使用 for-each 循环遍历数组并累加每个元素的值，最终返回累加的结果。

需要注意的是，在使用可变参数时，它必须是方法的最后一个参数，且只能出现一次。例如，以下方法定义是非法的：

public void foo(int... nums, String name) {
    // ...
}

在这个例子中，可变参数 nums 不是方法的最后一个参数，因此是非法的。

在 Java 中，方法还可以返回一个值，可以使用 return 关键字来指定方法的返回值。返回值的类型必须与方法定义中指定的返回类型相同，或者可以自动转换为该类型。例如，下面是一个接受两个整数参数并返回它们的和的方法定义：

public int sum(int a, int b) {
    return a + b;
}

在调用该方法时，可以将返回值保存到一个变量中，例如下面的代码：

int result = sum(3, 4);
System.out.println(result); // 输出 7

在这个例子中，sum 方法返回两个整数的和，使用 return 关键字指定返回值。在调用 sum 方法时，将返回值保存到一个整型变量 result 中，并输出该变量的值。

需要注意的是，如果方法返回值为 void，则不需要使用 return 关键字来指定返回值。例如，下面是一个不返回任何值的方法定义：

public void sayHello(String name) {
    System.out.println("Hello, " + name + "!");
}

在调用该方法时，不需要将返回值保存到变量中，例如下面的代码：

sayHello("Tom"); // 输出 "Hello, Tom!"

在这个例子中，sayHello 方法不返回任何值，因此不需要使用 return 关键字。

Java 中还有一种特殊的方法叫做构造方法（Constructor），它用于创建对象并初始化对象的成员变量。构造方法的名称必须与类名相同，且没有返回值类型，包括 void。当创建一个对象时，Java 会自动调用构造方法来初始化对象的成员变量。例如，下面是一个带有参数的构造方法的定义：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

在这个例子中，Person 类定义了一个带有两个参数的构造方法，用于初始化对象的 name 和 age 成员变量。在构造方法内部，可以使用 this 关键字来引用当前对象，例如：

public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

在这个例子中，this.name 和 this.age 表示当前对象的 name 和 age 成员变量，而 name 和 age 则是构造方法的参数。

当创建一个 Person 对象时，Java 会自动调用构造方法来初始化对象的成员变量，例如下面的代码：

Person person = new Person("Tom", 20);

在这个例子中，创建了一个 Person 对象，并将 "Tom" 和 20 作为参数传递给构造方法，用于初始化对象的 name 和 age 成员变量。

除了普通的构造方法，Java 中还有一种特殊的构造方法叫做默认构造方法（Default Constructor），也称为无参构造方法。如果一个类没有显式定义构造方法，Java 会自动提供一个默认构造方法。默认构造方法没有参数，也没有方法体，仅用于创建对象。例如，下面是一个没有显式定义构造方法的类：

public class Person {
    private String name;
    private int age;

    // 没有显式定义构造方法
}

在这个例子中，Person 类没有显式定义构造方法，因此 Java 会自动提供一个默认构造方法。

当创建一个 Person 对象时，Java 会自动调用默认构造方法来创建对象，例如下面的代码：

Person person = new Person();

在这个例子中，创建了一个 Person 对象，并自动调用默认构造方法来创建对象。由于默认构造方法没有方法体，因此创建的对象没有任何成员变量的值，即 name 和 age 成员变量的值为默认值 null 和 0。如果需要初始化成员变量的值，可以通过显式定义构造方法来实现。

除了构造方法，Java 中还有一种特殊的方法叫做静态方法（Static Method），也称为类方法。静态方法不需要创建对象就可以直接调用，可以通过类名来调用。静态方法常用于执行不依赖对象状态的操作，例如工具类中的常用方法等。静态方法使用 static 关键字来修饰，例如下面是一个静态方法的定义：

public class MathUtils {
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
}

在这个例子中，MathUtils 类定义了一个静态方法 max，用于返回两个整数中的最大值。在方法定义中，使用 static 关键字来修饰方法，表示该方法是静态方法。

在调用静态方法时，可以通过类名来直接调用，例如下面的代码：

int maxNum = MathUtils.max(3, 5);
System.out.println(maxNum); // 输出 5

在这个例子中，使用 MathUtils.max 来调用静态方法 max，并将返回值保存到一个整型变量 maxNum 中，并输出该变量的值。

需要注意的是，静态方法不能直接访问非静态成员变量和非静态方法，因为静态方法在调用时并不依赖对象的状态，只能访问静态成员变量和静态方法。

除了普通的方法和静态方法，Java 中还有一种特殊的方法叫做抽象方法（Abstract Method）。抽象方法没有方法体，只有方法声明，用于声明方法的签名和返回值类型，具体的实现由子类来完成。如果一个类包含抽象方法，那么该类必须被声明为抽象类（Abstract Class）。抽象方法使用 abstract 关键字来修饰，例如下面是一个抽象方法的定义：

public abstract class Shape {
    public abstract double getArea();
}

在这个例子中，Shape 类定义了一个抽象方法 getArea，用于返回图形的面积。在方法定义中，使用 abstract 关键字来修饰方法，表示该方法是抽象方法。由于该类包含抽象方法，因此该类必须被声明为抽象类。

如果一个类继承自一个抽象类，那么该类必须实现所有抽象方法，否则该类也必须被声明为抽象类。例如下面是一个继承自 Shape 抽象类的子类 Rectangle：

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getArea() {
        return width * height;
    }
}

在这个例子中，Rectangle 类继承自抽象类 Shape，并实现了抽象方法 getArea，用于返回矩形的面积。由于 Rectangle 类实现了所有抽象方法，因此不需要被声明为抽象类。

在 Java 中，还有一种方法叫做 final 方法（Final Method）。final 方法不能被子类重写，可以使用 final 关键字来修饰方法。final 方法通常用于确保方法的实现不被修改，以确保代码的安全性和可靠性。例如下面是一个 final 方法的定义：

public class MyClass {
    public final void doSomething() {
        // do something
    }
}

在这个例子中，MyClass 类定义了一个 final 方法 doSomething，用于执行某些操作。在方法定义中，使用 final 关键字来修饰方法，表示该方法是 final 方法。

需要注意的是，final 方法只能在定义的时候确定，不能在运行时被修改。如果一个方法在定义的时候没有被声明为 final，那么子类可以通过重写该方法来修改它的实现。另外，final 方法只能在类中被定义，不能在接口中被定义。

Java 还有一种方法叫做静态方法（Static Method）。静态方法属于类，而不是对象，可以使用类名来调用，而不需要创建对象。静态方法通常用于工具类或者提供一些便捷的操作。在方法定义中，使用 static 关键字来修饰方法，例如下面是一个静态方法的定义：

public class MyClass {
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
}

在这个例子中，MyClass 类定义了一个静态方法 max，用于返回两个整数中的最大值。在方法定义中，使用 static 关键字来修饰方法，表示该方法是静态方法。可以通过类名来调用该方法，例如 MyClass.max(1, 2)。

需要注意的是，静态方法不能访问非静态成员，因为静态方法在没有创建对象的情况下就可以被调用，而非静态成员需要依赖于对象的存在。另外，静态方法不能被重写，因为它属于类而不是对象。

原文链接：codingdict.net

热门标签