Método Java

Neste tutorial, você aprenderá sobre métodos Java com exemplos, como definir métodos e como usar métodos em programas Java.

O que é um método?

Na matemática, já estudamos funções. Por exemplo, f(x) = x²x é uma função que retorna o quadrado.

Se x =　2, então f(2) =　4
Se x =　3, f(3) =　9
e assim por diante.

Da mesma forma, na programação de computadores, uma função é um bloco de código que executa uma tarefa específica.

No programação orientada a objetos, este é um termo para funções. O método está ligado à classe e define o comportamento da classe.

Antes de aprender sobre métodos, certifique-se de entenderJava Classes and Objects.

Tipos de métodos Java

De acordo com o método definido pelo usuário ou o método disponível na biblioteca padrão, há dois tipos de métodos no Java:

• Métodos da biblioteca padrão

• Método definido pelo usuário

Métodos da biblioteca padrão

　Métodos da biblioteca padrão são métodos integrados no Java, que podem ser usados a qualquer momento. Esses métodos da biblioteca padrão aparecem junto com a biblioteca de classes Java (JCL) nos arquivos de arquivo Java (JVM e JRE).*.jar).

Por exemplo:

• print() - É um método da java.io.PrintStream. O método print("…") imprime uma string entre aspas.

• sqrt() - 　É um método de matemática. Ele retorna a raiz quadrada de um número.
  

Este é um exemplo de trabalho:

public class Main {}}
　　　　public static void main(String[] args) {
　　　　
　　　　　　　　//Usando o método sqrt()
　　　　　　　　System.out.print("4A raiz quadrada é: "　+　Math.sqrt(4));
　　　　}
}

Output:

4A raiz quadrada é:　2.0

Método definido pelo usuário

Podemos criar nossos próprios métodos para executar certas tarefas. Este método é chamado de método definido pelo usuário.

Como criar métodos definidos pelo usuário?

Aqui está como criamos métodos em Java:

public static void myMethod() {
　　　　System.out.println("minha função");
}

Aqui, criamos um método chamado myMethod(). Podemos ver que usamos public, static e void antes do nome do método.

• public - modificador de acesso. Isso significa que o método pode ser acessado de qualquer lugar. Para mais informações, acesseJava Access Modifiers

• static - Isso significa que o método pode ser acessado sem qualquer objeto. Para mais informações, acesseJava Static Keyword.

• void - Isso significa que o método não retorna nenhum valor. Vamos entender isso em uma parte posterior do tutorial.

Este é um exemplo simples de como criamos métodos. No entanto, a sintaxe completa de definição de métodos em Java é:

modificador static returnType nameOfMethod (parameters) {
　　　　//　corpo do método
}

aqui,

• modificador - ele define o método de acesso como método público, privado etc.

• static - Se usar a palavra-chave static, não é necessário criar um objeto para acessá-lo.
  Por exemplo, o método sqrt() da classe padrão Math é estático. Portanto, podemos chamar Math.sqrt() diretamente sem criar uma instância da classe Math.

• returnType - ele especifica o tipo de valor retornado pelo método. Por exemplo, se o método tiver o tipo de retorno int, ele retornará um valor inteiro.
  Um método que pode retornar tipos de dados primitivos (int, float, double, etc.), objetos nativos (String, Map, List, etc.) ou qualquer outro objeto embutido e definido pelo usuário.
  Se o método não retornar nenhum valor, seu tipo de retorno é void.

• nameOfMethod - ele é umidentificadorusado para referenciar métodos específicos no programa.
  Podemos dar qualquer nome ao método. No entanto, nomeá-lo com a tarefa que ele executa é uma prática mais convencional. Por exemplo, calculateArea(), display() etc.

• parâmetros (argumentos) - esses são os valores passados para o método. Podemos passar qualquer quantidade de parâmetros para o método.

• corpo do método - Isso inclui instruções de programação usadas para executar algumas tarefas. O corpo do método está contido dentro de chaves { }.

Como chamar métodos Java?

Agora que sabemos como definir métodos, precisamos aprender a usá-los. Para isso, devemos chamar o método. Veja como fazer isso

myMethod();

Esta instrução chama o método myMethod() previamente declarado.

1. 　Ao executar o código do programa, ele encontra myFunction() no código.

2. 　Em seguida, ele faz uma ramificação para o método myFunction() e executa o código dentro do corpo do método.

3. 　Após a execução do corpo do método, o programa retorna ao estado original e executa a próxima instrução após a chamada do método.
   

Exemplo: método Java

Vamos ver como usar métodos em programas Java.

class Main {
　　　　public static void main(String[] args) {
　　　　　　　　System.out.println("Estamos prestes a encontrar um tipo de método.");
　　　　　　　　//chamar método
　　　　　　　　myMethod();
　　　　　　　　System.out.println("O método foi executado com sucesso!");
　　　　}
　　　　//　definição do método
　　　　private static void myMethod(){
　　　　　　　　System.out.println("Imprimindo internamente do myMethod!");
　　　　}
}

Output:

Estamos prestes a encontrar um tipo de método.
Imprimindo internamente do myMethod!
O método foi executado com sucesso!

No programa acima, temos um método chamado myMethod(). Este método não aceita nenhum parâmetro. Da mesma forma, o tipo de retorno do método é void (o que significa que não retorna nenhum valor).

Aqui, o método é static. Portanto, chamamos o método sem criar um objeto da classe.

Vamos ver outro exemplo

