Revisão: Módulos de programas em Java

Principais vantagens de uso de módulos (em outras LP chamados funções,

procedimentos, subrotinas e subprogramas) são:
1. lidar com a complexidade;
2. encurtar os programas;
3. tornar programas mais claras e legíveis;
4. facilitar a correcção dos erros;
5. tornar os programas mais eficazes.

Os módulos em Java são chamados de métodos e classes.

Os programas em Java são escritos combinando-se novos métodos e classes que o

programador escreve com métodos e classes “pré-empacotados” disponíveis na Java
API (biblioteca de classes Java) e em várias outras bibliotecas de métodos e classes.

Os métodos da Java API são fornecidos como parte do Java Developer’s Kit (J2SDK)
 Chamada de um método. Parâmetros
A chamada de um método (subprograma) é feita através do seu nome seguido por
parênteses contendo (ou não) uma lista de parâmetros reais (ou argumentos) de que o
método necessita para funcionar.

Existe uma relação de número, de ordem e de tipo entre os os parâmetros reais e

parâmetros formais (aqueles que encontram-se dentro de método).

Quando a chamada de método termina, o método ou devolve um resultado para o

método que chamou ou simplesmente devolve o controle para o método que chamou.
Se o método estiver em uma outra classe, a chamada deve ser precedida por um nome
de referência e um operador ponto.
Mas se estiver em mesma classe, pode chamar os outros métodos directamente.
Dois tipos de métodos em Java:
• método do tipo void
• método que retorna um valor.
Quando um método tem valor de retorno, a sua chamada tem que ser integrada numa
instrução, para que o valor devolvido possa ser utilizado.
 Variáveis locais e globais
