Chamamos procedimento a um método que “faz” algo e que não devolve nenhum valor como resultado da sua execução. Imprimir algo no ecrã é um exemplo de um procedimento.
Distinguimos entre:
- definição do procedimento – indicar qual o conjunto de instruções que ele representa, e
- invocação do procedimento – indicar que queremos executar o conjunto de instruções por ele representado.
Para que possamos indicar qual o conjunto de instruções que compõe o procedimento, temos que o definir num local acessível pelo programa que o vai usar. Para já vamos considerar que o vamos definir na mesma classe que contém o nosso programa.
Para definir um procedimento que imprime no ecrã três linhas com cruzes podemos escrever o seguinte no mesmo ficheiro onde o vamos usar:
static void imprimeTresLinhas() {
System.out.println("++++++++++++++++++++++++++++");
System.out.println("++++++++++++++++++++++++++++");
System.out.println("++++++++++++++++++++++++++++");
}
Podemos colocar esta definição do procedimento em qualquer parte do nosso ficheiro java, desde que não seja no meio de outro método!
A definição de um procedimento inclui o corpo e a assinatura.
- O corpo do procedimento é constituído por um bloco de instruções entre duas chavetas;
- A assinatura do método precede o corpo do método; nela se indica, entre outras coisas (mais sobre isto adiante), o nome do método.
No exemplo acima o corpo do procedimento compõe-se de três instruções iguais. O seu nome é imprimeTresLinhas
. A palavra void
precede o nome e significa “o método não produz nenhum resultado”.
A preceder as outras palavras, a palavra static
vai ser usada, para já, sempre que definirmos métodos. Não a usaremos para sempre, mas explicaremos o seu significado mais tarde.
Até agora vimos como abstrair um conjunto de instruções dando-lhe um nome. O método imprimeTresLinhas
, por exemplo, escreve três linhas com cruzes no standard output.
Este procedimento terá sempre o mesmo efeito quando é executado (já veremos mais à frente como invocá-lo). Podemos executá-lo 100 vezes seguidas que o efeito será sempre o mesmo.
Há situações em que, num programa, queremos executar um mesmo conjunto de ações várias vezes mas com ligeiras variações. Para isso podemos definir um método em que o conjunto de instruções que o compõe tem pontos de variação que são desconhecidos na altura da definição, mas que serão conhecidos quando o método for invocado e executado.
Fazemos isso usando uma variável no ponto de variação e incluindo-a numa parte da assinatura do método que é a lista de parâmetros.
Um parâmetro representa um valor que é desconhecido na definição do método mas que vai ser indicado (instanciado) pelo programador quando invoca o método. Desta maneira podemos ter efeitos diferentes em várias execuções do mesmo método.
- Um parâmetro tem um tipo e um nome;
- Um parâmetro vai ter um valor quando o método é invocado e executado;
- O seu tipo restringe os valores que lhe podem ser dados;
- O seu nome serve para identificar, dentro do corpo do método, o seu valor;
- Os parâmetros representam "o que o método tem que conhecer para poder fazer o que precisa de fazer".
Relembre o método imprimeInformacao
da classe NotasFinaisLegivel
:
xxxxxxxxxx
static void imprimeInformacao(int nrAluno, int notaAluno) {
System.out.println("O aluno " + nrAluno + " teve " + notaAluno + " valores");
System.out.println("++++++++++++++++++++++++++++");
}
Neste exemplo definimos dois parâmetros na assinatura do método – nrAluno
e notaAluno
.
A forma como lemos a primeira instrução do corpo do método
xxxxxxxxxx
System.out.println("O aluno " + nrAluno + " teve " + notaAluno + " valores");
pode ser a seguinte:
Imprimir no ecrã a string resultante de concatenar as strings:
nrAluno
(definido aquando da invocação do método),notaAluno
eA segunda instrução do corpo do método
xxxxxxxxxx
System.out.println("++++++++++++++++++++++++++++");
não depende dos valores dos parâmetros e, como já sabemos, escreve ++++++++++++++++++++++++++++
no ecrã.
Então, se numa dada execução deste método os parâmetros nrAluno
e notaAluno
tiverem os valores "58000" e 15, o efeito da execução do método é a impressão, no ecrã, da frase:
xxxxxxxxxx
O aluno 58000 teve 15 valores
++++++++++++++++++++++++++++
Falta-nos então ver como se faz para invocar um procedimento; é nessa altura que são definidos os valores que os seus parâmetros irão tomar na execução.
Para executarmos um procedimento temos que o invocar. Já que um procedimento pode ter parâmetros, os valores desses parâmetros terão que ser conhecidos antes de iniciada a execução.
A invocação de um procedimento é feita através de uma instrução composta por
o nome do procedimento
os valores a atribuir aos parâmetros
- na mesma ordem com que estão definidos na assinatura do método,
- entre parentesis e separados por vírgulas,
- estes valores são expressões, que, como já sabemos, podem ser literais, nomes de variáveis ou expressões mais complexas.
Como resultado da invocação, os valores indicados para os parâmetros são copiados para esses mesmos parâmetros e as instruções do corpo do método são executadas.
Qualquer referência ao nome de um parâmetro no corpo do método representa o valor “guardado” nesse parâmetro.
Por exemplo, a instrução
xxxxxxxxxx
imprimeInformacao(12345, nota);
é uma invocação do procedimento imprimeInformacao
. Os valores escolhidos para instanciar os valores dos parâmetros são o literal 12345 e o valor da variável nota
.
Relembre de novo a definição do método imprimeInformacao
da classe NotasFinaisLegivel
:
xxxxxxxxxx
static void imprimeInformacao(int nrAluno, int notaAluno) {
System.out.println("O aluno " + nrAluno + " teve " + notaAluno + " valores");
System.out.println("++++++++++++++++++++++++++++");
}
Se, no método main
da classe NotasFinaisLegivel
, tivéssemos, por exemplo, a instrução
xxxxxxxxxx
imprimeInformacao(33333,10);
ela invocaria o método imprimeInformação
, copiando os valores 33333 e 10 para os parâmetros nrAluno
e notaAluno
, respetivamente, e executaria as instruções que compõem o corpo desse método.
O efeito dessa invocação seria a impressão, no standard output, de:
xxxxxxxxxx
O aluno 33333 teve 10 valores
++++++++++++++++++++++++++++
É óbvio que se um procedimento não tem parâmetros, não se escrevará nada entre os parêntesis. O método imprimeTresLinhas
, por exemplo, é invocado através da instrução
xxxxxxxxxx
imprimeTresLinhas();
Já agora repare que System.out.println(...)
é também uma invocação de um procedimento. A grande diferença é que esse procedimento não está definido no ficheiro NotasFinaisLegivel.java
(mais tarde veremos onde).
NOTA: Um engano muito comum dos alunos é indicarem os tipos dos parâmetros aquando da invocação como, por exemplo, imprimeInformacao(int 33333, int 10);
. Os tipos dos parâmetros são indicados na definição do método! Na invocação só temos que indicar os valores que os parâmetros devem tomar, sejam eles dados por literais, por nomes de variáveis ou por expressões mais complexas.
Vamos agora fazer uma variação do nosso programa NotasFinaisLegivel
, começando por escrever três linhas de cruzes e de seguida as informações de cada aluno, separadas também por três linhas de cruzes:
xpublic class NotasFinaisVariacao {
public static void main (String [] args) {
imprimeTresLinhas();
// Nota final do aluno 12345
int nota = notaFinal(16.2, 12.3, 14.4, 15.1);
imprimeInformacaoB(12345, nota);
// Nota final do aluno 54321
nota = notaFinal(12.0, 14.2, 10.0, 10.5);
imprimeInformacaoB(54321, nota);
// Nota final do aluno 50000
nota = notaFinal(18.0, 15.6, 10.2, 16.2);
imprimeInformacaoB(50000, nota);
} // fim do metodo main
/***********************************************************
/************************** METODOS ***********************
/***********************************************************
/*
* Nota final arredondada as unidades
*/
static int notaFinal(double exame, double trab1, double trab2, double trab3) {
double notaCalculada = 0.75 * exame + 0.25 * ((trab1 + trab2 + trab3) / 3) ;
return (int)(notaCalculada + 0.5);
}
/*
* Imprimir nota de aluno no standard output
*/
static void imprimeInformacaoB(int nrAluno, int notaAluno) {
System.out.println("O aluno " + nrAluno + " teve " + notaAluno + " valores");
imprimeTresLinhas();
}
/*
* Imprimir tres linhas com cruzes no standard output
*/
static void imprimeTresLinhas() {
System.out.println("++++++++++++++++++++++++++++");
System.out.println("++++++++++++++++++++++++++++");
System.out.println("++++++++++++++++++++++++++++");
}
}
Repare que o método ImprimeInformaçãoB
invoca o método imprimeTresLinhas
.
Este programa escreve o seguinte no standard output:
++++++++++++++++++++++++++++
++++++++++++++++++++++++++++
++++++++++++++++++++++++++++
O aluno 12345 teve 16 valores
++++++++++++++++++++++++++++
++++++++++++++++++++++++++++
++++++++++++++++++++++++++++
O aluno 54321 teve 12 valores
++++++++++++++++++++++++++++
++++++++++++++++++++++++++++
++++++++++++++++++++++++++++
O aluno 50000 teve 17 valores
++++++++++++++++++++++++++++
++++++++++++++++++++++++++++
++++++++++++++++++++++++++++
Anterior: 4.1. Alguns métodos já nossos conhecidos
Seguinte: 4.3. Funções