Java - Métodos

Un método Java es una colección de declaraciones que se agrupan para realizar una operación. Cuando llamas al System.out.println() método, por ejemplo, el sistema en realidad ejecuta varias declaraciones para mostrar un mensaje en la consola.

Ahora aprenderá a crear sus propios métodos con o sin valores de retorno, 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.

Método de creación

Considerando el siguiente ejemplo para explicar la sintaxis de un método:

Syntax

public static int methodName(int a, int b) {
   // body
}

Aquí,

public static - modificador
int - tipo de retorno
methodName - nombre del método
a, b - parámetros formales
int a, int b - lista de parámetros

La definición de método consta de un encabezado de método y un cuerpo de método. Lo mismo se muestra en la siguiente sintaxis:

Syntax

modifier returnType nameOfMethod (Parameter List) {
   // method body
}

La sintaxis que se muestra arriba incluye:

modifier - Define el tipo de acceso del método y su uso es opcional.
returnType - El método puede devolver un valor.
nameOfMethod- Este es el nombre del método. La firma del método consta del nombre del método y la lista de parámetros.
Parameter List- La lista de parámetros, es el tipo, orden y número de parámetros de un método. Estos son opcionales, el método puede contener cero parámetros.
method body - El cuerpo del método define lo que hace el método con las declaraciones.

Example

Aquí está el código fuente del método definido anteriormente llamado min(). Este método toma dos parámetros num1 y num2 y devuelve el máximo entre los dos -

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

Método de llamada

Para usar un método, debe llamarse. Hay dos formas en que se llama a un método, es decir, el método devuelve un valor o no devuelve nada (sin valor devuelto).

El proceso de llamar al método es simple. Cuando un programa invoca un método, el control del programa se transfiere al método llamado. Este método llamado luego devuelve el control a la persona que llama en dos condiciones, cuando:

se ejecuta la declaración de retorno.
llega al método que termina la llave de cierre.

Los métodos que devuelven vacío se consideran una llamada a una declaración. Consideremos un ejemplo:

System.out.println("This is tutorialspoint.com!");

El método que devuelve el valor se puede entender con el siguiente ejemplo:

int result = sum(6, 9);

A continuación se muestra el ejemplo para demostrar cómo definir un método y cómo llamarlo:

Example

public class ExampleMinNumber {
   
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      int c = minFunction(a, b);
      System.out.println("Minimum Value = " + c);
   }

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Esto producirá el siguiente resultado:

Output

Minimum value = 6

La palabra clave vacía

La palabra clave void nos permite crear métodos que no devuelven un valor. Aquí, en el siguiente ejemplo, estamos considerando un método vacío methodRankPoints . Este método es un método nulo, que no devuelve ningún valor. La llamada a un método void debe ser una declaración, es decir, methodRankPoints (255.7); . Es una declaración de Java que termina con un punto y coma, como se muestra en el siguiente ejemplo.

Example

public class ExampleVoid {

   public static void main(String[] args) {
      methodRankPoints(255.7);
   }

   public static void methodRankPoints(double points) {
      if (points >= 202.5) {
         System.out.println("Rank:A1");
      }else if (points >= 122.4) {
         System.out.println("Rank:A2");
      }else {
         System.out.println("Rank:A3");
      }
   }
}

Esto producirá el siguiente resultado:

Output

Rank:A1

Pasar parámetros por valor

Mientras se trabaja con el proceso de llamada, se deben pasar argumentos. Estos deben estar en el mismo orden que sus respectivos parámetros en la especificación del método. Los parámetros se pueden pasar por valor o por referencia.

Pasar parámetros por valor significa llamar a un método con un parámetro. A través de esto, el valor del argumento se pasa al parámetro.

Example

El siguiente programa muestra un ejemplo de paso de parámetro por valor. Los valores de los argumentos siguen siendo los mismos incluso después de la invocación del método.

public class swappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("Before swapping, a = " + a + " and 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 + " and b is " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
      
      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}

Esto producirá el siguiente resultado:

Output

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

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 anular. Al anular, un método tiene el mismo nombre de método, tipo, número de parámetros, etc.

Consideremos el ejemplo discutido anteriormente para encontrar números mínimos de tipo entero. Si, digamos que queremos encontrar el número mínimo de tipos dobles. Luego se introducirá el concepto de sobrecarga para crear dos o más métodos con el mismo nombre pero diferentes parámetros.

El siguiente ejemplo explica lo mismo:

Example

