Métodos e Procedimentos Prof. Jesus José de Oliveira Neto
Procedimentos são estruturas que agrupam um conjunto de comandos, que são executados quando o procedimento é chamado. Métodos são procedimentos que podem retornar um valor ao seu término. A Linguagem Java não faz distinção.
Evitam que os blocos do programa fiquem grandes demais e mais difíceis de ler e entender. Ajudam a organizar o programa. Permitem reaproveitamento de códigos construídos anteriormente. Evitam repetição de trechos de códigos, minimizando erros e facilitando alterações.
<tipo> nome_do_método(<tipo> arg1, <tipo> arg2,..., <tipo> argn) { <corpo do método> return valor_de_retorno; // não é obrigatório
Exemplo de um método: int soma(int a, int b) { int c; c = a + b; return c;
Todo método deve ter um tipo (String, int, float), o qual indicará o tipo de seu valor de retorno (saída). Os argumentos (ou parâmetros) indicam o tipo e quais valores são esperados para serem manipulados pelo método (entrada). int soma(int a, int b) { int c; c = a + b; return c; Corpo do método
Um método pode não ter argumentos, basta não informá-los. Exemplo: int random() { Random rand = new Random(); return rand.nextint(100);
A expressão contida no comando return é chamado de valor de retorno do método. Esse comando é sempre o último a ser executado por um método. Nada após ele será executado. Os métodos só podem ser declaradas fora de outros métodos. Lembre-se que o corpo do programa principal (main(string[] args)) é um método!
Uma forma clássica de realizarmos a invocação (ou chamada) de um método é atribuindo o seu valor a uma variável: resultado = soma(x,y); Na verdade, o resultado da chamada de um método é uma expressão, que pode ser usada em qualquer lugar que aceite uma expressão: System.out.println("Soma: + soma(a,b) );
Método que calcula a soma dos valores de x e y: static int x, y, resultado; static int soma(int a, int b){ return (a + b); public static void main(string[] args){ x = 3; y = 5; resultado = soma(x, y); System.out.println(resultado);
As variáveis x e y no exemplo anterior são chamadas de parâmetros. Conforme exemplo anterior, os argumentos não possuem necessariamente os mesmos nomes que os parâmetros que o método espera. Seus valores são apenas copiados para o método chamada, sem ser afetados pelas alterações nos parâmetros dentro do método.
É utilizado em métodos Java. É um tipo que representa o nada, ou seja: Indica que um método não retorna nenhum valor.
Exemplo de método que não retorna valor: void imprime_dobro(int x) { System.out.println("Dobro de x: + 2*x);
static int x, y, resultado; static void soma() { resultado = x + y; public static void main(string[] args) { x = 3; y = 5; soma(); System.out.println(resultado);
Parâmetros ou argumentos são os valores recebidos e/ou retornados por um método. Podem ser divididos em duas categorias: Formais:correspondem aos parâmetros utilizados na definição do método. Reais: correspondem aos parâmetros utilizados na chamada do método.
Parâmetros formais static int soma(int a, int b) { return (a + b); public static void main(string[] args) { int x = 3; int y = 5; System.out.println(soma(x, y)); Parâmetros reais
É o mecanismo de informar sobre quais valores o processamento definido no método deve ser realizado. Os parâmetros são passados para um método de acordo com a sua posição. Os parâmetros formais de um método se comportam como variáveis locais (criados na entrada e destruídos na saída) No caso do Java, esta variável pode representar um tipo primitivo ou um objeto. Existem duas categorias: Por valor Por referência
Os valores das variáveis externas (método chamador) são copiados para as variáveis internas do método chamado. Alteração no valor das variáveis terá efeito local ao método chamado. var var_interna 0001 1001 0101 1010 1111 0101 1011 0011 0000 0001 0001 1001 0000 0101 0001 1010 0001 1111 1001 0101 1011 0011 0101 1010 0000 0001 1111 0101 0001 1001 0101 1010 1111 0101 1011 0011 0000 0001 0001 1001 0101 1010 1111 0101 1011 0011 0000 0001 0001 1001 0101 1010 1111 0101 1011 0011
Quando passamos uma variável do tipo primitivo para um método chamamos esta passagem de passagem por valor. A variável original que foi informada na chamada do método não é alterada. Uma cópia do valor da mesma é passada para ser utilizada dentro do método. Por isso chamamos de passagem por valor.
Exemplo de passagem de parâmetro por valor public class PassagemValor { public static int quadrado(int x) { x=x*x; return x; public static void main(string args[]) { int x = 3,y; y = quadrado(x); System.out.println( quadrado de +x+ = +y);
Toda passagem de parâmetros no Java é feita por valor! A cada chamada de método, os parâmetros são copiados e estas cópias são utilizadas na execução do mesmo.
Os valores das variáveis externas não são passados para o método, mas sim os seus endereços. Ocorre alteração no valor das variáveis externas.
0001 1001 var 0101 1010 1111 0101 1011 0011 0000 0001 0001 1001 0101 1010 1111 0101 1011 0011 0000 0001 0001 1001 0101 1010 1111 0101 1011 0011 0000 0001 0001 1001 0101 1010 1111 0101 1011 0011 0000 0001 0001 1001 0101 1010 1111 0101 1011 0011
Uma desvantagem da passagem por valor é que, se um item de dados grande está sendo passado, copiar esses dados pode consumir um tempo de processamento considerável.
No caso de objetos, a referência dos mesmos é passada por valor, portanto não é possível alterar a referência de uma variável através de um método. Mas o conteúdo dos objetos podem ser alterados e estes são mantidos mesmo após a execução do método. Por isso merecem um tratamento diferenciado.
Quando passamos uma variável do tipo objeto, na realidade apenas a referência do objeto é passada para o método. O objeto em questão está ativo e acessível através desta referência. Os atributos dos objetos podem ser alterados e estas alterações serão mantidas mesmo após a execução do método.
public class PassagemObjetos { public static void alteramsg(stringbuffer sb) { sb.append( alterada ); public static void main(string args[]) { StringBuffer sb = new StringBuffer( mensagem ); alteramsg(sb); System.out.println(sb.toString());
Outra forma de se utilizar objetos para passar parâmetros é utilizando arrays. Ao invés de passar uma variável diretamente por parâmetro utilizamos um vetor da seguinte forma:
public class PassagemObjetosArray { public static void quadrado(int i[]) { i[0]=i[0]*i[0]; public static void main(string args[]) { int i[] = new int[1]; i[0]=3; quadrado(i); System.out.println( resultado= +i[0]); Note que utilizamos um vetor de uma posição só. Não é uma solução elegante, pois à primeira vista do programa podemos equivocadamente imaginar que o vetor possui um método diferente. Pois o conceito de vetor não foi idealizado para esta finalidade.
1) Faça um programa que: Leia um vetor turma de 5 alunos Cada registro/objeto de aluno deve ter o numero de matrícula do aluno e suas notas de 4 bimestres. Faca um procedimento que Imprima a lista de matrícula e notas de cada aluno Faca um método que tenha como parametro um objeto Aluno e retorne a média das 4 nota Percorra o vetor de alunos e imprima a matricula e a média calculada( pela funcao criada) para cada aluno.
2) Escreva um programa em Java que manipule um vetor de registros com dados de 10 trabalhadores de uma empresa, conforme a estrutura a seguir: int id; String nome; char sexo; float salario; O programa deve ter as seguintes métodos: a) um método para ler os dados dos 10 funcionários. b) um método que receba por referência a lista e exiba os dados dos 10 funcionários. c) um método que receba, como parâmetro, um caractere correspondente ao sexo e a lista para exibir os dados somente dos funcionários do respectivo sexo. d) um método que receba por referência a lista de funcionários e atualize o salário de todos os funcionários de acordo com o percentual informado como parâmetro.