Java - Métodos

Um método Java é uma coleção de instruções que são agrupadas para executar uma operação. Quando você chama o System.out.println() Por exemplo, o sistema realmente executa várias instruções para exibir uma mensagem no console.

Agora você aprenderá como criar seus próprios métodos com ou sem valores de retorno, invocar um método com ou sem parâmetros e aplicar a abstração de método no projeto do programa.

Método de criação

Considerando o exemplo a seguir para explicar a sintaxe de um método −

Sintaxe

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

Aqui,

estática pública − modificador
int - tipo de retorno
nomedométodo - nome do método
a, b − parâmetros formais
int a, int b - lista de parâmetros

A definição de método consiste em um cabeçalho de método e um corpo de método. O mesmo é mostrado na seguinte sintaxe -

Sintaxe

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

A sintaxe mostrada acima inclui −

modificador − Define o tipo de acesso do método e é de uso opcional.
tipo de retorno − O método pode retornar um valor.
nomeDoMétodo − Este é o nome do método. A assinatura do método consiste no nome do método e na lista de parâmetros.
Lista de parâmetros − A lista de parâmetros, é o tipo, ordem e número de parâmetros de um método. Estes são opcionais, o método pode conter zero parâmetros.
corpo do método − O corpo do método define o que o método faz com as instruções.

Exemplo

Aqui está o código fonte do método definido acima chamado min() . Este método recebe dois parâmetros num1 e num2 e retorna o máximo entre os dois −

/** 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 Chamada

Para usar um método, ele deve ser chamado. Existem duas maneiras de chamar um método, ou seja, o método retorna um valor ou não retorna nada (sem valor de retorno).

O processo de chamada de método é simples. Quando um programa invoca um método, o controle do programa é transferido para o método chamado. Este método chamado então retorna o controle para o chamador em duas condições, quando -

a instrução de retorno é executada.
ele atinge a chave de fechamento do método.

Os métodos que retornam void são considerados como chamadas para uma instrução. Vamos considerar um exemplo -

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

O valor de retorno do método pode ser entendido pelo exemplo a seguir -

int result = sum(6, 9);

A seguir está o exemplo para demonstrar como definir um método e como chamá-lo -

Exemplo
Demonstração ao 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; 
   }
}

Isso produzirá o seguinte resultado -

Saída

Minimum value = 6

A palavra-chave nula

A palavra-chave void nos permite criar métodos que não retornam um valor. Aqui, no exemplo a seguir, estamos considerando um método void methodRankPoints . Este método é um método void, que não retorna nenhum valor. A chamada para um método void deve ser uma instrução, ou seja, methodRankPoints(255.7); . É uma instrução Java que termina com um ponto e vírgula, conforme mostrado no exemplo a seguir.

Exemplo
Demonstração ao 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");
      }
   }
}

Isso produzirá o seguinte resultado -

Saída

Rank:A1

Passando parâmetros por valor

Ao trabalhar no processo de chamada, os argumentos devem ser passados. Estes devem estar na mesma ordem que seus respectivos parâmetros na especificação do método. Os parâmetros podem ser passados por valor ou por referência.

Passar Parâmetros por Valor significa chamar um método com um parâmetro. Através disso, o valor do argumento é passado para o parâmetro.

Exemplo

O programa a seguir mostra um exemplo de passagem de parâmetro por valor. Os valores dos argumentos permanecem os mesmos mesmo após a invocação do método.
Demonstração ao 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);
   }
}

Isso produzirá o seguinte resultado -

Saída

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

Método de sobrecarga

Quando uma classe tem dois ou mais métodos com o mesmo nome, mas com parâmetros diferentes, isso é conhecido como sobrecarga de método. É diferente de superação. Na substituição, um método tem o mesmo nome de método, tipo, número de parâmetros, etc.

Vamos considerar o exemplo discutido anteriormente para encontrar números mínimos do tipo inteiro. Se, digamos que queremos encontrar o número mínimo de tipo duplo. Em seguida, será introduzido o conceito de sobrecarga para criar dois ou mais métodos com o mesmo nome, mas com parâmetros diferentes.

O exemplo a seguir explica o mesmo -

Exemplo
Demonstração ao 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; 
   }
}

Isso produzirá o seguinte resultado -

Saída

Minimum Value = 6
Minimum Value = 7.3

Os métodos de sobrecarga tornam o programa legível. Aqui, dois métodos são dados pelo mesmo nome, mas com parâmetros diferentes. O número mínimo dos tipos inteiro e duplo é o resultado.

Usando argumentos de linha de comando

Às vezes, você desejará passar algumas informações para um programa ao executá-lo. Isso é feito passando argumentos de linha de comando para main( ).

Um argumento de linha de comando é a informação que segue diretamente o nome do programa na linha de comando quando ele é executado. Para acessar os argumentos de linha de comando dentro de um programa Java é bastante fácil. Eles são armazenados como strings no array String passado para main( ).

Exemplo

O programa a seguir exibe todos os argumentos de linha de comando com os quais é chamado -

public class CommandLine {

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

Tente executar este programa como mostrado aqui -

$java CommandLine this is a command line 200 -100

Isso produzirá o seguinte resultado -

Saída

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

A palavra-chave this

isto é uma palavra-chave em Java que é usada como referência ao objeto da classe atual, com um método de instância ou um construtor. Usando isto você pode referenciar os membros de uma classe como construtores, variáveis e métodos.

Observação − A palavra-chave este é usado apenas em métodos de instância ou construtores

Em geral, a palavra-chave this é usado para -

Diferencie as variáveis de instância das variáveis locais se elas tiverem os mesmos nomes, dentro de um construtor ou método.

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

Chame um tipo de construtor (construtor parametrizado ou padrão) de outro em uma classe. É conhecido como invocação explícita do construtor.

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

Exemplo

Aqui está um exemplo que usa this palavra-chave para acessar os membros de uma classe. Copie e cole o seguinte programa em um arquivo com o nome This_Example.java .
Demonstração ao 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(); 
   }
}

Isso produzirá o seguinte resultado -

Saída

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 variável(var-args)

O JDK 1.5 permite passar um número variável de argumentos do mesmo tipo para um método. O parâmetro no método é declarado da seguinte forma -

typeName... parameterName

Na declaração do método, você especifica o tipo seguido por reticências (...). Apenas um parâmetro de comprimento variável pode ser especificado em um método, e este parâmetro deve ser o último parâmetro. Quaisquer parâmetros regulares devem precedê-lo.

Exemplo
Demonstração ao 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);
   }
}

Isso produzirá o seguinte resultado -

Saída

The max value is 56.5
The max value is 3.0

O método finalize( )

É possível definir um método que será chamado imediatamente antes da destruição final de um objeto pelo coletor de lixo. Este método é chamado finalize( ) , e pode ser usado para garantir que um objeto termine corretamente.

Por exemplo, você pode usar finalize( ) para garantir que um arquivo aberto pertencente a esse objeto seja fechado.

Para adicionar um finalizador a uma classe, basta definir o método finalize( ). O Java Runtime chama esse método sempre que está prestes a reciclar um objeto dessa classe.

Dentro do método finalize( ), você especificará as ações que devem ser executadas antes que um objeto seja destruído.

O método finalize() tem esta forma geral −

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

Aqui, a palavra-chave protected é um especificador que impede o acesso a finalize( ) por código definido fora de sua classe.

Isso significa que você não pode saber quando ou mesmo se finalize( ) será executado. Por exemplo, se seu programa terminar antes da coleta de lixo, finalize( ) não será executado.

Java - Expressões Regulares Java - Arquivos e E/S

Java