Variáveis declaradas dentro de um método chamam-se locais. Eles podem ser
utilizados somente dentro do método onde foram declaradas.
Uma variável local é criada sempre que o método é activado e destruída quando ele
termina a sua execução.
Variáveis declarados no início da execução do programa, fora de qualquer método,
chamam-se globais. Eles podem ser utilizados em qualquer método e são destruídas
quando o programa termina.
!!! Não é boa prática declarar todas as variáveis como globais.
Passagem de parâmetros
Em Java, a passagem de parâmetros de tipos predefinidos (int, float, boolean, etc.)
é feita por valor, que significa que não é o parâmetro real que é passado ao método,
mas apenas o seu valor. Este tipo de passagem implica que o valor da variável fica
inalterável após a execução do subprograma, independentemente das alterações feitas.
Valor de retorno
Quando é necessário que o método devolva um valor que calculou, a palavra void deve
ser substituída pelo tipo de resultado que o método deve devolver.
public class AdmReprDisp_N_alunos
{ public static void main(String args[])
{ menu(); }

public static int lerQuantValidar()

{ int quant;
do
{ System.out.print("Introduza a quantidade de alunos: ");
quant=Le.umInt();
System.out.println(quant);
if (quant<=0)
System.out.println(" a quantidade nao e valida");
} while(quant<=0);
return quant;
}

public static float lerValidarUmaNota (int k)

{ float umaNota;
do
{ System.out.print("\tnota do "+k+"-o teste: ");
umaNota = Le.umFloat();
System.out.println(umaNota);
if (umaNota<0 || umaNota>20)
System.out.println("Nota introduzida e invalida!");
} while (umaNota<0 || umaNota>20);
return umaNota;
}
 public static int calcular()
{ float n1, n2, n3;
int media;
n1 = lerValidarUmaNota (1);
n2 = lerValidarUmaNota (2);
n3 = lerValidarUmaNota (3);
media = Math.round((n1+n2+n3)/3);
return media;
}

public static void decidir(int q)

{ int m;
for (int i = 1; i <= q; i++)
{ System.out.println("Introduza as notas do "+i+"
aluno:");
m = calcular ();
if (m >= 14)
System.out.println(" Dispensado com media”+m);
else
if (m < 10)
System.out.println(" Excluido com media”+m);
else
System.out.println(" Aprovado com media”+m);
}
 public static void menu ()
{ byte op; float valor1=0,valor2=0;int n=0;
do
{ System.out.println(" * * * M E N U * * * * ");
System.out.println("1.Introduzir numero de alunos");
System.out.println("2.visualizar calculos");
System.out.println("3.Terminar");
System.out.println("Introduza a sua opcao: ");
op = Le.umByte();
switch (op)
{ case 1: n = lerQuantValidar();break;
case 2: decidir (n); break;
case 3: System.out.println("Volta sempre!"); break;
default:System.out.println("Opcao invalida");break;
}
} while (op != 3);
}
}
 Ficheiro do tipo texto
A entrada de dados (leitura) permite transmitir informação do teclado para a memória
central, enquanto que a saída de dados (escrita) possibilita a transmissão de informação
da memória central para o ecrã do computador. Estes fluxos de dados, teclado -
memória e memória - ecrã, permitem ao programa comunicar com o utilizador:
fluxo
leitura
Programa
Teclado
fluxo escrita
Ecrã Programa

fluxo
leitura
Ficheiro Programa

fluxo escrita
Ficheiro Programa

Em Java cada ficheiro é considerado como um fluxo sequencial de bytes. Cada ficheiro
acaba com um marcador de fim de ficheiro. Um programa Java abre um ficheiro
através de criação de um objecto e associação de um fluxo de bytes a este objecto.
Java inclui várias classes que permitem definir estes fluxos de dados, cada uma das
quais é adequada a um determinado tipo de dados e forma de representação. Estas
classes foram incluídas na biblioteca java.io, pelo que esta deve ser importada para
qualquer programa que as use.
Os ficheiros de texto só podem conter caracteres. Para guardar valores de outros tipos em
ficheiros de texto, é necessário converter estes valores para cadeias de caracteres.
File f1 = new File(nomeDoFicheiro);
Classe File
O objectivo principal da classe File é criar uma representação lógica do ficheiro e
evitar que o programador tenha que se preocupar com as formas como os diversos SO
lidam com ficheiros. Esta classe pode também ser usada para representar directórios,
bastando que o parâmetro seja o nome de um directório, em vez de um ficheiro.
A criação de um objecto da classe File não garante por si só a criação de um ficheiro,
ou directório em disco. No entanto, se o ficheiro já existir, este objecto fornece alguns
métodos que podem ser úteis. No caso dos directórios, esta classe pode mesmo ser
utilizada para a sua criação, o que pode ser útil para organizar os ficheiros manipulados
por um programa. Alguns métodos da classe File:
delete() apaga o ficheiro ou directório;
exists() devolve true se o ficheiro ou directório existir e false caso contrário;
length() devolve o tamanho do ficheiro (não funciona com directórios);
renameTo(File) altera o nome do ficheiro ou directório para o nome do objecto
que recebe como parâmetro;
setReadOnly() marca o ficheiro ou directório como só de leitura;
mkdir() cria um subdirectório no directório corrente;
Uma das operações que pode ser assegurada por objectos da classe File é a
verificação da existência de um ficheiro:
File f1 = new File("c:/Trabalhos/UmFich.txt");
if (f1.exists())
System.out.print("Ficheiro existe");
else
System.out.print("Ficheiro não existe");

Preparação de ficheiro para leitura:

FileReader frd =new FileReader (new File(nomeDoFicheiro));

BufferedReader fR = new BufferedReader (frd);

ou de forma abreviada:
FileReader frd = new FileReader (nomeDoFicheiro);
BufferedReader fR = new BufferedReader (frd);

Preparação de ficheiro para escrita:

FileWriter fwt =new FileWriter (new File(nomeDoFicheiro));

BufferedWriter fW = new BufferedWriter (fwt);

ou de forma abreviada:

FileWriter fwt = new FileWriter (nomeDoFicheiro);

BufferedWriter fW = new BufferedWriter (fwt);
As classes FileReader e FileWriter são específicas de ficheiros de
caracteres, permitindo a sua leitura ou escrita caracter a caracter. Para conseguir a
leitura e escrita mais rápida, linha a linha, e armazenado tais dados num buffer,
reduzindo o número de operações físicas, utilizam-se as classes: BufferedReader
(para leitura) e BufferedWriter (para escrita) .

No caso da abertura de um ficheiro em modo de escrita, pode verificar-se uma de

duas situações: o ficheiro não exista e os seus conteúdos são apagados. Em
qualquer dos casos, o processo de abertura de um ficheiro para escrita resulta num
ficheiro vazio.
Para fechar ficheiros utiliza-se o método close() da classe BufferedReader e
BufferedWriter.
A leitura de uma linha a partir de um ficheiro de texto pode ser feita utilizando o
método readLine() da classe BufferedReader.
As palavras throws IOException são obrigatórias para todos os métodos que
incluam operações de entrada /saída ou que chamem métodos que as incluam. A
sua função é indicar ao compilador que o método pode gerar ou propagar um erro do
tipo IOException, que se verifica por exemplo, quando se tenta abrir para leitura
um ficheiro inexistente.
Mais tarde será apresentada a forma como estes erros podem ser detectados nos
próprios métodos, evitando assim a sua propagação.
Exemplo: Criar um ficheiro de texto com 15 linhas, em cada linha escrever um só
numero (começando pelo 1). Ler do ficheiro os números, achar o produto deles e
visualizar no ecrã .
import java.io.*;
public class EscrLerFichNumeros
{ public static void main (String args[])throws IOException
{ String nomeFich = “Criarnum.txt";
escreverNum(nomeFich);
lerNum(nomeFich);
}
public static void escreverNum (String nome) throws IOException
{ final int MAX = 15;
String str = "";
FileWriter fw = new FileWriter(nome);
BufferedWriter fichOut = new BufferedWriter(fw);
for (int i = 1; i <= MAX; i++)
{ fichOut.write(str.valueOf(i)); //write(i) também funciona
fichOut.newLine();
}
fichOut.close();
System.out.println ("O ficheiro foi criado com nome "+nome);
}
public static void lerNum (String nomeF) throws IOException
{ int numero; byte cont = 0; long prod=1;
String umaLinha = "";
FileReader fr = new FileReader(nomeF);
BufferedReader fichIn = new BufferedReader(fr);
while (umaLinha != null) // ate atingir fim de ficheiro
{ umaLinha = fichIn.readLine();
if (umaLinha != null)
{ numero = Integer.parseInt(umaLinha);
System.out.println (numero);
prod *= numero;
cont++;
}
else
System.out.println ("Fim do ficheiro!");
}
fichIn.close();
System.out.println ("Produto de "+cont+" numeros="+prod);
}
}
 Classe StringTokenizer
Muitas vezes é necessário dividir uma cadeia de caracteres nas palavras que a
compõem. Isso é possível utilizando apenas métodos da classe String. No entanto, a
classe StringTokenizer, definida na biblioteca java.util, inclui um conjunto de métodos
que permitem obter o mesmo resultado de uma forma mais simples.

import java.util.StringTokenizer;
public class DivisaoDeString
{ public static void main(String args[])
{ String frase = "Programar aprende-se programando";
StringTokenizer d = new StringTokenizer(frase);
while (d.hasMoreElements())
{ String palavra = d.nextToken();
System.out.println(palavra);
}
}
}
A separação das palavras que constituem a cadeia de caracteres é conseguida à custa
de dois métodos da classe StringTokenizer. O método hasMoreElements() permite
determinar se a divisão já foi completada. Quando tal acontecer, este método devolverá
false, levando ao fim o ciclo while. Por sua vez, o método nextToken() devolve a
próxima palavra da cadeia de caracteres. Para o fazer, considera que as palavras estão
separadas por um ou mais espaços em branco.
Output:
Programar
aprende-se
programando

A classe StringTokenizer tem outro construtor que pode ser utilizado quando se
pretende utilizar um separador diferente. Por exemplo, no caso de desejar considerar o
ponto e virgula poderia fazer:

StringTokenizer x = new StringTokenizer(frase, ";");

 Noções básicas de classes e objectos
Boa parte de nosso entendimento e relacionamento com o mundo se dá através do
conceito de objectos.
Principais características da programação orientada aos objectos:
 Identidade
 Classificação
 Polimorfismo
 Hereditariedade
 Encapsulamento.
Todos os objectos tem um nome que os representa. Ao mesmo tempo que cada
objecto tem uma identidade e características próprias.
Reconhecemos categorias de objectos, ou seja, grupos de objectos que compartilham
características comuns embora distintas em cada objecto, criarmos uma classificação
para as coisas.
Polimorfismo se refere a nossa capacidade de nos reconhecer num objecto particular
um outro mais geral .
Hereditariedade é um mecanismo de criarmos novos objectos a partir de outros que já
existem.
Encapsulamento indica que podemos utilizar um objecto conhecendo apenas sua
interface, isto é, sua aparência exterior .
Um objecto é uma combinação de dados ou atributos (variáveis) e acções ou
comportamentos (métodos) logicamente relacionados.

Um objecto pode ser caracterizado por três componentes:

 identidade;
 atributos;
 comportamentos.

Em qualquer linguagem OO primeiro deve se definir a classe e depois

objectos (um ou mais) que pertencem a esta classe, cada um deles com
atributos próprios, mas com os mesmos comportamentos.

Podemos entender uma classe como um modelo ou como uma especificação

para certos objectos.

Assim a criação de uma classe implica em definir um tipo de objecto em

termos de seus atributos (variáveis que conterão os dados) e seus métodos
(funções que manipulam tais dados).
 A relação entre uma classe e objectos dessa classe:

Objecto Joao

Atributos
Joao
maculino
solteiro
30

Comportamentos
Classe Trabalhador inserir dados
visualizar dados
Atributos mudar estado civil
nome
sexo
estado civil
idade
Objecto Olga
Comportamentos
inserir dados Atributos
visualizar dados Olga
mudar estado civil femenino
casada
Objecto Manuel 40
Atributos
Comportamentos
Manuel
inserir dados
masculino
visualizar dados
viuvo
mudar estado civil
60

Comportamentos
inserir dados
visualizar dados
mudar estado civil
 Criação de uma classe

public class Trabalhador

{ //Atributos
private String nome;
private short codigo, idade;
//Construtor. Recebe valores iniciais dos atributos (nome,cod e idade)
public Trabalhador()
{ System.out.println("Nome: ");
nome = validarNome();
System.out.println("Codigo (1111-9999): ");
codigo = validarShort((short)1111, (short)9999);
System.out.println("Idade (18-65): ");
idade = validarShort((short)18,(short)65);
}
private String validarNome()
{ String y;
do
{ System.out.println("Digite o nome do trabalhador");
y = Le.umaString();
if(y.length()== 0)
System.out.println("Erro:Tente Denovo:");
} while(y.length()== 0);
return y;
}
private short validarShort(short a, short b)
{ short c;
do
{ c = Le.umShort();
if(c<a || c>b)
System.out.println("Valor invalido! Tente de novo");
} while (c<a || c>b);
return c;
}

//Devolve a idade.
public short getIdade() { return idade; }

//Prepara e devolve uma linha de informação sobre o trabalhador.

public String toString()
{ return "Nome\tCodigo\tIdade\n"+nome+"\t"+codigo+"\t"+idade; }
}