La declaración de un método o constructor declara el número y el tipo de argumentos de ese método o constructor. Por ejemplo, a continuación veremos un método que calcula los pagos mensuales de una hipoteca basándose en el importe de la hipoteca, el tipo de interés, la duración (el número de cuotas) y el valor futuro de la hipoteca:

public double computePayment(double loanAmt,
                             double rate,
                             double futureValue,
                             int numPeriods) {
    double interest = rate / 100.0;
    double partial1 = Math.pow((1 + interest), -numPeriods);
    double denominator = (1 - partial1) / interest;
    double answer = (-loanAmt / denominator)
                    - ((futureValue * partial1) / denominator);
    return answer;
}
 

Este método tiene cuatro parámetros: el importe del crédito, el tipo de interés, el valor futuro y el número de períodos. Los primeros tres son números de coma flotante de doble precisión y el cuarto es un entero. Los parámetros se utilizan en el cuerpo del método y tomarán los valores de los argumentos pasados.

---

Nota : Parámeters se refiere a la lista de variables en la declaración de un método. Argumentos son los valores pasados cuando se invoca el método. Cuando se invoca un método los argumentos usados deben concordar con los parámetros de la declaración en tipo y orden.

---

Tipos de parámetros

Puede utilizar cualquier tipo de dato como parámetro de un método o constructor. Esto incluye tipos de dato primitivos, como «double», «float» e «integer», como hemos visto en el método computePayment, y tipos de datos de referencia, como objetos y arrays.

Este es un ejemplo de un método que acepta un array como argumento. En este ejemplo el método cra un nuevo objeto de tipo Polygon y lo inicializa desde un array de objetos Point (asumamos que Point es una clase que representa una coordenada xy):

public Polygon polygonFrom(Point[] corners) {
    // el cuerpo del método v aquí
}

---

Nota : El lenguaje de programación Java no permite pasar métodos a métodos. Pero puede pasar un objeto a un método y luego invocar los métodos del objeto.

---

Número arbitrario de argumentos

Podemos utilizar una construcción llamada varargs para pasar un número arbitrario de valores a un método. Se utiliza varargs cuando no sabemos cuántos elementos de un tipo en concreto se pasarán al método. Es un atajo para crear un array manualmente (el método anterior podría haber utilizado varargs en lugar de un array).

Para usar varargs se añaden al tipo del último parámetro tres puntos («...»), luego un espacio y el nombre del parámetro. Ahora el método puede ser invocado con cualquier número de ese parámetro, incluso ninguno.

public Polygon polygonFrom(Point... corners) {
    int numberOfSides = corners.length;
    double squareOfSide1, lengthOfSide1;
    squareOfSide1 = (corners[1].x - corners[0].x)*(corners[1].x - corners[0].x) 
                        + (corners[1].y - corners[0].y)*(corners[1].y - corners[0].y) ;
    lengthOfSide1 = Math.sqrt(squareOfSide1);
    // sigue más código del cuerpo del método que crea
    // y devuelve un polígono que conecta los Points
}
 

Puede ver que, dentro del método, corners es tratado como un array. Se puede llamar al método tanto con un array o con una secuencia de argumentos. El código del cuerpo del método tratará al parámetro como un array en cualquiera de los casos.

Verá con más frecuencia el uso de varargs en métodos de impresión; por ejemplo este método printf:

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

permite imprimir un número arbitrario de objetos. Se puede llamar también así:

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

o así

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

o con otro número distinto de argumentos.

Nombres de parámetros

Cuando declare un parámetro a un método o constructor debe proporcionar un nombre para ese parámetro. Este nombre se usa dentro del cuerpo del método para referirse al argumento recibido.

El nombre del parámetro debe ser único en su ámbito. No puede ser igual al nombre de otro parámetro o de una variable local dentro de ese método o constructor.

Un parámetro puede tener el mismo nombre que alguno de los campos de la clase. Si este es el caso, se dice que el parámetro sombrea al campo. Sombrear campos puede hacer que el código sea difícil de leer y solamente se utiliza, por convenio, dentro de constructores y métodos que fijan un campo en concreto. Por ejemplo, veamos la siguiente clase Circle y su método setOrigin:

public class Circle {
    private int x, y, radius;
    public void setOrigin(int x, int y) {
        ...
    }
}
 

La clase Circle tiene tres campos: x, y y radius. El método setOrigin tiene dos parámetros, cada uno de los cuales tiene el mismo nombre que uno de los campos. Cada parámetro del método sombrea al campo que comparte su nombre. Por lo que, al usar los nombres x ó y dentro del cuerpo del método nos referimos al marámtero, no al campo. Para acceder al campo deberá usar un nombre cualificado. Esto se comentará más adelante en esta lección en la sección titulada «Uso de la palabra clave this».

Pasar argumentos de tipo de dato primitivo

Los argumentos primitivos, como un int o un double se pasan a los métodos por valor. Esto significa que cualquier cambio en los valores de los parámetros solamente existe dentro del ámbito del método. Cuando el método vuelve, los parámetros han desaparecido y cualquier cambio se ha perdido. Veamos un ejemplo:

public class PassPrimitiveByValue {

    public static void main(String[] args) {
           
        int x = 3;
           
        //invocar passMethod() con x como argumento
        passMethod(x);
           
        // imprimir x para ver si su valor ha cambiado
        System.out.println("Después de invocar passMethod, x = " + x);
           
    }
        
    // cambiar el parámetro en passMethod()
    public static void passMethod(int p) {
        p = 10;
    }
}
 

Cuando ejecute este programa, la salida será:

Después de invocar passMethod, x = 3

Pasar argumentos de tipo de dato de referencia

Los tipos de dato de referencia, como los objetos, también se pasan a los métodos por valor. Esto significa que cuando el método vuelve, la referencia recibida sigue apuntando al mismo objeto que antes. Sin embargo los valores de los campos del objeto pueden ser modificados en el método si tienen el nivel de acceso adecuado.

Por ejemplo, veamos un método en una clase que mueve objetos de tipo Circle:

public void moveCircle(Circle circle, int deltaX, int deltaY) {
    // código para mover el origen de un círculo a  x+deltaX, y+deltaY
    circle.setX(circle.getX() + deltaX);
    circle.setY(circle.getY() + deltaY);
        
    //codigo para asignar una nueve referencia al círculo
    circle = new Circle(0, 0);
}
 

Invocamos al método con estos argumentos:

moveCircle(myCircle, 23, 56)
 

Dentro del método, circle inicialmente se refiere a myCircle. El método cambia las coordenadas x e y del objeto al que circle referencia (es decir, myCircle) a 23 y 56 respectivamente. Estos cambios persistirán cuando el método vuelva. Entonces a circle se le asigna una referencia a un nuevo objeto Circle con x = y = 0. Esta reasignación no es permanente, ya que la referencia se pasó por valor y no puede cambiar. Dentro del método el objeto al que apunta circle ha cambiado, pero, cuando el método vuelve, myCircle sige apuntando al mismo objeto Circle que antes de que se llamara al método.