Java - Métodos

Um método Java é uma coleção de instruções agrupadas para executar uma operação. Quando você liga para o System.out.println() método, 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 abstração de método no design do programa.

Método de Criação

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

Syntax

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

Aqui,

public static - modificador
int - tipo de retorno
methodName - 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 e um corpo de método. O mesmo é mostrado na seguinte sintaxe -

Syntax

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

A sintaxe mostrada acima inclui -

modifier - Define o tipo de acesso do método e seu uso é opcional.
returnType - O método pode retornar um valor.
nameOfMethod- Este é o nome do método. A assinatura do método consiste no nome do método e na lista de parâmetros.
Parameter List- 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.
method body - O corpo do método define o que o método faz com as instruções.

Example

Aqui está o código-fonte do método definido acima chamado min(). Este método usa 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 (nenhum 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 ao chamador em duas condições, quando -

a instrução de retorno é executada.
atinge o método que termina com a chave de fechamento.

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

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

O valor de retorno do método pode ser compreendido pelo seguinte exemplo -

int result = sum(6, 9);

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

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

Isso produzirá o seguinte resultado -

Output

Minimum value = 6

A palavra-chave vazia

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.

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");
      }
   }
}

Isso produzirá o seguinte resultado -

Output

Rank:A1

Passando Parâmetros por Valor

Ao trabalhar no processo de chamada, os argumentos devem ser passados. Eles 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. Com isso, o valor do argumento é passado para o parâmetro.

Example

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.

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 -

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étodo

Quando uma classe tem dois ou mais métodos com o mesmo nome, mas parâmetros diferentes, isso é conhecido como sobrecarga de método. É diferente de substituir. 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 de tipo inteiro. Se, digamos que queremos encontrar o número mínimo de tipo duplo. Em seguida, o conceito de sobrecarga será introduzido para criar dois ou mais métodos com o mesmo nome, mas parâmetros diferentes.

O exemplo a seguir explica o mesmo -

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

Isso produzirá o seguinte resultado -

Output

Minimum Value = 6
Minimum Value = 7.3

Os métodos de sobrecarga tornam o programa legível. Aqui, dois métodos são dados com o 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 da linha de comando dentro de um programa Java é muito fácil. Eles são armazenados como strings no array String passado para main ().

Example

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

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 conforme mostrado aqui -

$java CommandLine this is a command line 200 -100

Isso produzirá o seguinte resultado -

Output

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

Esta palavra-chave

thisé 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 isso, você pode referir os membros de uma classe, como construtores, variáveis e métodos.

Note- A palavra - chave this é usada apenas em métodos de instância ou construtores

Em geral, a palavra - chave para a qual isso é usado -

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

Example

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

Isso produzirá o seguinte 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 variáveis (var-args)

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

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. Todos os parâmetros regulares devem precedê-lo.

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

Isso produzirá o seguinte resultado -

Output

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 pouco antes da destruição final de um objeto pelo coletor de lixo. Este método é chamadofinalize( ), e pode ser usado para garantir que um objeto seja encerrado de forma limpa.

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, você simplesmente define 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 protegida é 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 termina antes de ocorrer a coleta de lixo, finalize () não será executado.

↰ Previous page Next page ↱

Java - Métodos

Método de Criação

Método de Chamada

A palavra-chave vazia

Passando Parâmetros por Valor

Sobrecarga de método

Usando argumentos de linha de comando

Esta palavra-chave

Argumentos variáveis ​​(var-args)

O método finalize ()

Argumentos variáveis (var-args)