Métodos de Java

En los capítulos anteriores hemos usado con frecuenciaSystem.out.println(), entonces, ¿qué es?

  • println() es un método.
  • System es una clase del sistema.
  • out es el objeto de salida estándar.

El uso de esta sentencia es llamar al método println() del objeto de salida estándar out en la clase System.

Entonces, ¿qué es un método?

Un método de Java es una colección de sentencias que juntas ejecutan una función.

  • Un método es una combinación ordenada de pasos para resolver un tipo de problema.
  • Los métodos están contenidos en clases u objetos.
  • Los métodos se crean en el programa y se referencian en otros lugares.

Ventajas de los métodos

  • 1. Hacen que el programa sea más corto y claro.
  • 2. Facilitan el mantenimiento del programa.
  • 3. Pueden mejorar la eficiencia del desarrollo de programas.
  • 4. Mejoran la reutilización del código.

Reglas de nomenclatura de métodos

  • 1. La primera palabra del nombre de un método debe comenzar con una letra minúscula; las palabras siguientes se escriben con mayúscula inicial, sin usar separadores. Por ejemplo:addPerson。
  • 2. El guion bajo puede aparecer en los nombres de los métodos de prueba de JUnit para separar los componentes lógicos del nombre. Un patrón típico es:test<MethodUnderTest>_<state>, por ejemplotestPop_emptyStack。

Definición de métodos

En general, definir un método incluye la siguiente sintaxis:

modificador tipo de retorno nombre del método(tipo de parámetro nombre del parámetro){... cuerpo del método ...returnvalor de retorno;}

Un método contiene una cabecera y un cuerpo. A continuación se presentan todas las partes de un método:

  • Modificador:El modificador, que es opcional, indica al compilador cómo llamar al método. Define el tipo de acceso del método.
  • Tipo de valor de retorno:Un método puede devolver un valor. returnValueType es el tipo de datos del valor de retorno del método. Algunos métodos ejecutan las operaciones necesarias pero no devuelven un valor. En este caso, returnValueType es la palabra clavevoid。
  • Nombre del método:Es el nombre real del método. El nombre del método y la tabla de parámetros constituyen conjuntamente la firma del método.
  • Tipo de parámetro:Un parámetro es como un marcador de posición. Cuando se llama al método, se pasa un valor al parámetro. Este valor se denomina argumento real o variable. La lista de parámetros se refiere al tipo, orden y número de parámetros del método. Los parámetros son opcionales; el método puede no contener ningún parámetro.
  • Cuerpo del método:El cuerpo del método contiene las sentencias concretas que definen la función del método.

Por ejemplo:

public static int age(int birthday){...}

Puede haber varios parámetros:

static float interest(float principal, int year){...}

Nota:En algunos otros lenguajes, los métodos se refieren a procedimientos y funciones. Un método que devuelve un valor de tipo no void se llama función; un método que devuelve un valor de tipo void se llama procedimiento.

Ejemplo

El siguiente método contiene 2 parámetros, num1 y num2, y devuelve el valor máximo de estos dos parámetros.

/** Devuelve el mayor de dos variables de tipo entero*/ public static int max(int num1, int num2) { int result; if (num1 > num2) result = num1; else result = num2; return result; }

Una forma más abreviada (operador ternario):

public static int max(int num1, int num2) { return num1 > num2 ? num1 : num2; }

Llamada a métodos

Java admite dos formas de llamar a un método, dependiendo de si el método devuelve un valor.

Cuando un programa llama a un método, el control del programa se transfiere al método llamado. Cuando se ejecuta la sentencia de retorno del método llamado o se alcanza la llave de cierre del cuerpo del método, el control se devuelve al programa.

Cuando un método devuelve un valor, la llamada al método suele tratarse como un valor. Por ejemplo:

int larger = max(30, 40);

Si el valor de retorno del método es void, la llamada al método debe ser una sentencia. Por ejemplo, el método println devuelve void. La siguiente llamada es una sentencia:

System.out.println("¡Bienvenido al tutorial para novatos!");

Ejemplo

El siguiente ejemplo demuestra cómo definir un método y cómo llamarlo:

Código del archivo TestMax.java:

public class TestMax { /** Método principal*/ public static void main(String[] args) { int i = 5; int j = 2; int k = max(i, j); System.out.println( i + "y" + j + "Comparar, el valor máximo es:" + k); } /** Devuelve el mayor de dos variables enteras*/ public static int max(int num1, int num2) { int result; if (num1 > num2) result = num1; else result = num2; return result; } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

5 和 2 比较，最大值是：5

Este programa contiene el método main y el método max. El método main es llamado por la JVM; aparte de eso, el método main no difiere de los demás métodos.

La cabecera del método main es invariable, como se muestra en el ejemplo: lleva los modificadores public y static, devuelve un valor de tipo void, el nombre del método es main, y además lleva un parámetro de tipo String[]. String[] indica que el parámetro es un arreglo de cadenas.

La palabra clave void

Esta sección explica cómo declarar y llamar a un método void.

El siguiente ejemplo declara un método llamado printGrade y lo llama para imprimir la calificación dada.

Ejemplo

Código del archivo TestVoidMethod.java:

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'); } } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

C

Aquí el método printGrade es un método de tipo void; no devuelve un valor.

La llamada a un método void debe ser una sentencia. Por lo tanto, se llama como una sentencia en la tercera línea del método main. Igual que cualquier sentencia que termina en punto y coma.

Paso de parámetros por valor

Al llamar a un método se necesitan proporcionar parámetros; debes proporcionarlos en el orden especificado en la lista de parámetros.

Por ejemplo, el siguiente método imprime un mensaje n veces consecutivas:

Código del archivo TestVoidMethod.java:

public static void nPrintln(String message, int n) { for (int i = 0; i < n; i++) { System.out.println(message); } }

Ejemplo

El siguiente ejemplo demuestra el efecto de pasar por valor.

El programa crea un método que se utiliza para intercambiar dos variables.

Código del archivo TestPassByValue.java:

public class TestPassByValue { public static void main(String[] args) { int num1 = 1; int num2 = 2; System.out.println("Antes del intercambio, el valor de num1 es:" + num1 + ", el valor de num2 es:" + num2); //Llamando al método swap swap(num1, num2); System.out.println("Después del intercambio, el valor de num1 es:" + num1 + ", el valor de num2 es:" + num2); } /** Método para intercambiar dos variables*/ public static void swap(int n1, int n2) { System.out.println("\tEntrando en el método swap"); System.out.println("\t\tAntes del intercambio, el valor de n1 es:" + n1 + ", el valor de n2:" + n2); //Intercambiando los valores de n1 y n2 int temp = n1; n1 = n2; n2 = temp; System.out.println("\t\tDespués del intercambio, el valor de n1 es" + n1 + ", el valor de n2:" + n2); } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

交换前 num1 的值为：1 ，num2 的值为：2
    进入 swap 方法
        交换前 n1 的值为：1，n2 的值：2
        交换后 n1 的值为 2，n2 的值：1
交换后 num1 的值为：1 ，num2 的值为：2

Se pasan dos parámetros al llamar al método swap. Lo interesante es que, después de llamar al método, los valores de los argumentos reales no cambian.

Sobrecarga de métodos

El método max usado anteriormente solo es aplicable a datos de tipo int. Pero, ¿y si deseas obtener el máximo de dos datos de tipo punto flotante?

La solución es crear otro método con el mismo nombre pero con parámetros diferentes, como se muestra en el siguiente código:

public static double max(double num1, double num2) { if (num1 > num2) return num1; else return num2; }

Si al llamar al método max pasas parámetros de tipo int, se llamará al método max con parámetros de tipo int;

Si se pasan parámetros de tipo double, se llamará al método max de tipo double; esto se llama sobrecarga de métodos.

Es decir, dos métodos de una clase tienen el mismo nombre pero diferentes listas de parámetros.

El compilador de Java determina qué método debe llamarse según la firma del método.

La sobrecarga de métodos puede hacer que el programa sea más claro y legible. Los métodos que realizan tareas estrechamente relacionadas deben usar el mismo nombre.

Los métodos sobrecargados deben tener listas de parámetros diferentes. No puedes sobrecargar un método solo basándote en la diferencia de modificadores o del tipo de retorno.

Ámbito de variables

El ámbito de una variable es la parte del programa en la que la variable puede ser referenciada.

Las variables declaradas dentro de un método se denominan variables locales.

El alcance de una variable local comienza desde su declaración hasta el final del bloque que la contiene.

Las variables locales deben declararse antes de poder usarse.

El alcance de los parámetros de un método abarca todo el método. Los parámetros son en realidad variables locales.

Las variables declaradas en la parte de inicialización de un bucle for tienen un alcance que abarca todo el bucle.

Pero las variables declaradas dentro del cuerpo del bucle tienen un ámbito que va desde su declaración hasta el final del cuerpo del bucle. Esto incluye declaraciones de variables como se muestra a continuación:

Puedes declarar una variable local con el mismo nombre varias veces en diferentes bloques no anidados dentro de un método, pero no puedes declarar una variable local dos veces en bloques anidados.

Uso de argumentos de línea de comandos

A veces deseas pasar mensajes a un programa cuando lo ejecutas. Esto se logra pasando argumentos de línea de comandos a la función main().

Los argumentos de línea de comandos son la información que sigue al nombre del programa al ejecutarlo.

Ejemplo

El siguiente programa imprime todos los argumentos de línea de comandos:

Código del archivo CommandLine.java:

public class CommandLine { public static void main(String[] args){ for(int i=0; i<args.length; i++){ System.out.println("args[" + i + "]: " + args[i]); } } }

Ejecuta este programa de la siguiente manera:

$ javac CommandLine.java 
$ java CommandLine this is a command line 200 -100
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

Métodos constructores

Un constructor es un método especial utilizado para crear objetos de una clase. Cuando se crea un objeto con la palabra clave new, el constructor se llama automáticamente para inicializar los atributos del objeto.

Características de los constructores:

  • El nombre del método es igual al nombre de la clase: El nombre del constructor debe ser idéntico al de la clase.
  • No tiene tipo de retorno: El constructor no tiene tipo de retorno, ni siquieravoidse puede escribir.
  • Se llama automáticamente al crear un objeto: Cada vez que se utilizanewpara crear un objeto, se llama automáticamente al constructor.
  • Puede sobrecargarse: Se pueden definir varios constructores para la misma clase, pero las listas de parámetros de estos constructores deben ser diferentes (es decir, constituyen una sobrecarga).

Ya sea que definas o no tu propio constructor, todas las clases tienen un constructor, porque Java proporciona automáticamente un constructor predeterminado. El modificador de acceso del constructor predeterminado es el mismo que el de la clase (si la clase es public, el constructor también es public; si la clase es protected, el constructor también es protected).

Una vez que defines tu propio constructor, el constructor predeterminado deja de ser válido.

Ejemplo

A continuación se muestra un ejemplo del uso de un constructor:

//Un constructor simple class MyClass { int x; //A continuación se muestra el constructor: MyClass(int i ) { x = i; } }

Puedes llamar al constructor para inicializar un objeto de la siguiente manera:

Código del archivo ConsDemo.java:

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); } }

El resultado de la ejecución es el siguiente:

10 20

Para más contenido, consulta el siguiente capítulo:Constructores en Java。

Parámetros variables

Desde JDK 1.5, Java admite pasar un número variable de argumentos del mismo tipo a un método.

La declaración de los parámetros variables de un método es la siguiente:

typeName... parameterName

En la declaración del método, agrega puntos suspensivos (...) después del tipo de parámetro especificado.

Un método solo puede especificar un parámetro variable, y debe ser el último parámetro del método. Cualquier parámetro normal debe declararse antes que él.

Ejemplo

Código del archivo VarargsDemo.java:

public class VarargsDemo { public static void main(String[] args) { //Llamar a un método con parámetros variables 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); } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

The max value is 56.5
The max value is 3.0

El método finalize()

El método finalize ha sido marcado como obsoleto (deprecated) en Java 9 y se eliminará en versiones futuras de Java. Se recomienda usartry-with-resourcesojava.lang.ref.Cleanerpara gestionar recursos.

Java permite definir un método así: se llama antes de que el objeto sea destruido (recolectado) por el recolector de basura. Este método se llama finalize( ) y se utiliza para limpiar el objeto que se va a recolectar.

Por ejemplo, puedes usar finalize() para asegurarte de que un archivo abierto por un objeto se cierre.

En el método finalize(), debes especificar las operaciones que se deben realizar cuando el objeto se destruya.

El formato general de finalize() es:

protected void finalize() { //Código de finalización aquí }

La palabra clave protected es un calificador que asegura que el método finalize() no pueda ser llamado por código fuera de la clase.

Por supuesto, la recuperación de memoria de Java puede realizarse automáticamente por la JVM. Si deseas usarla manualmente, puedes utilizar el método anterior.

Ejemplo

Código del archivo FinalizationDemo.java:

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(); //Llamar al recolector de basura de 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"); } }

Al ejecutar el código anterior, la salida es la siguiente:

$ javac FinalizationDemo.java 
$ java FinalizationDemo
Cake Object 1is created
Cake Object 2is created
Cake Object 3is created
Cake Object 3is disposed
Cake Object 2is disposed

Alternativa:Se recomienda utilizar la interfaz AutoCloseable, junto con la sentencia try-with-resources, para cerrar los recursos automáticamente. Por ejemplo:

try (Resource res = new Resource()) {
    // 使用资源
} catch (Exception e) {
    e.printStackTrace();
}
Otras extensiones