Métodos de Java

在本教程中，您将借助示例学习Java方法，如何定义方法以及如何在Java程序中使用方法。

什么是方法？

在数学中，我们可能已经研究过函数。例如，f(x) = x²x 是一个返回平方值的函数。

If x =　2,　then f(2)　=　4
If x =　3,　f(3)　=　9
and so on.

同样，在计算机编程中，函数是执行特定任务的代码块。

在面向对象的编程中，该方法是用于函数的术语。方法绑定到类，并且它们定义类的行为。

在学习方法之前，请确保了解Java类和对象.

Java方法的类型

根据用户定义的方法还是标准库中可用的方法，Java中有两种方法：

• 标准库方法

• 用户定义的方法

标准库方法

　标准库方法是Java中的内置方法，可以随时使用。这些标准库与Java类库（JCL）一起出现在JVM和JRE的Java归档文件（*.jar）中。

例如，

• print() - 是java.io.PrintSteam的一个方法。print("…")方法用引号打印字符串。

• sqrt() - 　是数学课的一种方法。它返回一个数字的平方根。
  

这是一个工作示例：

public　class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　
　　　　　　　　//使用sqrt()方法
　　　　　　　　System.out.print("4的平方根是:　"　+　Math.sqrt(4));
　　　　}
}

输出：

4的平方根是:　2.0

用户定义的方法

还可以创建自己选择的方法来执行某些任务。这种方法称为用户定义方法。

¿Cómo crear métodos definidos por el usuario?

Esto es cómo creamos métodos en Java:

public static void myMethod() {
　　　　System.out.println("Mi función");
}

Aquí, creamos un método llamado myMethod(). Podemos ver que usamos public, static y void antes del nombre del método.

• public - Modificador de acceso. Esto significa que se puede acceder al método desde cualquier lugar. Para obtener más información, visiteJava访问修饰符

• static - Esto significa que se puede acceder al método sin ningún objeto. Para obtener más información, visiteJava静态关键字.

• void - Esto significa que el método no devuelve ningún valor. Vamos a aprender más sobre esto en la parte posterior de este tutorial.

Este es un ejemplo simple de cómo creamos métodos. Sin embargo, la sintaxis completa de definición de métodos en Java es:

modificador static returnType nombreDelMétodo (parámetros) {
　　　　//　cuerpo del método
}

Aquí,

• modificador - Define el método de acceso como métodos públicos, privados, etc.

• static - Si se utiliza la palabra clave static, no es necesario crear un objeto para acceder a él.
  Por ejemplo, el método estático sqrt() de la clase Math estándar. Por lo tanto, podemos llamar a Math.sqrt() sin crear una instancia de la clase Math.

• returnType - especifica el tipo de valor que devuelve el método. Por ejemplo, si el método tiene un tipo de retorno int, devuelve un valor entero.
  Un método que puede devolver tipos de datos primitivos (int, float, double, etc.), objetos nativos (String, Map, List, etc.) o cualquier otro objeto integrado y definido por el usuario.
  Si el método no devuelve un valor, su tipo de retorno es void.

• nameOfMethod - es unidentificadorpara referirse a un método específico en el programa.
  Podemos dar cualquier nombre al método. Sin embargo, es más común nombrarlo según la tarea que realiza. Por ejemplo, calculateArea(), display() y otros.

• parámetros (argumentos) - Estos son los valores que se pasan al método. Podemos pasar una cantidad arbitraria de parámetros al método.

• cuerpo del método - Incluye declaraciones de programación para ejecutar ciertas tareas. El cuerpo del método se encuentra entre corchetes { }.

¿Cómo llamar a un método en Java?

Ahora que sabemos cómo definir métodos, necesitamos aprender a usarlos. Para eso, debemos llamar a ese método. Esto es cómo se hace

myMethod();

Esta declaración llama al método previamente declarado myMethod().

1. 　Mientras se ejecuta el código del programa, se encuentra con myFunction() en el código.

2. 　Luego se realiza una ramificación al método myFunction() y se ejecuta el código dentro del cuerpo del método.

3. 　Después de que se ejecuta el cuerpo del método, el programa regresa a su estado original y ejecuta la siguiente instrucción después de la llamada al método.
   

Ejemplo: método Java

Vamos a ver cómo se utilizan los métodos en un programa Java.

class Main {
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　System.out.println("Próximamente, encontraremos un tipo de método.");
　　　　　　　　//Llamar al método
　　　　　　　　myMethod();
　　　　　　　　System.out.println("¡El método se ha ejecutado con éxito!");
　　　　}
　　　　//　definición del método
　　　　private static void myMethod(){
　　　　　　　　System.out.println("Imprimir desde el interior de myMethod!");
　　　　}
}

输出：

Próximamente, encontraremos un tipo de método.
Imprimir desde el interior de myMethod!
¡El método se ha ejecutado con éxito!

En el programa anterior, tenemos un método llamado myMethod(). Este método no acepta parámetros. Además, el tipo de retorno del método es void (lo que significa que no devuelve ningún valor).

En este caso, el método es static. Por lo tanto, llamamos al método sin crear un objeto de la clase.

Vamos a ver otro ejemplo

