方法或构造器的声明，声明了该方法或构造器的参数数目和类型。例如，以下是一种基于房屋贷款额，利率，贷款期限（期数）和贷款终值来计算房屋贷款的每月还款额的方法：

  1. public double computePayment(
  2.                   double loanAmt,
  3.                   double rate,
  4.                   double futureValue,
  5.                   int numPeriods) {
  6.     double interest = rate / 100.0;
  7.     double partial1 = Math.pow((1 + interest), 
  8.                     - numPeriods);
  9.     double denominator = (1 - partial1) / interest;
  10.     double answer = (-loanAmt / denominator)
  11.                     - ((futureValue * partial1) / denominator);
  12.     return answer;
  13. }

该方法有四个参数：贷款额，利率，终值和期数。前三个是双精度浮点数，第四个是整型。这些参数在方法主体中使用，并且在运行时将采用传入的参数的值。

注意： 参数是指方法声明中的变量列表。参数是调用该方法时传递的实际值。调用方法时，使用的参数必须在类型和顺序上与声明的参数匹配。

参数类型

您可以将任何数据类型用于方法或构造器的参数。如在computePayment方法中看到的那样，这包括基本数据类型（例如，双精度浮点数，单精度浮点数和整数），以及引用数据类型（例如，对象和数组）。
这是一个接受数组作为参数的方法的示例。在此示例中，该方法创建一个Polygon对象，并从Point对象数组对其进行初始化（假设Point是一个表示x，y坐标的类）：

  1. public Polygon polygonFrom(Point[] corners) {
  2.     // method body goes here
  3. }

注意： 如果要将方法传递给方法，请使用 lambda表达式或 方法引用。

任意数量的参数

您可以使用称为varargs的构造将任意数量的值传递给方法。当您不知道将向该方法传递多少特定类型的参数时，可以使用varargs。这是手动创建数组的快捷方式（以前的方法可能使用了varargs而不是数组）。
要使用varargs，请在最后一个参数的类型后加上省略号（三个点，…），然后是一个空格和参数名称。然后可以使用任意数量的该参数（包括无）调用该方法。

  1. public Polygon polygonFrom(Point... corners) {
  2.     int numberOfSides = corners.length;
  3.     double squareOfSide1, lengthOfSide1;
  4.     squareOfSide1 = (corners[1].x - corners[0].x)
  5.                      * (corners[1].x - corners[0].x) 
  6.                      + (corners[1].y - corners[0].y)
  7.                      * (corners[1].y - corners[0].y);
  8.     lengthOfSide1 = Math.sqrt(squareOfSide1);
  10.     // more method body code follows that creates and returns a 
  11.     // polygon connecting the Points
  12. }

您可以看到，在方法内部，corners被视为数组。可以使用数组或参数序列调用该方法。在任何一种情况下，方法主体中的代码均会将参数视为数组。
您通常会在打印方法中看到varargs。例如，printf方法：

  1. public PrintStream printf(String format, Object... args)

允许您打印任意数量的对象。可以这样：

  1. System.out.printf("%s: %d, %s%n", name, idnum, address);

或像这样

  1. System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone, email);

或使用其他数量的参数。

参数名称

在为方法或构造器声明参数时，请为该参数提供名称。在方法主体中使用该名称来引用传入的参数。
参数名称在其范围内必须唯一。它不能与相同方法或构造器的另一个参数的名称相同，也不能与方法或构造器中的局部变量的名称相同。
参数可以与类的字段之一具有相同的名称。如果是这种情况，则称参数为遮蔽（shadow）字段。遮蔽字段会使您的代码难以阅读，并且通常仅在设置特定字段的构造器和方法中使用。例如，考虑以下Circle类及其setOrigin方法：

  1. public class Circle {
  2.     private int x, y, radius;
  3.     public void setOrigin(int x, int y) {
  4.         ...
  5.     }
  6. }

Circle类有三个字段：x，y，和radius。setOrigin方法有两个参数，每个参数与一个字段具有相同的名称。每个方法参数遮蔽共享其名称的字段。因此，在方法主体内使用的简单名称x或y是参数，而不是字段。要访问字段，必须使用限定名称。本课程稍后将在标题为“使用this关键字” 的部分中对此进行讨论。

传递基本数据类型参数

基本类型参数（例如int或double）通过传递值到方法中。这意味着对参数值的任何更改仅存在于方法范围内。方法返回时，参数消失，对它们的任何更改都将丢失。这是一个例子：

  1. public class PassPrimitiveByValue {
  3.     public static void main(String[] args) {
  5.         int x = 3;
  7.         // invoke passMethod() with 
  8.         // x as argument
  9.         passMethod(x);
  11.         // print x to see if its 
  12.         // value has changed
  13.         System.out.println("After invoking passMethod, x = " + x);
  15.     }
  17.     // change parameter in passMethod()
  18.     public static void passMethod(int p) {
  19.         p = 10;
  20.     }
  21. }

运行此程序时，输出为：

  1. After invoking passMethod, x = 3

传递引用数据类型参数

引用数据类型参数（例如对象）也通过值传递到方法中。这意味着当方法返回时，传入的引用仍然引用与以前相同的对象。但是，如果对象的字段的值具有适当的访问级别，则可以在方法中更改它们。
例如，考虑任意类中移动Circle对象的方法：

  1. public void moveCircle(Circle circle, int deltaX, int deltaY) {
  2.     // code to move origin of circle to x+deltaX, y+deltaY
  3.     circle.setX(circle.getX() + deltaX);
  4.     circle.setY(circle.getY() + deltaY);
  6.     // code to assign a new reference to circle
  7.     circle = new Circle(0, 0);
  8. }

使用以下参数调用该方法：

  1. moveCircle(myCircle, 23, 56)

在方法内部，circle最初指myCircle。该方法将circle引用对象（即myCircle）的x和y坐标分别更改为23和56。当方法返回时，这些更改将保留。然后使用circle对新Circle对象的引用赋值x = y = 0。但是，这种重新赋值没有永久性，因为引用是按值传递的并且不能更改。在该方法内，circle指向的对象已更改，但是当该方法返回时，myCircle仍引用与Circle调用该方法之前相同的对象。