public class ExampleOverloading {

   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      double c = 7.3;
      double d = 9.4;
      int result1 = minFunction(a, b);
      
      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

   // for integer
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Esto producirá el siguiente resultado:

Output

Minimum Value = 6
Minimum Value = 7.3

Los métodos de sobrecarga hacen que el programa sea legible. Aquí, dos métodos tienen el mismo nombre pero con diferentes parámetros. El resultado es el número mínimo de tipos enteros y dobles.

Usar argumentos de línea de comandos

A veces querrá pasar información a un programa cuando lo ejecute. Esto se logra pasando argumentos de la línea de comandos a main ().

Un argumento de línea de comando es la información que sigue directamente al nombre del programa en la línea de comando cuando se ejecuta. Acceder a los argumentos de la línea de comandos dentro de un programa Java es bastante fácil. Se almacenan como cadenas en la matriz String que se pasa a main ().

Example

El siguiente programa muestra todos los argumentos de la línea de comandos con los que se llama:

public class CommandLine {

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

Intente ejecutar este programa como se muestra aquí -

$java CommandLine this is a command line 200 -100

Esto producirá el siguiente resultado:

Output

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

La esta palabra clave

thises una palabra clave en Java que se utiliza como referencia al objeto de la clase actual, con un método de instancia o un constructor. Con esto , puede hacer referencia a los miembros de una clase, como constructores, variables y métodos.

Note- La palabra clave this se usa solo dentro de métodos de instancia o constructores

En general, la palabra clave this se usa para:

Diferenciar las variables de instancia de las variables locales si tienen los mismos nombres, dentro de un constructor o un método.

class Student {
   int age;   
   Student(int age) {
      this.age = age;	
   }
}

Llame a un tipo de constructor (constructor parametrizado o predeterminado) de otro en una clase. Se conoce como invocación explícita del constructor.

class Student {
   int age
   Student() {
      this(20);
   }
   
   Student(int age) {
      this.age = age;	
   }
}

Example

Aquí hay un ejemplo que usa esta palabra clave para acceder a los miembros de una clase. Copie y pegue el siguiente programa en un archivo con el nombre,This_Example.java.

public class This_Example {
   // Instance variable num
   int num = 10;
	
   This_Example() {
      System.out.println("This is an example program on keyword this");	
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();
      
      // Assigning the local variable num to the instance variable num
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }
      
   public void print() {
      // Local variable num
      int num = 20;
      
      // Printing the local variable
      System.out.println("value of local variable num is : "+num);
      
      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);
      
      // Invoking the greet method of a class
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();
      
      // Invoking the print method
      obj1.print();
	  
      // Passing a new value to the num variable through parametrized constructor
      This_Example obj2 = new This_Example(30);
      
      // Invoking the print method again
      obj2.print(); 
   }
}

Esto producirá el siguiente resultado:

Output

This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

Argumentos variables (var-args)

JDK 1.5 le permite pasar un número variable de argumentos del mismo tipo a un método. El parámetro en el método se declara de la siguiente manera:

typeName... parameterName

En la declaración del método, especificas el tipo seguido de puntos suspensivos (...). Solo se puede especificar un parámetro de longitud variable en un método, y este parámetro debe ser el último parámetro. Cualquier parámetro regular debe precederlo.

Example

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable args  
	   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);
   }
}

Esto producirá el siguiente resultado:

Output

The max value is 56.5
The max value is 3.0

El método finalize ()

Es posible definir un método que será llamado justo antes de la destrucción final de un objeto por el recolector de basura. Este método se llamafinalize( )y se puede utilizar para garantizar que un objeto termine limpiamente.

Por ejemplo, puede usar finalize () para asegurarse de que un archivo abierto propiedad de ese objeto esté cerrado.

Para agregar un finalizador a una clase, simplemente defina el método finalize (). El tiempo de ejecución de Java llama a ese método cada vez que está a punto de reciclar un objeto de esa clase.

Dentro del método finalize (), especificará las acciones que deben realizarse antes de que se destruya un objeto.

El método finalize () tiene esta forma general:

protected void finalize( ) {
   // finalization code here
}

Aquí, la palabra clave protected es un especificador que evita el acceso a finalize () por código definido fuera de su clase.

Esto significa que no puede saber cuándo o incluso si se ejecutará finalize (). Por ejemplo, si su programa finaliza antes de que ocurra la recolección de basura, finalize () no se ejecutará.

↰ Previous page Next page ↱