Como chamar um método em Java

Neste artigo, mostrar-lhe-emos como chamar um método em Java. Um método em java é uma colecção de afirmações que são agrupadas para realizar uma operação. Pode passar dados, conhecidos como parâmetros, para um método. Os métodos são também conhecidos como funções.

Cada método tem o seu próprio nome. Quando esse nome é encontrado num programa, a execução do programa ramifica-se para o corpo desse método. Quando o método é terminado, a execução volta à área do código do programa de onde foi chamado, e o programa continua para a linha seguinte do código.

Quando se chama o método System.out.println(), por exemplo, o sistema executa de facto várias afirmações em segundo plano que já estão armazenadas na biblioteca, a fim de exibir uma mensagem na consola.

Porquê usar métodos? Para reutilizar o código: definir o código uma vez, e utilizá-lo muitas vezes. Na realidade, a moda modular permite que vários programadores trabalhem independentemente em conceitos separados que podem ser montados mais tarde para criar todo o projecto. A utilização de métodos será o nosso primeiro passo na direcção da programação modular.

Agora aprenderá como criar os seus próprios métodos com ou sem return valores, invocar um método com ou sem parâmetros, e aplicar abstracção de métodos no desenho do programa.

Criar um Método

Um método deve ser declarado dentro de uma classe. É definido com o nome do método, seguido de parênteses ().

A definição do método consiste num cabeçalho do método e num corpo do método.

Exemplo:

