Métodos De Java

Share

|

Se utilizan los métodos mientras que los bloques de edificio de su programa, realizando las tareas que se pueden llamar repetidas veces y con el mismo código para realizar la tarea cada vez. Las partes básicas pero fundamentales del declaración de un método son su nombre, su tipo de vuelta, firma del parámetro, y llaves del segmento de código. Las líneas siguientes del código son un ejemplo de un declaración del método.

doSomething() vacío de los parásitos atmosféricos {// 
agrega código aquí}

Este método se llama el doSomething y tiene un tipo de vuelta de vacío, que indica simplemente que el método no vuelve un valor. Hemos visto el vacío de la palabra clave ya, que es el tipo de vuelta de la cañería del método. Si el método doSomething fuera agregado a su clase principal del programa, entonces en el método principal de la clase usted llamaría el método doSomething introduciendo el código siguiente:

doSomething();

Observe las necesidades doSomething del método de ser estático en el momento porque la cañería del método, de la cual estamos asumiendo el método doSomething va a ser llamada, es también parásitos atmosféricos. El método doSomething no necesitaría ser estático si creáramos un caso de la clase a la cual el doSomething pertenecería.

Si usted desea un método que vuelva un valor, usted debe especificar el tipo de vuelta del método, y entonces usted debe utilizar la vuelta de la palabra clave en el bloque del código del método para especificar el valor vuelto.

getFiveDoubled() interno estático {vuelta 10; }

El método siguiente volverá simplemente el valor de 10 a dondequiera que fuera llamado de. La línea siguiente del código se podía agregar, por ejemplo, en su método principal para asignar este valor a una variable:

myNumber = getFiveDoubled() internos;

Esta línea del código asignará el valor de 10 al myNumber variable.

Observe apenas porque el método getFiveDoubled ahora tiene un tipo de vuelta, él no significa que no puede ser invitado sus el propios.

getFiveDoubled();

Este método esencialmente no hará nada, pero usted puede tener un método que realice una tarea requerida y después vuelva un valor, de que usted desea no hacer caso.

Un método que tiene un valor de vuelta (no vacío) debe tener una declaración de vuelta en cada punto posible de la salida del método. El recopilador tomará si una trayectoria sin un valor de vuelta es posible. Por otra parte, si usted tiene un método con el tipo de vuelta vacío y después desea salir fuera del método temprano, usted puede utilizar la vuelta de la palabra clave en sus el propios. Por ejemplo, tome el código siguiente:

vuelta vacía del doSomething() del público 
{if(leaveEarly == verdad); // continúa con el resto del 
código}

Esto es similar a cómo la declaración de la rotura se utiliza para salir fuera de ciertos bloques del código, tales como casos del interruptor y lazos, como vimos anterior. El ejemplo que acabamos de ver es un ejemplo muy básico, pero el uso de la vuelta de la palabra clave en este caso puede ser muy útil para inmediatamente salir fuera de racimos complicados del código en un método dado.

El Pasar De Parámetro

El método anterior, getFiveDoubled, es porque volverá solamente un valor, 10 bastante insustanciales y muy incómodos. Sin embargo, podríamos crear un método que tomará en cualquier número, lo doblamos, y después volvemos el valor doblado. Esto se puede alcanzar usando pasar de parámetro. El pasar de parámetro permite que usted pase valores a un método que el método pueda entonces manipular. El método siguiente contiene un parámetro, se dobla que y se vuelve el nuevo valor.