class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar um objeto da classe Output
　　　　　　　　Output obj = new Output();
　　　　　　　　System.out.println("Estamos prestes a encontrar um método.");
　　　　　　　　//Chamar myMethod() da classe Output
　　　　　　　　obj.myMethod();
　　　　　　　　System.out.println("O método foi executado com sucesso!");
　　　　}
}
class Output {
　　
　　　　//public: Este método pode ser chamado externamente da classe
　　　　public void myMethod() {
　　　　　　　　System.out.println("Imprimindo internamente do myMethod().");
　　　　}
}

Output:

Estamos prestes a encontrar um método.
Imprimindo internamente do myMethod()
O método foi executado com sucesso!

No exemplo acima, criamos um método chamado myMethod(). Este método está localizado na classe chamada Output.

Como o método não é static, usamos o objeto da classe obj para chamar este método.

obj.myMethod();

Parâmetros e valor de retorno do método

Como mencionado anteriormente, os métodos Java podem ter zero ou mais parâmetros. E eles também podem retornar alguns valores.

Exemplo: valor de retorno do método

Vamos usar um exemplo de método com retorno.

class SquareMain {
　　　　public static void main(String[] args) {
　　　　　　　　int result;
　　　　　　　　//chamar o método e armazenar o valor retornado
　　　　　　　　result = square();　
　　　　　　　　System.out.println("10o valor quadrado é: "　+　result);
　　　　}
　　　　public static int square() {
　　　　　　　　//return　instrução
　　　　　　　　return　10　*　10;
　　　　}
}

Output:

10o valor quadrado é:　100

No programa acima, criamos um método chamado square(). Este método não aceita nenhum parâmetro e retorna um valor de10 *10.

Aqui, mencionamos que o tipo de retorno do método é int. Portanto, o método deve sempre retornar um valor inteiro.

Como vimos, o escopo deste método é limitado, pois ele sempre retorna o mesmo valor. Agora, vamos modificar o trecho de código acima para que ele sempre retorne o quadrado de qualquer inteiro passado ao método, e não sempre10o valor quadrado.

Exemplo: método aceita parâmetros e retorna valores

public class Main {}}
　　　
　　　　public static void main(String[] args) {
　　　　　　　　int　result,　n;
　　　　　　　　
　　　　　　　　n　= 　3;
　　　　　　　　result　=　square(n);
　　　　　　　　System.out.println("3é:　"　+　result);
　　　　　　　　
　　　　　　　　n　= 　4;
　　　　　　　　result　=　square(n);　
　　　　　　　　System.out.println("4é:　"　+　result);
　　　　}
　　　　//　Methods
　　　　static　int　square(int　i)　{
　　　　　　　　return　i　*　i;
　　　　}
}

Output:

3is:　9
4is:　16

Aqui, o método square(）aceita um parâmetro i e retorna o quadrado de i. O valor retornado é armazenado na variável result.

Se passarmos qualquer outro tipo de dados, além de valores do tipo int, o compilador gerará um erro. Isso porque o Java é uma linguagem de tipo forte.

　Os parâmetros passados para o método getSquare() durante a chamada do método chamados de parâmetros reais.

result　=　getSquare(n);

　Os parâmetros aceitos na definição do método são chamados de parâmetros formais. O tipo dos parâmetros formais deve ser tipificado explicitamente.

public　static　int　square(int　i)　{...}

Também podemos usar vírgulas para passar vários parâmetros para métodos Java. Por exemplo,

public class Main {}}
　　　　//Method Definition
　　　　public　static　int　getIntegerSum　(int　i,　int　j)　{
　　　　　　　　return　i　+　j;
　　　　}
　　　　//　Method Definition
　　　　public　static　int　multiplyInteger　(int　x,　int　y)　{
　　　　　　　　return x　*　y;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//chamar método
　　　　　　　　System.out.println("10　+　20　=　"　+　getIntegerSum(10,　20));
　　　　　　　　System.out.println("20　x　40　=　"　+　multiplyInteger(20,　40));
　　　　}
}

Output:

10　+　20　=　30
20　x　40　=　800

Atenção: O tipo de dados dos parâmetros reais e dos parâmetros formais deve coincidir, ou seja, o tipo de dados do primeiro parâmetro real deve coincidir com o tipo de dados do primeiro parâmetro formal. Da mesma forma, o tipo do segundo parâmetro real deve coincidir com o tipo do segundo parâmetro formal, e assim por diante.

Quais são as vantagens de usar métodos?

1. As principais vantagens sãoReutilização do códigoPodemos escrever uma vez um método e usá-lo várias vezes. Não precisamos reescrever todo o código a cada vez. Podemos considerá-lo como "Escrever uma vez, usar várias vezesPor exemplo,

public class Main {}}
　　　　//Method Definition
　　　　private static int getSquare(int x){
　　　　　　　　return x　*　x;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　for (int i =　1; i <=　5; i++) {
　　　　　　　　　　　　//Method Call
　　　　　　　　　　　　int result = getSquare(i);
　　　　　　　　　　　　System.out.println(""　+　i　+　"The square of the number is: "　+　result);
　　　　　　　　}
　　　　}
}

Output:

1　is:　1
2　is:　4
3　is:　9
4　is:　16
5　is:　25

　In the above program, we created a method named getSquare() to calculate the square of a number. Here, we calculate the square of numbers less than6of the square of the number.

　Therefore, we repeatedly use the same method

Methods2Making the codeMore readable,Easier to debugFor example, the getSquare() method is very readable, so we can know that this method will calculate the square of a number.