class Main {
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Crear un objeto de la clase Output
　　　　　　　　Output obj = new Output();
　　　　　　　　System.out.println("Próximamente, encontraremos un método.");
　　　　　　　　//Llamar al método myMethod() de la clase Output
　　　　　　　　obj.myMethod();
　　　　　　　　System.out.println("¡El método se ha ejecutado con éxito!");
　　　　}
}
class Output {
　　
　　　　//public: este método se puede llamar desde fuera de la clase
　　　　public void myMethod() {
　　　　　　　　System.out.println("Imprimir desde el interior de myMethod().");
　　　　}
}

输出：

Próximamente, encontraremos un método.
Imprimir desde el interior de myMethod()
¡El método se ha ejecutado con éxito!

En el ejemplo anterior, creamos un método llamado myMethod(). Este método se encuentra en la clase llamada Output.

Dado que el método no es static, se debe llamar al método utilizando el objeto de la clase obj.

obj.myMethod();

Parámetros y valores de retorno del método

Como se mencionó anteriormente, los métodos Java pueden tener cero o más parámetros. Y también pueden devolver algunos valores.

Ejemplo: valor de retorno del método

Vamos a tomar como ejemplo un método con retorno de valor.

class SquareMain {
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　int result;
　　　　　　　　//Llamar al método y almacenar el valor devuelto
　　　　　　　　result = square();　
　　　　　　　　System.out.println("10el valor cuadrado es: "　+　result);
　　　　}
　　　　public static int square() {
　　　　　　　　//la declaración return
　　　　　　　　return　10　*　10;
　　　　}
}

输出：

10El valor cuadrado es:　100

En el programa anterior, creamos un método llamado square(). Este método no acepta ningún parámetro y devuelve un valor de10 *10.

Aquí, mencionamos que el tipo de retorno del método es int. Por lo tanto, este método debe devolver siempre un valor entero.

Como hemos visto, el rango de este método es limitado, ya que siempre devuelve el mismo valor. Ahora, modificaremos el fragmento de código anterior para que siempre devuelva el cuadrado de cualquier entero pasado al método, en lugar de siempre devolver10El valor cuadrado es.

Ejemplo: método que acepta parámetros y devuelve valores

public　class　Main　{
　　　
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　int　result,　n;
　　　　　　　　
　　　　　　　　n　=　3;
　　　　　　　　result　=　square(n);
　　　　　　　　System.out.println("3El cuadrado es: "　+　result);
　　　　　　　　
　　　　　　　　n　=　4;
　　　　　　　　result　=　square(n);　
　　　　　　　　System.out.println("4El cuadrado es: "　+　result);
　　　　}
　　　　//　方法
　　　　static　int　square(int　i)　{
　　　　　　　　return　i　*　i;
　　　　}
}

输出：

3的平方是:　9
4的平方是:　16

Aquí, el método square(）acepta un parámetro i y devuelve el cuadrado de i. El valor devuelto se almacena en la variable result.

Si pasamos cualquier otro tipo de datos en lugar de valores de tipo int, el compilador generará un error. Esto se debe a que Java es un lenguaje de tipo fuerte.

　Los parámetros pasados al método getSquare() durante la llamada al método se llaman parámetros reales.

result　=　getSquare(n);

　Los parámetros aceptados por la definición del método se llaman parámetros formales. El tipo de los parámetros formales debe estar tipificado explícitamente.

public　static　int　square(int　i)　{...}

También podemos usar comas para pasar varios parámetros a un método Java. Por ejemplo,

public　class　Main　{
　　　　//方法定义
　　　　public　static　int　getIntegerSum　(int　i,　int　j)　{
　　　　　　　　return　i　+　j;
　　　　}
　　　　//　方法定义
　　　　public　static　int　multiplyInteger　(int　x,　int　y)　{
　　　　　　　　return　x　*　y;
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Llamar al método
　　　　　　　　System.out.println("10　+　20　=　"　+　getIntegerSum(10,　20));
　　　　　　　　System.out.println("20　x　40　=　"　+　multiplyInteger(20,　40));
　　　　}
}

输出：

10　+　20　=　30
20　x　40　=　800

Atención: El tipo de datos de los parámetros reales y los parámetros formales debe coincidir, es decir, el tipo de datos del primer parámetro real debe coincidir con el tipo de datos del primer parámetro formal. Del mismo modo, el tipo del segundo parámetro real debe coincidir con el tipo del segundo parámetro formal, y así sucesivamente.

¿Cuáles son las ventajas de usar métodos?

1. Las principales ventajas sonReutilización del código. Podemos escribir una vez un método y usarlo varias veces. No es necesario que volvamos a escribir todo el código cada vez. Puedemos considerarlo como “Escribir una vez, reutilizar varias vecesPor ejemplo,

public　class　Main　{
　　　　//方法定义
　　　　private　static　int　getSquare(int　x){
　　　　　　　　return　x　*　x;
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　for　(int　i　=　1;　i　<=　5;　i++)　{
　　　　　　　　　　　　//方法调用
　　　　　　　　　　　　int　result　=　getSquare(i);
　　　　　　　　　　　　System.out.println(""　+　i　+　"　的平方是:　"　+　result);
　　　　　　　　}
　　　　}
}

输出：

1　的平方是:　1
2　的平方是:　4
3　的平方是:　9
4　的平方是:　16
5　的平方是:　25

　在上面的程序中，我们创建了一个名为getSquare()的方法来计算数字的平方。这里，用同样的方法计算小于6的数的平方。

　因此，我们反复使用相同的方法

方法2使代码更易读，更易于调试。例如，getSquare()方法可读性很强，因此我们可以知道这个方法将计算一个数字的平方。