número interno) del doubleNumber(int {número * = 2; 
número de vuelta; }

Como usted puede ver, el parámetro es un número llamado variable del tipo interno y se especifica entre los soportes que siguen el nombre del método. Para llamar este método, usted podría, por ejemplo, utilizar el código siguiente:

//doble 2 del myNumber interno de los iguales 4 = 
doubleNumber(2); //entonces dobla su número actual 4 del 
myNumber = del doubleNumber(myNumber) de los iguales 8; 
//entonces cuadruplica su número actual para igualar el 
myNumber 32 = el doubleNumber(doubleNumber(myNumber));

Esta última línea del código llamará el doubleNumber del método dos veces, primero volviendo un valor que sea el valor doble del myNumber, que alternadamente entonces se pasa pues un parámetro a la segunda llamada al doubleNumber que vuelve eventual el valor final de 32, asignándolo al myNumber variable.

Para reiterar lo que mencionamos anterior, si el valor que usted pasa mientras que un parámetro está de un tipo de datos primitivo variable, la variable sí mismo no se pasa al método. Una nueva variable con ese valor se crea en el método y después se utiliza. Esto significa que los cambios realizados a este valor dentro del método llamado no afectarán el valor de la variable original.

Usted puede también tener más de un parámetro, usando una coma para separar parámetros consecutivos. El ejemplo simple siguiente, SpidersEyes.java, contiene el método se multiplica, que contiene dos parámetros que sean ambos tipo interno y vuelve el valor de los dos parámetros multiplicados juntos. Aquí está el código:

clase pública SpidersEyes {valueA interno estático 
público del multiply(int, valueB interno) {valueA de vuelta * valueB;
} args[ main(String vacío ] de los parásitos atmosféricos 
públicos) {numberOfSpiders internos = 10; eyesPerSpider interno
= 8; totalEyes = multiply(numberOfSpiders, eyesPerSpider 
internos); System.out.println("Total eyes =" + los totalEyes); 
}}

Hay dos cosas a observar de este ejemplo. Primero, hemos utilizado los parásitos atmosféricos de la palabra clave para el método nos multiplicamos. Esto es porque no hay caso de la clase SpidersEyes creado actualmente, tan en la orden para la cañería, que es estática, para poder tener acceso al método se multiplica, él debe ser estático también. La segunda cosa al aviso es que la cañería del método también toma un parámetro, que es un arsenal de secuencias.

Firmas Del Método

Es posible tener dos métodos que compartan el mismo nombre. Sin embargo, deben tener diversas firmas porque de otra manera cuando usted desea llamar uno de los métodos, el recopilador no tienen ninguna manera de distinguir uno del otro, pues la invocación del método se basa en el recopilador que reconoce la firma. Teniendo métodos del mismo nombre pero con diversas firmas se conoce como sobrecargar el método.

El nombre del método y la firma del parámetro de ese método determinan la firma de un método. El tipo de vuelta de un método no influencia su firma. Por lo tanto usted no puede tener dos métodos con el mismo nombre con dos diversos valores de vuelta con la misma firma del parámetro.

En el ejemplo anterior, SpidersEyes.java, hicimos un método llamar para multiplicarse, que tomó dos valores de parámetro del tipo internos, volviendo el valor de los valores de parámetro multiplicados juntos. Si también incluimos un método que hizo la misma cosa pero utilizamos valores del tipo doble en lugar de otro, podríamos crear otro método con el mismo nombre pero con una diversa firma del parámetro.

multiply(int interno estático público a, b) interno 
{vuelva a * b; } a multiply(double doble estática pública, b) 
doble {vuelva a * b; }

La firma del parámetro es determinada por los tipos de datos de los parámetros y por lo tanto del número de parámetros también. Digamos que ahora agregamos el método siguiente junto con los dos métodos anteriores:

multiply(int largo estático público a, b) interno 
{vuelta (long)(a * b); }

El programa compilaría no más de largo porque este método y la original multiplican la parte del método la misma firma. Tienen el mismo nombre y también los mismos parámetros ambos—de la firma dos del parámetro del tipo interno. La solución más obvia es cambiar la firma del parámetro del último método a los parámetros de la toma dos del tipo largos.

multiply(long largo estático público a, b) largo {vuelva
a * b; }

Esto ahora trabajará porque las firmas del parámetro son diferentes. Si usted no puede alterar la firma del parámetro de una manera razonable, no incomode; elasticidad justa los diversos nombres de los métodos (e.g., multiplyInt, multiplyDouble, multiplyLong, etc.).