Java - Métodos

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

Ahora aprenderá cómo crear sus propios métodos con o sin valores de retorno, invocar un método con o sin parámetros y 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 −

Sintaxis

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

Aquí,

estática pública − modificador
int − tipo de retorno
nombre del método − nombre del método
a, b − parámetros formales
int a, int b − lista de parámetros

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

Sintaxis

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

La sintaxis que se muestra arriba incluye −

modificador − Define el tipo de acceso del método y su uso es opcional.
tipo de retorno − El método puede devolver un valor.
nombreDeMétodo − Este es el nombre del método. La firma del método consiste en el nombre del método y la lista de parámetros.
Lista de parámetros − 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.
cuerpo del método − El cuerpo del método define lo que hace el método con las sentencias.

Ejemplo

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 llamadas

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 de retorno).

El proceso de llamada de 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 sentencia return.
llega al método que termina la llave de cierre.

Los métodos que devuelven void se consideran llamadas 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);

El siguiente es el ejemplo para demostrar cómo definir un método y cómo llamarlo −

Ejemplo

Demostración en vivo

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 −

Salida

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 vacío, 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.

Ejemplo

Demostración en vivo

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 −

Salida

Rank:A1

Pasar parámetros por valor

Mientras se trabaja bajo el proceso de llamada, se deben pasar los 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.

Ejemplo

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.

Demostración en vivo

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 −

Salida

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 tipo doble. 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 −

Ejemplo

Demostración en vivo

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 −

Salida

Minimum Value = 6
Minimum Value = 7.3

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

Uso de argumentos de línea de comandos

A veces querrá pasar alguna 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 comandos es la información que sigue directamente al nombre del programa en la línea de comandos 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 el arreglo String pasado a main().

Ejemplo

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 −

Salida

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

La palabra clave esta

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

Nota − La palabra clave esto se usa solo dentro de métodos de instancia o constructores

En general, la palabra clave esto está acostumbrado a −

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

Ejemplo

Aquí hay un ejemplo que usa this 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 .

Demostración en vivo

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 −

Salida

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 de 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, especifica 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.

Ejemplo

Demostración en vivo

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 −

Salida

The max value is 56.5
The max value is 3.0

El método finalizar()

Es posible definir un método que será llamado justo antes de la destrucción final de un objeto por parte del recolector de basura. Este método se llama finalizar() , y se puede usar 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 se deben realizar 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 impide el acceso a finalizar() por código definido fuera de su clase.

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

Java - Expresiones regulares Java - Archivos y E/S

Java