En este artículo, te mostraremos cómo llamar a un método en Java. Un método en java es una colección de sentencias que se agrupan para realizar una operación. Puedes pasar datos, conocidos como parámetros, a un método. Los métodos también se conocen como funciones.
Cada método tiene su propio nombre. Cuando se encuentra ese nombre en un programa, la ejecución del programa se ramifica hacia el cuerpo de ese método. Cuando el método termina, la ejecución vuelve a la zona del código del programa desde la que fue llamado, y el programa continúa con la siguiente línea de código.
Cuando se llama al método System.out.println(), por ejemplo, el sistema ejecuta en realidad varias sentencias en segundo plano que ya está almacenada en la biblioteca, para mostrar un mensaje en la consola.
¿Por qué usar métodos? Para reutilizar el código: definir el código una vez, y utilizarlo muchas veces. En realidad la moda modular permite que varios programadores trabajen de forma independiente en conceptos separados que pueden ser ensamblados posteriormente para crear el proyecto completo. El uso de métodos será nuestro primer paso en la dirección de la programación modular.
Ahora aprenderás a crear tus propios métodos con o sin valores return, a invocar un método con o sin parámetros, y a aplicar la abstracción de métodos en el diseño del programa.
Crear un método
Un método debe ser declarado dentro de una clase. Se define con el nombre del método, seguido de paréntesis ().
La definición del método consta de una cabecera y un cuerpo del método.
Ejemplo:
public class MyClass { public static void myMethod() { // code to be executed }}
Explicación del código:
-
public static: modificador, define el tipo de acceso del método -
myMethod(): nombre del método -
static: significa que el método pertenece a la clase MyClass y no a un objeto de la clase MyClass. -
void: significa que este método no tiene valor de retorno.
Nota: La palabra public antes del nombre del método significa que el método en sí puede ser llamado desde cualquier lugar que incluya otras clases, incluso desde diferentes paquetes (archivos) siempre y cuando se importe la clase. Hay otras tres palabras que pueden sustituir a public. Son protected y private. Si un método es protected, sólo esta clase y las subclases (las clases que utilizan esto como base para construir) pueden llamar al método. Si un método es private, entonces el método sólo puede ser llamado dentro de la clase. La última palabra clave es realmente ni siquiera una palabra. Esto es si no tienes nada en el lugar de publicprotected, o private. Esto se denomina por defecto, o paquete-privado. Esto significa que sólo las clases del mismo paquete pueden llamar al método. Si te interesa ver más ejemplos puedes leer este artículo.
Cómo llamar a un método en Java
Para llamar a un método en Java, escribe el nombre del método seguido de dos paréntesis () y un punto y coma;
El proceso de llamada a un método es sencillo. Cuando un programa invoca un método, el control del programa se transfiere al método llamado.
En el siguiente ejemplo, myMethod() se utiliza para imprimir un texto (la acción), cuando es llamado:
MiClase.java
public class MyClass { static void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { myMethod(); }}
Salida:
You have called me! My name is: myMethod!
En el ejemplo anterior si se elimina la palabra clave static, java se queja de que no se puede llamar a un método desde una función estática:
Si no quieres usar static, sólo puedes llamar al método de instancia:
public class MyClass { void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { new MyClass().myMethod(); }}
También se puede llamar a un método varias veces:
MyClass.java
public class MyClass { static void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { myMethod(); myMethod(); myMethod(); }}
Salida:
You have called me! My name is: myMethod!You have called me! My name is: myMethod!You have called me! My name is: myMethod!
Parámetros de métodos Java
3.1 Parámetros y argumentos
Se puede pasar información a los métodos como parámetro. Los parámetros actúan como variables dentro del método.
Los parámetros se especifican después del nombre del método, dentro de los paréntesis. Puedes añadir tantos parámetros como quieras, sólo tienes que separarlos con una coma.
El siguiente ejemplo tiene un método que toma como parámetro un int llamado num. Cuando se llama al método, le pasamos un número, que se utiliza dentro del método para ser multiplicado por 2:
Ejemplo03
public class Math { static int multiplyBytwo(int number) { return number * 2; } public static void main(String args) { int result = multiplyBytwo(2); System.out.println("The output is: " + result); }}
Salida:
The result of multiplication is: 4
3.2 Parámetros múltiples
Puedes tener tantos parámetros como quieras. Mira el siguiente ejemplo:
Ejemplo04
public class Math { static int sum(int num1, int num2) { return num1 + num2; } public static void main(String args) { int result = sum(2,3); System.out.println("Sum of numbers is: " + result); }}
Salida:
Sum of numbers is: 5
Nota: cuando se trabaja con múltiples parámetros, la llamada al método debe tener el mismo número de argumentos que parámetros hay, y los argumentos deben pasarse en el mismo orden.
En los ejemplos 03 y 04 hemos pasado parámetros por valor. De hecho los valores de los argumentos siguen siendo los mismos incluso después de la invocación del método. Veamos otro ejemplo, ejemplo05:
Swapp.java
public class Swapp { public static void swapFunction(int a, int b) { System.out.println("In swapFunction at the begining: a = " + a + " , b = " + b); // Swap n1 with n2 int c = a; a = b; b = c; System.out.println("In swapFunction at the end: a = " + a + " , b = " + b); } public static void main(String args) { int a = 10; int b = 20; System.out.println("Before swapping: a = " + a + " , b = " + b); // Invoke the swap method swapFunction(a, b); System.out.println("\n**Now, Before and After swapping values will be same here**:"); System.out.println("After swapping: a = " + a + " , b = " + b); }}
Salida:
Before swapping: a = 10 , b = 20In swapFunction at the begining: a = 10 , b = 20In swapFunction at the end: a = 20 , b = 10**Now, Before and After swapping values will be same here**:After swapping: a = 10 , b = 20
Ahora bien, si pasamos un objeto y cambiamos alguno de sus campos, los valores también se modificarán, ejemplo06:
Estudiante.java
public class Student { String firstName; String familyName; int age; public Student(){ } public Student(String firstName, String familyName){ this.firstName = firstName; this.familyName = familyName; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getFamilyName() { return familyName; } public void setFamilyName(String familyName) { this.familyName = familyName; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }}
Ahora creamos una instancia de la clase Student e inicializamos sus campos mediante su constructor, después cambiaremos el valor del campo mediante su método:
public class Main { public static void main(String args) { Student student = new Student("Jack", "Smith"); System.out.println("Student's name is set (Constructor): " + student.getFirstName()); student.setFirstName("John"); System.out.println("Student's name is set (Main): " + student.getFirstName()); }}
Salida:
Student's name is set (Constructor): JackStudent's name is set (Main): John
Sobrecarga de métodos
Cuando una clase tiene dos o más métodos con el mismo nombre pero diferentes parámetros, se conoce como sobrecarga de métodos. Es diferente de la sobrecarga. En el overriding, un método tiene el mismo nombre de método, tipo, número de parámetros, etc. Considera el siguiente ejemplo, que tiene un método que suma números de diferente tipo, ejemplo07:
Suma.java
public class Sum { static int sum(int x, int y) { return x + y; } static double sum(double x, double y) { return x + y; } public static void main(String args) { int int_sum = sum(10, 20); double double_sum = sum(10.5, 23.67); System.out.println("int: " + int_sum); System.out.println("double: " + double_sum); }}
Salida:
int: 30double: 34.17
Nota: Múltiples métodos pueden tener el mismo nombre siempre que el número y/o tipo de parámetros sean diferentes.
Sobreescritura de métodos
La sobreescritura es una característica que permite a una subclase o clase hija proporcionar una implementación específica de un método que ya es proporcionado por una de sus superclases o clases padre. Cuando un método en una subclase tiene el mismo nombre, los mismos parámetros o firma y el mismo tipo de retorno (o subtipo) que un método en su superclase, entonces se dice que el método en la subclase sobrescribe el método en la superclase.
Si se utiliza un objeto de una clase padre para invocar el método, entonces se ejecutará la versión de la clase padre, pero si se utiliza un objeto de la subclase para invocar el método, entonces se ejecutará la versión de la clase hija. En otras palabras, es el tipo del objeto al que se hace referencia (no el tipo de la variable de referencia) lo que determina qué versión de un método anulado se ejecutará.
5.1 Reglas para la anulación de métodos Java
- El método debe tener el mismo nombre que en la clase padre
- El método debe tener el mismo parámetro que en la clase padre.
- Debe existir una relación IS-A (herencia).
Veamos un ejemplo, el ejemplo08:
Humano.java
public class Human { //Overridden method public void walk() { System.out.println("Human is walking"); }}
Ahora extendemos la clase Human y creamos una subclase a partir de ella:
HumanoHijo.java
public class HumanChild extends Human{ //Overriding method public void walk(){ System.out.println("Child is walking"); } public static void main( String args) { HumanChild obj = new HumanChild(); obj.walk(); }}
Como ves, obj.walk();llamará a la versión de la clase child de walk():
Salida:
Child is walking