public class MyClass { public static void myMethod() { // code to be executed }}

Explicação do código:

• public static : modificador, define o tipo de acesso do método
• myMethod(): nome do método
• static: significa que o método pertence à classe MyClass e não a um objecto da classe MyClass.
• void: significa que este método não tem um valor de retorno.

Note: A palavra public antes do nome do método significa que o próprio método pode ser chamado de qualquer lugar que inclua outras classes, mesmo de diferentes pacotes (ficheiros), desde que se importe a classe. Há três outras palavras que podem substituir public. Elas são protected e private. Se um método é protected, então apenas esta classe e subclasses (classes que usam isto como base para construir) podem chamar o método. Se um método for private, então o método só pode ser chamado dentro da classe. A última palavra-chave nem sequer é realmente uma palavra. Isto é se não tiver nada no lugar de publicprotected, ou private. A isto chama-se o padrão, ou package-private. Isto significa que apenas as classes do mesmo pacote podem chamar o método. Se estiver interessado em ver mais exemplos, pode ler este artigo.

Como chamar um método em Java

Para chamar um método em Java, escreva o nome do método seguido de dois parênteses () e um ponto e vírgula;

O processo de chamada do método é simples. Quando um programa invoca um método, o controlo do programa é transferido para o método chamado.

No exemplo seguinte, myMethod() é utilizado para imprimir um texto (a acção), quando é chamado:

MyClass.java

public class MyClass { static void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { myMethod(); }}

Output:

You have called me! My name is: myMethod!

No exemplo acima, se remover o static palavra-chave, java queixa-se de que não se pode chamar um método a partir de uma função estática:

se não quiser usar static, só se pode chamar método por exemplo:

public class MyClass { void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { new MyClass().myMethod(); }}

Um método também pode ser chamado várias vezes:

MyClass.java

public class MyClass { static void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { myMethod(); myMethod(); myMethod(); }}

Output:

You have called me! My name is: myMethod!You have called me! My name is: myMethod!You have called me! My name is: myMethod!

Java Método Parâmetros

3>3.1 Parâmetros e Argumentos

Informação pode ser passada aos métodos como parâmetro. Os parâmetros actuam como variáveis dentro do método.

Parâmetros são especificados após o nome do método, dentro dos parênteses. Pode adicionar quantos parâmetros quiser, basta separá-los com uma vírgula.

O exemplo seguinte tem um método que toma um int chamado num como parâmetro. Quando o método é chamado, passamos um número, que é utilizado dentro do método a ser multiplicado por 2:

Exemplo03

public class Math { static int multiplyBytwo(int number) { return number * 2; } public static void main(String args) { int result = multiplyBytwo(2); System.out.println("The output is: " + result); }}

Output:

The result of multiplication is: 4

3.2 Parâmetros Múltiplos

Pode ter tantos parâmetros quantos quiser. Veja o seguinte exemplo:

Exemplo04

public class Math { static int sum(int num1, int num2) { return num1 + num2; } public static void main(String args) { int result = sum(2,3); System.out.println("Sum of numbers is: " + result); }}

Output:

Sum of numbers is: 5

Nota: quando se trabalha com múltiplos parâmetros, a chamada de método deve ter o mesmo número de argumentos que há parâmetros, e os argumentos devem ser passados na mesma ordem.

Nos exemplos 03 e 04 passámos parâmetros por valor. De facto, os valores dos argumentos permanecem os mesmos, mesmo após a invocação do método. Vejamos outro exemplo, exemplo05:

Swapp.java

public class Swapp { public static void swapFunction(int a, int b) { System.out.println("In swapFunction at the begining: a = " + a + " , b = " + b); // Swap n1 with n2 int c = a; a = b; b = c; System.out.println("In swapFunction at the end: a = " + a + " , b = " + b); } public static void main(String args) { int a = 10; int b = 20; System.out.println("Before swapping: a = " + a + " , 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 + " , b = " + b); }}

Output:

Before swapping: a = 10 , b = 20In swapFunction at the begining: a = 10 , b = 20In swapFunction at the end: a = 20 , b = 10**Now, Before and After swapping values will be same here**:After swapping: a = 10 , b = 20

Agora, se passarmos um objecto e alterarmos qualquer um dos seus campos, os valores também serão alterados, exemplo06:

Student.java

public class Student { String firstName; String familyName; int age; public Student(){ } public Student(String firstName, String familyName){ this.firstName = firstName; this.familyName = familyName; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getFamilyName() { return familyName; } public void setFamilyName(String familyName) { this.familyName = familyName; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }}

Agora criamos uma instância da classe Student e inicializamos os seus campos pelo seu construtor, depois disso alteramos o valor do campo pelo seu método:

public class Main { public static void main(String args) { Student student = new Student("Jack", "Smith"); System.out.println("Student's name is set (Constructor): " + student.getFirstName()); student.setFirstName("John"); System.out.println("Student's name is set (Main): " + student.getFirstName()); }}

Output:

Student's name is set (Constructor): JackStudent's name is set (Main): John

Sobrecarga do Método

Quando uma classe tem dois ou mais métodos com o mesmo nome mas parâmetros diferentes, é conhecida como sobrecarga do método. É diferente de sobrecarga. Na sobreposição, um método tem o mesmo nome de método, tipo, número de parâmetros, etc. Considere o seguinte exemplo, que tem um método que adiciona números de tipo diferente, exemplo07:

Sum.java

public class Sum { static int sum(int x, int y) { return x + y; } static double sum(double x, double y) { return x + y; } public static void main(String args) { int int_sum = sum(10, 20); double double_sum = sum(10.5, 23.67); System.out.println("int: " + int_sum); System.out.println("double: " + double_sum); }}

Output:

int: 30double: 34.17

Note: Vários métodos podem ter o mesmo nome desde que o número e/ou tipo de parâmetros sejam diferentes.

Método Overriding

Overriding é uma característica que permite a uma subclasse ou classe criança fornecer uma implementação específica de um método que já é fornecido por uma das suas superclasses ou classes mãe. Quando um método numa subclasse tem o mesmo nome, os mesmos parâmetros ou assinatura e o mesmo tipo de retorno (ou subtipo) que um método na sua super-classe, então diz-se que o método na subclasse substitui o método na super-classe.

Se um objecto de uma classe pai for utilizado para invocar o método, então a versão na classe pai será executada, mas se um objecto da subclasse for utilizado para invocar o método, então a versão na classe filho será executada. Por outras palavras, é o tipo do objecto referido (não o tipo da variável de referência) que determina que versão de um método sobreposto será executada.

5.1 Regras para o método Java Overriding

1. O método deve ter o mesmo nome que na classe pai
2. O método deve ter o mesmo parâmetro que na classe pai.
3. Deve haver uma relação IS-A (herança).

Deixe-nos ver um exemplo, exemplo08:

Human.java

public class Human { //Overridden method public void walk() { System.out.println("Human is walking"); }}

Agora estendemos a classe Human e criamos uma subclasse a partir dela:

HumanChild.java

public class HumanChild extends Human{ //Overriding method public void walk(){ System.out.println("Child is walking"); } public static void main( String args) { HumanChild obj = new HumanChild(); obj.walk(); }}

Como vê, obj.walk(); chamará a versão de classe criança de walk():

Output:

Child is walking