doc - Paulo Roberto Gomes Luzzardi

Propaganda
Java: A Linguagem de Programação
por
Prof. Dr. Paulo Roberto Gomes Luzzardi
facebook: Paulo Roberto Gomes Luzzardi
WhatsApp: 91648037
e-mail: [email protected] e [email protected]
e-mail (Senac): [email protected]
DropBox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m
Hostinger: http://pluzzardi.w.pw e http://pluzzardi.zz.mu (Home Page)
OS X Server (Apple): http://pluzzardi.no-ip.info:8080 (Home Page)
Versão 1.66
26-05-2017
Bibliografia recomendada:
DEITEL, H. M. and DEITEL, P. J. Java: como programar, 8. ed.: São Paulo: Pearson,
2010 (ISBN 85-363-0123-6).
1
Pelotas, sexta-feira, 26 de maio de 2017 (17:58 pm)
Sumário
1. Arquitetura de um programa em Java ................................................................................................ 6
1.1 Elementos básicos de um programa em Java ........................................................................ 6
1.2 Elementos básicos de um método estático .......................................................................... 6
1.3 Como compilar um programa em Java via Terminal ........................................................... 6
1.4 Como executar um programa em Java via Terminal ........................................................... 6
1.5 Como executar um .jar em Java via Terminal .................................................................... 6
1.6 Pasta contendo os projetos/arquivos em Java .................................................................. 6
2. Estrutura de um programa em Java .................................................................................................... 7
2.1 Identificadores ........................................................................................................................... 7
2.2 Comentários do programador .................................................................................................... 7
2.3 Regras gerais para escrever um programa em Java ......................................................... 8
2.4 Palavras reservadas do Java ................................................................................................ 10
2.5 Declaração de variáveis......................................................................................................... 10
2.5.1 Onde as variáveis podem ser declaradas .................................................................. 10
2.5.2 Inicialização de variáveis .......................................................................................... 13
2.6 Constantes ................................................................................................................................... 13
2.6.1 Constantes hexadecimais e octais .............................................................................. 13
2.6.2 Constantes Strings ........................................................................................................... 14
2.6.3 Constantes especiais ....................................................................................................... 16
2.7 Comandos do pré-processador do Java ................................................................................ 16
2.7.1 O comando import ............................................................................................................... 16
3. Tipos de dados ....................................................................................................................................... 17
3.1 Tipos básicos ............................................................................................................................. 17
3.2 Escrevendo uma classe em Java ............................................................................................ 17
3.2.1 Conceitos básicos ................................................................................................................. 17
3.2.2 Referência this ..................................................................................................................... 22
3.2.3 Lista de exercícios sobre Classes ................................................................................ 22
3.3 Sobrecarga de métodos em Java ............................................................................................ 36
4. Métodos de entrada e saída de dados ............................................................................................ 38
4.1 Entrada de dados via teclado .............................................................................................. 38
4.2 Saída de dados via tela......................................................................................................... 39
5. Operadores ............................................................................................................................................... 41
5.1 Operadores aritméticos ........................................................................................................... 41
5.2 Operadores relacionais ........................................................................................................... 41
5.3 Operadores lógicos ................................................................................................................... 41
5.4 Incremento e decremento......................................................................................................... 42
5.5 Operador de atribuição ........................................................................................................... 42
5.6 Casts ............................................................................................................................................. 43
5.7 Expressões ................................................................................................................................... 44
6. Métodos para funções matemáticas padrões .................................................................................. 45
6.1 Math.abs ....................................................................................................................................... 45
6.2 Math.asin ..................................................................................................................................... 45
6.3 Math.acos ..................................................................................................................................... 45
6.4 Math.atan ..................................................................................................................................... 45
6.5 Math.sin ....................................................................................................................................... 45
6.6 Math.cos ....................................................................................................................................... 45
6.7 Math.tan ....................................................................................................................................... 47
6.8 Math.exp ....................................................................................................................................... 47
6.9 Math.pow ....................................................................................................................................... 47
2
6.10 Math.sqrt ................................................................................................................................... 47
6.11 Math.log ..................................................................................................................................... 47
6.12 Double.parseDouble ................................................................................................................. 47
6.13 Integer.parseInt ..................................................................................................................... 47
6.14 Long.parseLong ......................................................................................................................... 47
6.15 Math.log10 ................................................................................................................................. 48
6.16 Math.random ............................................................................................................................... 48
6.17 Math.PI ....................................................................................................................................... 48
6.18 Conversão de graus para radianos .................................................................................... 48
7. Comandos ................................................................................................................................................... 49
7.1 Tipos de comandos ..................................................................................................................... 49
7.1.1 Sequência ............................................................................................................................. 49
7.1.2 Seleção ................................................................................................................................. 49
7.1.3 Repetição ............................................................................................................................. 51
7.2 Comando if ................................................................................................................................... 52
7.2.1 if encadeados ..................................................................................................................... 53
7.3 O comando switch ....................................................................................................................... 54
7.4 Comando while ............................................................................................................................. 57
7.5 O comando for ............................................................................................................................. 59
7.6 O loop do { } while ................................................................................................................. 61
7.7 Interrupção de loops ............................................................................................................... 62
7.7.1 O comando break ................................................................................................................. 62
7.7.2 O comando continue ........................................................................................................... 63
7.8 O método System.exit ()......................................................................................................... 64
8. Saída formatada (System.out.printf) ............................................................................................ 64
9. Lista de exercícios (comandos) ...................................................................................................... 66
10. Vetores, Matrizes e Strings .......................................................................................................... 70
10.1 Vetores ....................................................................................................................................... 70
10.2 Strings ....................................................................................................................................... 71
10.3 Matrizes (Multidimensional) .............................................................................................. 71
10.4 Vetor de Strings ..................................................................................................................... 73
10.5 Inicialização de matrizes e vetores .............................................................................. 73
10.6 Inicialização de um vetor de caracteres ...................................................................... 73
10.7 Inicialização de matrizes multidimensionais.............................................................. 74
10.8 Inicialização de vetores e matrizes sem tamanho ..................................................... 74
10.9 Classificação de dados ou ordenação (sort) ................................................................ 76
10.10 Lista de exercícios (vetores) ........................................................................................ 78
11. Manipulação de Strings..................................................................................................................... 81
11.1 Métodos para manipular Strings ........................................................................................ 81
11.2 Lista de exercícios (Strings) .......................................................................................... 85
12. Métodos estáticos definidos pelo programador ....................................................................... 88
12.1 Valores de retorno ................................................................................................................. 90
12.2 Passagem de parâmetros por valor .................................................................................... 92
12.3 Passagem de parâmetros por referência .......................................................................... 93
12.4 Métodos que devolvem valores não-inteiros .................................................................. 94
12.5 Argumentos do main (String [] args) .............................................................................. 95
12.6 Recursividade ........................................................................................................................... 96
12.7 Lista de Exercícios (métodos) .......................................................................................... 98
13. Classes (Interface ou Coleção) existentes em Java (Container) ................................... 102
14. Entrada e saída em disco (Arquivos) ........................................................................................ 119
14.1 Métodos para manipular arquivos em Java .................................................................... 119
14.2 Abertura de um arquivo texto .......................................................................................... 121
14.3 Listar um diretório ............................................................................................................. 122
14.4 Manipulação de um arquivo de palavras ........................................................................ 124
3
14.5 Arquivo Texto ......................................................................................................................... 127
14.6 Lista de exercícios (arquivos) ...................................................................................... 132
14.7 Acesso randômico em arquivos texto .............................................................................. 136
14.8 Arquivo binário de objetos em Java .............................................................................. 137
15. Conceitos diversos em Java .......................................................................................................... 139
15.1 Operadores bit a bit ........................................................................................................... 139
15.2 Formas abreviadas de Java ................................................................................................ 140
16. Listas Lineares: Pilha, Fila e Fila Circular ..................................................................... 141
16.1 Implementação de um lista em vetor .............................................................................. 141
16.2 Implementação de uma Pilha .............................................................................................. 145
16.3 Implementação de uma Fila ................................................................................................ 146
16.4 Implementação de uma Fila Circular .............................................................................. 148
17. Tratamento de erros ......................................................................................................................... 151
17.1 Tratamento de exceções....................................................................................................... 152
17.2 Tratamento de erros: Entrada de número inteiro via teclado ............................. 152
17.3 Tratamento de erros: Divisão por zero ........................................................................ 153
17.4 Tratamento de exceção com Exception ............................................................................ 153
17.5 Tratamento de exceção com MyException ........................................................................ 154
17.6 Exceção em ArrayList ........................................................................................................... 155
17.7 Exceções criadas pelo programador ................................................................................ 156
18. Herança em Java ................................................................................................................................. 159
18.1 Herança simples ..................................................................................................................... 159
18.2 Controle de acesso na definição de uma classe derivada ..................................... 159
18.3 Tipos de acessos (especificadores de acesso) ......................................................... 161
18.4 Lista de exercícios sobre Herança ................................................................................ 164
18.4.1 Herança (primeiro) ........................................................................................................... 164
18.4.2 Herança (segundo) ............................................................................................................. 165
18.4.3 Herança (terceiro) ........................................................................................................... 166
19. Coletor de Lixo (Garbage Collector) ........................................................................................ 169
20. Construtor e finalizador em Java .............................................................................................. 170
21. Applets em Java ................................................................................................................................. 172
22. Threads em Java ................................................................................................................................. 177
23. Sockets em Java ................................................................................................................................. 178
24. Data e Hora em Java ......................................................................................................................... 181
25. Glossário em Java ............................................................................................................................. 182
26. Curiosidades do Java ....................................................................................................................... 185
27. Classe Object ..................................................................................................................................... 187
28. Classe ArrayDeque ............................................................................................................................. 189
29. Formatar um double, float ou int .............................................................................................. 194
30. Leitura e gravação de objetos (registro) em Arquivos ..................................................... 195
30.1 Gravação de objetos em um arquivo binário de objetos ............................................ 195
30.2 Leitura objetos em um arquivo binário de objetos .................................................... 198
31. Eliminar problemas de conversão na entrada de Dados ....................................................... 201
32. Classe para Entrada de Inteiros e Reais em Java sem Erro na Digitação .................. 203
Legenda de Cores
Vermelho <enter>: Entrada de dados do programa
Azul: Saída do programa (Resultado do Programa)
Verde: Texto em destaque
Preto: Texto normal
Preto: Método em destaque
4
Itálico: Código em Java
Negrito: Texto em destaque
Sublinado: Observações
5
1. Arquitetura de um programa em Java
1.1 Elementos básicos de um programa em Java
package nome_do_pacote;
public class nome_da_classe {
// depois de compilado é gerado: nome_da_classe.class
public static void main(String[] args) {
corpo_do_programa;
System.exit(0);
// método principal
// finalizar o programa definitivamente
}
}
Programa Fonte: nome_da_classe.java
Classe Java Compilada: nome_da_classe.class (ByteCode)
1.2 Elementos básicos de um método estático
public static tipo_de_retorno nome_do_método(tipo_do_agumento nome_do_argumento, ...) {
corpo_do_método;
return(valor_de_retorno);
}
1.3 Como compilar um programa em Java via Terminal
$ javac Teste.java <enter>
$
// gera um arquivo “Teste.class”
1.4 Como executar um programa em Java via Terminal
$ java Teste <enter>
$
// a classe é executada
1.5 Como executar um .jar em Java via Terminal
$ java –jar Teste.jar <enter>
$
Observação: Para gerar um arquivo executável Java, ou seja, um “.jar” (pelo NetBeans) vá na opção
“Executar” e selecione “Limpar e Construir Projeto, desta forma, é gerado o arquivo “.jar” na pasta
“dist”do projeto, ou seja, dentro da pasta do NetBeans.
1.6 Pasta contendo os projetos/arquivos em Java
/Users/pluzzardi/NetBeansProjects
// MacOsX
/Users/pLuzzardi/Documents/NetBeansProjects
/home/pluzzardi/NetBeansProjects
// Windows
// Linux – Ubuntu
6
2. Estrutura de um programa em Java
2.1 Identificadores
São os nomes criados pelo programador para fazer referência a variáveis,
constantes, argumentos, atributos e métodos.
Regras para a criação de identificadores:





O primeiro caracter pode ser uma letra, ( $ ) ou sublinha ( _ );
Os caracteres seguintes devem ser letras, números ou sublinhas;
Não há limite de caracteres;
Não é permitido a utilização de caracteres em branco (caracter espaço);
Podem ser letras maiúsculas e minúsculas.
Convenções:





Sempre começar um identificador com uma letra e não "$" ou "_".
Os caracteres “$” e “_” nunca devem ser usados.
Use nomes completos em vez de abreviações confusas.
Palavras-chaves e palavras reservadas da linguagem não podem ser usadas como
identificadores.
Se o identificador tiver mais de um nome, o primeiro deve começar com letra
minúscula e os demais devem começar com letras maiúsculas (int numeroDentes =
0).
Exemplos em variáveis:
int numeroDentes = 32;
double inflacao;
char a, _a;
// _a deve ser evitado
Exemplos em constantes: final char letra = ‘A’;
final int tamanho = 10;
final double d = 123.45;
Exemplos de argumentos: public int Div(int x, int y) {
public boolean strChr(String s, char ch) {
Exemplos de atributos:
private int numElementos;
private int []vetor;
private int topo;
Exemplos em métodos:
x = raizQuadrada(y);
System.out.println(“Valor: ” + inverso(n));
Observação: o método “inverso” é definido pelo programador (1/n).
2.2 Comentários do programador
Os comentários do programador são linhas de código que não são compiladas
pelo compilador, ou seja, servem apenas como anotações (documentação) para serem
7
lembradas mais tarde (por exemplo, quando forem feitas manutenções no programa). Em
Java os comentários podem ser feitos de duas formas:
/* Assim pode ser usado para comentário de várias linhas */
// Isto é um comentário de uma linha apenas
Um comentário, pode ainda, utilizar várias linhas do programa. Veja o exemplo
abaixo:
/* ---------------------------------------------------Método: STRING
Argumentos de entrada: x, y
Argumentos de saída: c[], t[]
Retorno: Sem Retorno
------------------------------------------------------- */
2.3 Regras gerais para escrever um programa em Java
Um programa em Java é constituído de uma ou mais classes delimitadas por
chaves { }, onde uma destas classes, obrigatoriamente possui um método chamada
main(). As principais regras são:







Letras maiúsculas e minúsculas são tratadas como caracteres diferentes;
O formato do texto é livre;
O método main(){} especifica onde o programa começa e termina de ser
executado;
Todos os comandos são terminados por ponto e vírgula;
Todas as variáveis devem ser declaradas;
{ método começa a ser executado;
} método termina de ser executado.
Programa exemplo (1): Imprimir a data no seguinte formato: [Data: dd/mm/aaaa].
// -------------------------------------------- Fonte: Prog1.java
package prog1;
public class Prog1 {
public static void main(String[] args) {
int dia, mes, ano;
dia = 2;
mes = 6;
ano = 2013;
System.out.printf("Data: %02d/%02d/%04d\n", dia, mes, ano);
}
}
Resultado do Programa:
Data: 02/06/2013
// formata os campos da data
ou
// -------------------------------------------- Fonte: Prog1.java
package prog1;
8
public class Prog1 {
public static void main(String[] args) {
int dia = 2;
int mes = 6;
int ano = 2013;
System.out.println("Data: " + dia + "/" + mes + "/" + ano);
}
}
9
Resultado do Programa:
Data: 2/6/2013
// não formata a data
2.4 Palavras reservadas do Java
abstract
boolean break
byte
catch
char
class
continue
do
double else
extends
false
final
finaly float
for
implements
import instanceof
int
long
native new
null
private protected
public return
short
static super
switch synchronized this
throw
throws transient
true
void
volatile
while
const
goto (não usadas)
case
default
if
interface
package
try
Observação: As palavras reservadas não podem ser utilizadas pelo programador como
nome de variáveis, constantes, argumentos, atributos ou métodos, ou seja, não servem
como identificadores.
2.5 Declaração de variáveis
Sintaxe: tipo_dado_base lista_de_variáveis;
tipo_dado_base: deve ser um tipo de dado válido (boolean, char, int, byte, short,
long, float, double ou void)
lista_de_variáveis: um ou mais identificadores separados por vírgula.
Exemplo:
int i, j ,k;
float a, b;
char ch;
2.5.1 Onde as variáveis podem ser declaradas



Definidas fora de todas os métodos, incluindo o método main() são chamadas de
variáveis globais e podem ser acessadas em qualquer parte do programa. Estas
variáveis são alocadas estaticamente na memória RAM (Random Access Memory –
Memória de acesso randômico).
Quando definidas dentro de um método são chamadas de variáveis locais e só
podem ser acessadas dentro deste método. Estas variáveis são alocadas
dinamicamente na memória RAM.
Na declaração de parâmetros formais (argumentos) de um método. Sendo estas
locais e alocadas dinamicamente na memória RAM.
Observação: Memória ROM (Read Only Memory – Memória somente de leitura).
Alocação de memória: (Reserva de espaço de memória (RAM) para alocar uma variável)
10


Alocação estática de memória: Tipo de alocação de memória em que uma variável é
alocada (tem um espaço reservado) na memória RAM durante toda a execução do
programa. Este espaço de memória é desalocado somente quando o programa acaba.
Alocação dinâmica de memória: Tipo de alocação de memória em que uma variável é
alocada (tem um espaço reservado) na memória RAM temporariamente. Este espaço de
memória é desalocado quando o espaço não é mais necessário (coleta automática de
lixo – garbage collector).
Programa exemplo (2): O programa realiza uma operação de potência Xy.
// -------------------------------------------- Fonte: Prog2.java
package prog2;
import java.util.Scanner;
// importar classe Scanner
public class Prog2 {
// definição da classe Prog2
static double resultado;
// variável global
public static void main(String[] args) {
// definição das variáveis locais
Scanner entrada = new Scanner (System.in);
String s;
double base, expoente;
// método que permite imprimir na tela em modo texto
System.out.print("Base: ");
// método que permite entrada de dados via teclado em terminal texto
s = entrada.nextLine();
// método que converte String em double
base = Double.parseDouble(s);
System.out.print("Expoente: ");
s = entrada.nextLine();
expoente = Double.parseDouble(s);
// chamada do método POT
resultado = POT(base, expoente);
// método que imprime na tela com formatação do número
System.out.printf("Resposta = %7.2f\n", resultado);
}
// ---------------------------------- método estático POT
static double POT (double x, double y) {
// corpo do método POT definido pelo programador
// os argumentos x e y são variáveis locais
// definição de uma variável local
double resp;
resp = Math.exp(Math.log(x) * y);
return(resp);
// retorno do método
}
}
Resultado do Programa:
11
Base: 3 <enter>
Expoente: 4 <enter>
Resposta = 81,00
Variáveis globais: resultado
Variáveis locais: base, expoente, resp, x, y
Compilar por linha de comandos (via terminal):
$ javac Prog2.java <enter>
$
// gera arquivo Prog2.class
12
Executar por linha de comandos (via terminal):
$ java Prog2 <enter>
// executa o arquivo Prog2.class
2.5.2 Inicialização de variáveis
Em Java é possível fornecer valores iniciais a maioria das variáveis ao mesmo
tempo em que elas são declaradas, colocando um sinal de igual e uma constante após o
nome da variável.
tipo_dado_base nome_da_variável = constante;
Exemplos:
char ch = 'a';
// tipo_dado_base nome_da_variável = constante_caracter
String s = “Pelotas”;
// tipo_dado_base nome_da_variável = constante_string
int n = 0;
// tipo_dado_base nome_da_variável = constante_inteira
float y = 123.45f;
// tipo_dado_base nome_da_variável = constante_real
double z = 123.45;
int [] v = {10, 20, 30};
// vetor unidimensional
int [][] t = {{1, 2}, {3, 4}, {5, 6}};
// matriz bidimensional
String [] cidade = {“Pelotas”, “Rio Grande”, “Poa”};
char [] caracter = {‘S’, ‘s’, ‘N’, ‘n’};
2.6 Constantes
Valores fixos que o programa não pode alterar. As constantes podem ser de
qualquer tipo básico.
Tipo
Exemplos de constantes
char
int
float
String
'a'
'n'
'9'
1
123
2100
123.23 4.34e-3
-234
"Java" (classe String)
2.6.1 Constantes hexadecimais e octais
A linguagem de programação Java permite especificar constantes inteiras em
octal. Uma constante octal começa com um 0 (zero) antes dos demais números.
Exemplos:
int hexadecimal = 0xf;
int octal = 011;
// 15 em decimal
// 9 em decimal
Observações:


Qualquer número octal é formado por oito números ( 0 .. 7 ).
Qualquer número hexadecimal é formado por dezesseis números (0 ..9, A, B, C,
D, E, F).
// ------------------------------------------------------------- Fonte: Hexadecimal.java
package hexadecimal;
13
public class Hexadecimal {
public static void main(String[] args) {
for (int decimal = 0;decimal < 16; decimal++) {
String hexaDecimal = Integer.toHexString(decimal);
System.out.println("Decimal: " + decimal);
System.out.println("Hexadecimal: " + hexaDecimal);
// int hexaToDecimal = Integer.parseInt(hexaDecimal, 16);
// System.out.println("Hexadecimal para Decimal: " + hexaToDecimal);
}
}
}
Resultado do Programa:
Decimal: 0
Hexadecimal:
Decimal: 1
Hexadecimal:
Decimal: 2
Hexadecimal:
Decimal: 3
Hexadecimal:
Decimal: 4
Hexadecimal:
Decimal: 5
Hexadecimal:
Decimal: 6
Hexadecimal:
Decimal: 7
Hexadecimal:
Decimal: 8
Hexadecimal:
Decimal: 9
Hexadecimal:
Decimal: 10
Hexadecimal:
Decimal: 11
Hexadecimal:
Decimal: 12
Hexadecimal:
Decimal: 13
Hexadecimal:
Decimal: 14
Hexadecimal:
Decimal: 15
Hexadecimal:
Decimal: 16
Hexadecimal:
0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
10
2.6.2 Constantes Strings
Uma String é um conjunto de caracteres delimitados por aspas duplas que pode
conter letras, números e caracteres especiais. Em Java existe uma classe específica
para trabalhar com Strings (classe String).
Exemplo: String s = "Senac";
0
‘S’
1
‘e’
2
‘n’
3
‘a’
Figura 1: String
14
4
‘c’
Vetor de Strings:
String [] s = {“Paulo”, “Roberto”, “Gomes”, “Luzzardi”};
Vetor de caracteres:
char [] s = {'U', 'C', 'P', 'e', 'l'};
15
2.6.3 Constantes especiais
As constantes especiais são usadas para representar caracteres que não podem
ser inseridos pelo teclado. São elas:
Tabela 1: Constantes especiais
Constante
‘\b’
‘\f’
‘\n’
‘\r’
‘\t’
‘\”’
‘\’’
‘\\’
‘\o’
‘\x’
Significado
Retrocesso
Alimentação de formulário
Nova linha
Retorno de carro <CR>
Tab horizontal
Aspas duplas
Aspas simples
Barra invertida
Constante octal
Constante hexadecimal
2.7 Comandos do pré-processador do Java
2.7.1 O comando import
O comando import faz o compilador incluir um pacote de classes dentro do
programa fonte. Cada pacote possui diversas classes.
import java.util.Scanner; // pacote java.util e a classe Scanner
import javax.swing.*;
// pacote javax.swing e avisa que vai usar uma das classes
import java.awt.Graphics2d;
// pacote java.awt e a classe Graphics2d
Na URL abaixo você encontra as diversas api Java:
URL: http://java.sun.com/j2se/1.5.0/docs/api/
Resumo: Um pacote possui um conjunto de classes.
Exemplo: import javax.swing.JOptionPane;
Pacote: javax.swing
Classe: JOptionPane
Chamada de um dos Métodos da classe JOptionPane: JOptionPane.showMessageDialog();
Sintaxe: nomeClasse.nomeMétodo(lista_de_argumentos);
16
// chamada de métodos estáticos
3. Tipos de dados
3.1 Tipos básicos
A tabela abaixo exibe os oito (8) tipos de dados básicos que podem ser
utilizados pelo programador para definir suas variáveis. Na Tabela 2 são exibidos os
tipos básicos, a quantidade de bits, a faixa de valores válida e o número de bytes
que cada tipo de dados ocupa na memória RAM (memória principal) ou em disco (quando
armazenados na memória secundária).
Tabela 2: Tipos de dados
Tipo
boolean
char
byte
short
int
long
float
double
Bytes
1
2
1
2
4
8
4
8
Bits
8
16
8
16
32
64
32
64
Faixa de valores
true ou false
0 à 65.535
-128 à 127
-32.768 à 32.767
-2.147.483.648 à 2.147.483.647
-2E63 à 2E63
1.40239846e-46 à 3.40282347e+38
4.94065645841246544e-324 à 1.7976931348623157e+308
3.2 Escrevendo uma classe em Java
3.2.1 Conceitos básicos
O paradigma orientado à objetos possui cinco componentes básicos: objetos
(possui atributos e métodos), mensagens (chamada dos métodos), classes (tipo de
dado), instâncias (criação de objetos de uma classe específica - new) e métodos
(funções definidas pelo programador que manipulam os atributos).
Objetos, mensagens, classes, instâncias e métodos
Objetos são entidades lógicas que contém atributos (dados armazenados em
variáveis) e métodos (funções) que manipulam estes dados. Um objeto pode ser
definido através de um tipo de dado chamado classe (class).
Resumo:
a) Atributos: São as variáveis definidas e declaradas para cada objeto.
b) Métodos: São as funções definidas pelo programador que servirão para
manipular os atributos.
c) Mensagens: São as chamadas dos métodos.
d) Classe: É um tipo de dado definido por class. Uma classe não é um objeto, é
sim uma descrição do objeto.
e) Instância: Os objetos são instâncias de uma classe, ou seja, é criado um
objeto pertencente a uma classe específica. O objeto pode responder chamadas
dos métodos e armazenar informações nos atributos.
Resumidamente, objetos são instâncias de classes que respondem as mensagens
através dos métodos escritos pelo programador.
17
Uma linguagem de programação orientada à objetos pode suportar ou implementar
seis propriedades: abstração, encapsulamento, polimorfismo, herança, associação
(agregação e composição) e classes abstratas e concretas.
Exemplo de uma classe Vetor:
// -------------------------------------------------------- Vetor.java
package testavetor;
public class Vetor {
// -------------------------- atributos
private int[] vetor;
private int n;
private int max;
// ------------------------------ construtor
Vetor(int tam) {
max = tam;
vetor = new int[max];
n = 0;
}
// ------------------------------ add
public void add(int valor) {
if (n < max) {
vetor[n] = valor;
n++;
} else {
System.out.println("Erro: Vetor excedeu Limite");
}
}
// ------------------------------ exibe
public void exibe() {
System.out.print("Vetor: [");
for (int i = 0; i < n; i++) {
System.out.print(vetor[i] + " ");
}
System.out.println("]");
}
}
// ----------------------------------------------- TestaVetor.java
package testavetor;
public class Main {
public static void main(String[] args) {
Vetor v = new Vetor(5);
v.add(10);
v.add(20);
v.add(30);
v.add(40);
v.add(50);
v.exibe();
v.add(60);
v.exibe();
// testar o limite do vetor de 5 elementos
18
}
}
Resultado do Programa:
Vetor: [10 20 30 40 50 ]
Erro: Vetor excedeu Limite
Vetor: [10 20 30 40 50 ]
19
Tente implementar os seguintes métodos para a classe Vetor:
v.remove();
v.exibe();
System.out.println("Total de Elementos: " + v.length());
int pri = v.primeiro();
System.out.println("Primeiro: " + pri);
int ult = v.ultimo();
System.out.println("Último: " + ult);
boolean flag = v.existe(20);
if (flag) {
System.out.println("Existe elemento 20");
} else {
System.out.println("Não Existe elemento 20");
}
v.removeElemento(elemento);
v.exibe();
v.removePosicao(1);
v.exibe();
Uma linguagem de programação orientada à objetos pode suportar e/ou
implementar seis (6) propriedades: abstração, encapsulamento, polimorfismo,
herança, associação (agregação e composição) e classes abstratas e concretas.
Abstração
Objetos devem representar dados do mundo real.
Encapsulamento (“encapsulação”)
Os objetos possuem internamente atributos e métodos agrupados no mesmo local,
onde os métodos manipulam os atributos. Esta característica protege os dados
(atributos) de alterações indevidas, somente os membros da classe podem acessar os
atributos, desde que eles sejam privados (private) ou protegidos (protected) (caso
das classes derivadas, que herdam o direito de acesso aos atributos).
Polimorfismo (grego: “muitas formas”)
É a capacidade de objetos diferentes reagirem segundo a sua função a uma
ordem padrão. Significa que o nome de um objeto pode ser utilizado para vários
propósitos ligeiramente diferentes, ou seja, “ ... uma interface, vários métodos
... ”. A característica de polimorfismo é utilizada principalmente na sobrecarga de
métodos, sobrecarga de operadores e nas classes abstratas, onde os métodos são
declarados mas não definidos. Como tipos de polimorfismo tem-se: (a) Universal
(inclusão [como em Java, por exemplo, List lista = new LinkedList();] e paramétrico
[templates como em C++]) e (b) ad-hoc (sobrecarga de métodos e operadores). Java
não possui sobrecarga de operadores.

Sobrecarga de Operador: Permite sobrecarregar operadores para realizar
diferentes tipos de operações;

Sobrecarga de Método: Permite que um método retorne diferentes tipos de
informações e aceite argumentos de vários tipos, inclusive com quantidade
diferentes de argumentos;

Classes abstratas e concretas: Permite representar entidades e conceitos
abstratos, sendo sempre uma superclasse (ou classe Base) e não permite ser
20
instanciada, a classe abstrata apenas define um modelo (template) para uma
funcionalidade e fornece uma implementação incompleta que é herdada pelas
classes derivadas. Cada classe derivada implementa as funcionalidades da
classe abstrata. Uma classe abstrata pode possuir métodos abstratos, mas os
métodos são escritos nas classes derivadas concretas. Métodos abstratos
definem apenas a forma do método não contendo nenhum tipo de código. Classes
concretas implementam todos os métodos e podem ser instanciadas.
Herança
É o processo pelo qual uma classe de objetos pode adquirir as propriedades de
outra classe de objetos, em outras palavras, um objeto herda as características de
outro (herança simples) ou vários objetos (herança múltipla). A classe Base é
chamada de superclasse, enquanto a classe derivada pode ser chamada de subclasse.
Associação
É um vínculo que permite que objetos de uma ou mais classes se relacionem
entre si. Esta associação pode ser: unária (o vínculo é entre objetos da mesma
classe), binária (vínculo ocorre entre dois objetos de classes diferentes) ou
múltipla (vínculo ocorre entre mais de 2 objetos de classes diferentes). Cada
associação pode possuir características de (a) cardinalidade ou multiplicidade
(indica quantos objetos são possíveis em cada associação) e (b) navegação (existe a
possibilidade dos objetos acessarem outros objetos da mesma associação).
Uma associação pode ser de duas formas: agregação (Relacionamento com
características onde existe um grau menos intenso de coesão entre os elementos, pode
haver um certo grau de independência) ou composição (relacionamento com
características onde existe um alto grau de coesão e total grau de dependência entre
os elementos).
Classes Abstratas e Concretas
É criada para representar entidades e conceitos abstratos. Uma classe
abstrata é sempre uma superclasse ou classe base que não possui instâncias. Ela
define apenas o modelo (como um template em C++) para uma funcionalidade e fornece
uma implementação incompleta chamada de parte genérica sendo compartilhada por um
conjunto de classes derivadas ou subclasses. As classes derivadas completam as
funcionalidades da classe abstrata anexando um comportamento específico. Classes
abstratas possuem métodos abstratos. Esses métodos são implementados nas suas
classes derivadas concretas com o objetivo de definir o comportamento específico. O
método abstrato define apenas a assinatura do método não contendo nenhum código.
Classes concretas implementam seus métodos e permitem instanciar objetos. Classes
concretas não possuem métodos abstratos quando são classes derivadas de uma classe
abstrata.
Vantagens da Orientação a Objetos: (a) reutilização de código, (b) proteção aos
dados; (c) organização ou estruturação dos dados em forma de classes e objetos; (d)
sobrecarga de métodos e de operadores; (e) criação de pacotes de classes; (f) ter um
conjunto de pacotes pré-definidos (api’s: java2d, java3d, swing, awt, etc) e (g)
permitir ao desenvolvedor criar seus próprios pacotes.
Em Java, o programador pode criar suas próprias classes. Uma classe possui
duas partes distintas: atributos (variáveis) e métodos (funções ou procedimentos)
que manipulam estes atributos.
21
3.2.2 Referência this
Em java, quando um método de uma classe é chamado, é passado automaticamente
um argumento que é uma referência para o objeto que gerou a chamada. Esta referência
é chamada “this”, ou seja, a referência “this” referencia o objeto que chamou o
método.
Cada objeto tem acesso a uma referência a ele próprio, chamada this. Esta
referência faz referências aos atributos e métodos de um objeto.
Exemplo da utilização da referência this:
// -------------------------------------------------------- Data.java
package testadata;
import java.text.DecimalFormat;
public class Data {
// ------------------------------- atributos
private int dia, mes, ano;
// ------------------------------- construtor
Data(int dia, int mes, int ano) {
this.dia = dia;
this.mes = mes;
this.ano = ano;
}
// ------------------------------- sobrecarga do método toString
public String toString() {
DecimalFormat form = new DecimalFormat("00");
String data = "Data: " + form.format(dia) + "/" + form.format(mes) + "/" + ano;
return(data);
}
}
// ----------------------------------------------------------- TestaData.java
package testadata;
public class TestaData {
public static void main(String[] args) {
Data data = new Data(3, 9, 2011);
System.out.println(data);
}
}
Resultado do Programa:
Data: 03/09/2011
3.2.3 Lista de exercícios sobre Classes
22
3.2.3.1 Dado o seguinte programa principal, implemente a classe Circulo e seus
métodos:
// ------------------------------------------ TestaCirculo.java
package testacirculo;
public class TestaCirculo {
public static void main(String[] args) {
Circulo circ = new Circulo();
circ.setaRaio(3);
circ.calculaArea();
double area = circ.getArea();
System.out.printf("Área: %.2f\n", area);
}
}
2
Observação: area = pi . raio
onde pi é 3.1416
Círculo
double area, raio
setaRaio
calculaArea
getArea
Diagrama de classe
Resultado do Programa:
Área: 28,27
3.2.3.2 Dado o seguinte programa principal, implemente a classe PesoIdeal e seus
métodos:
// --------------------------------------------- Peso.java
package peso;
public class Peso {
public static void main(String[] args) {
PesoIdeal piHomem = new PesoIdeal('H', 1.67);
PesoIdeal piMulher = new PesoIdeal('m', 1.65);
piHomem.calculaPesoIdeal();
System.out.printf("Peso Ideal Homem: %.2f\n", piHomem.getPesoIdeal());
piMulher.calculaPesoIdeal();
System.out.printf("Peso Ideal Mulher: %.2f\n", piMulher.getPesoIdeal());
}
}
Resultado do Programa:
Peso Ideal Homem: 63,41
Peso Ideal Mulher: 57,77
Cálculo do Peso Ideal:
PIH = 72,7 x altura – 58
PIM = 62,1 x altura – 44,7
23
PesoIdeal
double altura, pi
char sexo
calculaPesoIdeal
getPesoIdeal
Diagrama de classe
3.2.3.3 Dado o seguinte programa principal, implemente a classe CPF e seus métodos:
// --------------------------------------------------------------- ValidaCPF.java
package validacpf;
public class ValidaCPF {
public static void main(String[] args) {
String s = "123456789";
CPF cpf = new CPF(s);
int digitoVerificador = cpf.verificaCPF();
System.out.printf("Digito verificador: %02d\n", digitoVerificador);
System.out.printf("CPF: %s-%02d\n", s , digitoVerificador);
}
}
Resultado do Programa:
Digito verificador: 09
CPF: 123456789-09
CPF
String cpf
int digito
verificaCPF
Diagrama de classe
Como calcular os Dígitos do CPF:
Entrada: CPF: 123456789
1) Primeiramente pega-se os dígitos da base do CPF e se faz a soma da multiplicação individual dos
dígitos, iniciando por 10 e indo até 2 como exemplificado abaixo:
1
2
3
4
5
6
7
8
9
x
x
x
x
x
x
x
x
x
10
9
8
7
6
5
4
3
2
---------10 + 18 + 24 + 28 + 30 + 30 + 28 + 24 + 18 = 210
2) O valor do primeiro dígito é o resultado da subtração de 11 pelo resto da divisão da soma acima por
11. Se este valor for 10 ou 11, o dígito é 0 (zero), do contrário é o próprio valor. No exemplo em
questão o dígito encontrado é calculado conforme vê-se a seguir:
11 - (210 % 11) = 10
3) O cálculo do segundo dígito é feito da mesma forma que o primeiro, porém com os 9 dígitos da base do
CPF e o primeiro dígito verificador encontrado, iniciando por 11 e indo até 2.
1
x
11
-11
2
x
10
-+ 20
3
4
x
x
9
8
--+ 27 + 32
5
6
7
8
9
0
x
x
x
x
x
x
7
6
5
4
3
2
------+ 35 + 36 + 35 + 32 + 27 + 0 = 255
24
4) O valor do segundo dígito é o resultado da subtração de 11 pelo resto da divisão da soma acima por
11. Se este valor for 10 ou 11, o dígito é 0 (zero), do contrário é o próprio valor. No exemplo em
questão o dígito encontrado é calculado conforme vê-se a seguir:
11 - (255 % 11) = 9
Saída: CPF válido é 123.456.789-09 ou 123456789-09
3.2.3.4 Dado o seguinte programa principal, implemente a classe DiaSemana e seus
métodos:
// ------------------------------------------------------- TestaDiaSemana.java
package testadiasemana;
public class TestaDiaSemana {
public static void main(String[] args) {
DiaSemana dia = new DiaSemana(18, 12, 2007);
dia.verificaDiaSemana();
dia.exibeDiaSemana();
}
}
Resultado do Programa:
Dia da Semana: Terça-Feira
DiaSemana
int dia, mes, ano
String semama
verificaDiaSemana
exibeDiaSemana
Diagrama de classe
Como calcular o Dia da Semana:
Deve-se calcular o Dia do Século:
Para qualquer cálculo com datas é essencial que se disponha do Dia do Século para a(s) data(s) em
questão. O Dia do século é o número de dias decorridos desde o inicio do século (1º de janeiro de 1901)
até a data em questão. Se usa como referência 1901 porque a maioria das datas com as quais se trabalha
ainda são do século passado. Lá por 2040 ou mais poderá se mudar para 2001.
A fórmula (válida para datas entre 1901 e 2099) é a seguinte:
Dia_do_Seculo = (ano - 1901) * 365 + (ano - 1901) DIV 4 + dia + (mês - 1) *31 - [(mês * 4 + 23) DIV 10]
* [(mês + 12) DIV 15] + [(4 - ano MOD 4) DIV 4) * [(mês + 12) DIV 15]
Entrada:
Dia [1..31]: 18
Mês [1..12]: 12
Ano [1901..2099]: 2007
Dia_do_Seculo = 39.068 (para a data acima)
Verificação do Dia da Semana:
Para saber o Dia_da_Semana basta dividir por 7 e entrar com o resto na tabela abaixo:
0
Segunda
1
Terça
2
Quarta
25
3
Quinta
4
Sexta
5
Sábado
6
Domingo
Resultado do Programa: 18/12/2007 é uma Terça-Feira
Observação: DIV é divisão inteira de dois números e MOD é o resto inteiro da divisão de dois números
3.2.3.5 Dado o seguinte programa principal, implemente a classe Data e seus métodos:
// ------------------------------------------------- TestData.java
package testdata;
public class TestData {
public static void main(String[] args) {
Data data = new Data();
data.setaData(4, 9, 2011);
data.extenso();
}
}
Resultado do Programa:
Data: 4 de setembro de 2011
Data
int dia, mes, ano
setaData
extenso
Diagrama de classe
3.2.3.6 Implemente os métodos “sortForcaBruta” e “bubleSort” na classe Vetor
vista no item 3.2.
v.sortForcaBruta();
v.exibe();
v.bubbleSort();
v.exibe();
3.2.3.7 Dado o seguinte programa principal, implemente a classe Pessoa e seus
métodos.
// --------------------------------------------------- TestaPessoa.java
package testapessoa;
public class TestaPessoa {
public static
Pessoa p1
Pessoa p2
Pessoa p3
void main(String[] args) {
= new Pessoa();
= new Pessoa();
= new Pessoa();
p1.setaDados("Paulo Roberto", 1962, 'm');
p2.setaDados("Renato Luis", 1965, 'm');
p3.setaDados("Francisco Carlos", 1959, 'm');
26
p1.calculaIdade();
p2.calculaIdade();
p3.calculaIdade();
p1.exibePessoa();
p2.exibePessoa();
p3.exibePessoa();
}
}
Resultado do Programa:
Nome: Paulo Roberto
Idade: 49 ano(s)
Sexo: Masculino
Nome: Renato Luis
Idade: 46 ano(s)
Sexo: Masculino
Nome: Francisco Carlos
Idade: 52 ano(s)
Sexo: Masculino
Pessoa
String nome
int ano
int idade
char sexo
setaDados
calculaIdade
exibePessoa
Diagrama de classe
3.2.3.8 Dado o seguinte programa principal, implemente a classe Pessoa e seus
métodos.
// ----------------------------------------------------- TestaPessoa2.java
package testapessoa2;
public class TestaPessoa2 {
public static void main(String[] args) {
Pessoa [] pessoa = new Pessoa[3];
pessoa[0] = new Pessoa();
pessoa[0].setaDados("Paulo Roberto", 1962, 'm');
pessoa[0].calculaIdade();
pessoa[0].exibePessoa();
pessoa[1] = new Pessoa();
pessoa[1].setaDados("Renato Luis", 1960, 'm');
pessoa[1].calculaIdade();
pessoa[1].exibePessoa();
pessoa[2] = new Pessoa();
pessoa[2].setaDados("Francisco Carlos", 1959, 'm');
pessoa[2].calculaIdade();
pessoa[2].exibePessoa();
}
}
Resultado do Programa:
Nome: Paulo Roberto
Idade: 49 ano(s)
27
Sexo: Masculino
Nome: Renato Luis
Idade: 51 ano(s)
Sexo: Masculino
Nome: Francisco Carlos
Idade: 52 ano(s)
Sexo: Masculino
Pessoa
String nome
int ano
int idade
char sexo
setaDados
calculaIdade
exibePessoa
Diagrama de classe
3.2.3.9 Dado o seguinte programa principal, implemente a classe Pessoa e seus
métodos.
// -------------------------------------------------- Pessoas.java
package pessoas;
public class Pessoas {
public static void main(String[] args) {
Pessoa pessoa = new Pessoa(7);
pessoa.insereDados("Beatriz", 11);
pessoa.insereDados("Debora", 13);
pessoa.insereDados("Fátima", 15);
pessoa.insereDados("Geni", 16);
pessoa.insereDados("Carla", 12);
pessoa.insereDados("Eva", 14);
pessoa.insereDados("Ana", 10);
pessoa.exibeDados();
pessoa.sort();
pessoa.exibeDados();
}
}
Resultado do Programa:
Lista
Nome:
Nome:
Nome:
Nome:
Nome:
Nome:
Nome:
Lista
Nome:
Nome:
Nome:
Nome:
Nome:
Nome:
Nome:
de Pessoas
Beatriz
Debora
Fátima
Geni
Carla
Eva
Ana
de Pessoas
Ana
Beatriz
Carla
Debora
Eva
Fátima
Geni
Idade:
Idade:
Idade:
Idade:
Idade:
Idade:
Idade:
11
13
15
16
12
14
10
Idade:
Idade:
Idade:
Idade:
Idade:
Idade:
Idade:
10
11
12
13
14
15
16
Pessoa
String [] nome
28
int [] idade
int n
insereDados
exibeDados
sort
Diagrama de classe
3.2.3.10
Dado o seguinte programa principal, implemente a classe Agenda e seus
métodos.
// ------------------------------------------------------- TestAgenda.java
package testagenda;
public class TestAgenda {
public static void main(String[] args) {
Agenda agenda = new Agenda(5);
agenda.insereTelefone("Ana", "99811234");
agenda.insereTelefone("Beatriz", "99812345");
agenda.insereTelefone("Carla", "99813456");
agenda.insereTelefone("Debora", "99814567");
agenda.insereTelefone("Eva", "99815678");
agenda.insereTelefone("Fátima", "99816789");
String fone = "99815678";
String nome = agenda.consultaNome(fone);
if (nome.compareTo("") != 0) {
System.out.println("Nome: " + nome + " - Telefone: " + fone);
} else {
System.out.println("ERRO: Usuário não Encontrado");
}
fone = "99810123";
nome = agenda.consultaNome(fone);
if (nome.compareTo("") != 0) {
System.out.println("Nome: " + nome + " - Telefone: " + fone);
} else {
System.out.println("ERRO: Usuário não Encontrado");
}
}
}
Resultado do Programa:
ERRO: Excedeu limite do Vetor
Nome: Eva - Telefone: 99815678
ERRO: Usuário não Encontrado
Agenda
String [] nome
String [] fone
int n
int max
insereTelefone
consultaNome
Diagrama de classe
A seguir o programa teste (TestVetor) proposto anteriormente:
// ------------------------------------------------- TestVetor.java
package testvetor;
public class TestVetor {
29
public static void main(String[] args) {
Vetor v = new Vetor(5);
v.add(10);
v.add(20);
v.add(30);
v.add(40);
v.exibe();
v.add(50);
v.exibe();
v.add(60);
v.exibe();
v.remove();
System.out.println("Total de Elementos: " + v.length());
int pri = v.primeiro();
System.out.println("Primeiro: " + pri);
int ult = v.ultimo();
System.out.println("Último: " + ult);
int elemento = 20;
boolean flag = v.existe(elemento);
if (flag) {
System.out.println("Existe elemento: " + elemento);
} else {
System.out.println("Não Existe elemento: " + elemento);
}
v.removeElemento(elemento);
v.exibe();
v.removePosicao(1);
v.exibe();
}
}
// -------------------------------------------------- vetor.java
package testvetor;
public class Vetor {
// ------------------ atributos
private int[] v;
private int n;
private int max;
// ------------------ construtor
Vetor(int max) {
this.max = max;
v = new int[this.max];
n = 0;
}
// ------------------ add
public void add(int valor) {
if (n < max) {
v[n] = valor;
n++;
} else {
System.out.println("ERRO: Excedeu o Limite do Vetor");
}
}
// ------------------ remove
public void remove() {
if (n > 0) {
30
n--;
} else {
System.out.println("ERRO: Vetor Vazio");
}
}
// ------------------ removeElemento
public void removeElemento(int valor) {
if (n > 0) {
for (int i = 0; i < n; i++) {
if (valor == v[i]) {
for (int j = i; j < n - 1; j++) {
v[j] = v[j + 1];
}
n--;
break;
}
}
} else {
System.out.println("ERRO: Vetor Vazio");
}
}
// ------------------ removePosicao
public void removePosicao(int posicao) {
if (n > 0 && posicao > 0 && posicao < n) {
for (int j = posicao; j < n - 1; j++) {
v[j] = v[j + 1];
}
n--;
} else {
System.out.println("ERRO: Vetor Vazio");
}
}
// ------------------ primeiro
public int primeiro() {
if (n > 0) {
return (v[0]);
} else {
return (-1);
}
}
// ------------------ ultimo
public int ultimo() {
if (n > 0) {
return (v[n - 1]);
} else {
return (-1);
}
}
// ----------------- exibe
public void exibe() {
System.out.print("Vetor: [");
for (int i = 0; i < n-1; i++) {
System.out.print(v[i] + " ");
}
System.out.println(v[n-1] + "]");
}
31
// ----------------- length
public int length() {
return (n);
}
// ----------------- existe
public boolean existe(int valor) {
for (int i = 0; i < n; i++) {
if (v[i] == valor) {
return (true);
}
}
return (false);
}
}
Resultado do Programa:
Vetor: [10 20 30 40]
Vetor: [10 20 30 40 50]
ERRO: Excedeu o Limite do Vetor
Vetor: [10 20 30 40 50]
Total de Elementos: 4
Primeiro: 10
Último: 40
Existe elemento: 20
Vetor: [10 30 40]
Vetor: [10 40]
Exemplo da definição de uma classe “Data”:
// ----------------------------------------------- Fonte: Data.java
package data;
public class Data {
private int dia, mes, ano;
// atributos da classe
public Data(int dd, int mm, int aa) {
dia = dd;
mes = mm;
ano = aa;
}
// construtor da classe
// ------------------------------- sobrecarga do método toString
public String toString() {
return(dia + "/" + mes + "/" + ano);
}
}
Programa exemplo que utiliza a classe “Data”:
// --------------------------------------------- Fonte: Main.java
package data;
public class Main {
public static void main(String[] args) {
Data data = new Data(16, 3, 2010);
System.out.println(data);
32
}
}
Exemplo da definição de uma classe “Calculadora”:
// -------------------------------------------------------- Fonte: Calculadora.java
package calc;
import javax.swing.*;
public class Calculadora {
// ............................................. lista de atributos da classe
private double x, y, resp;
private char op;
private int erro;
// ............................................. métodos públicos da classe
public Calculadora () {
erro = 0;
}
// construtor
// ---------------------------- entradaDados
public void entradaDados() {
String s;
s = JOptionPane.showInputDialog("Digite um Valor: ");
x = Double.parseDouble(s);
do {
s = JOptionPane.showInputDialog("Operador [+ - * / Rr Pp Ss Cc Tt]: ");
op = s.charAt(0);
} while (!strChr("+-*/RrPpSsCcTt", op));
if (!strChr("RrSsCcTt", op)) {
s = JOptionPane.showInputDialog("Digite outro Valor: ");
y = Double.parseDouble(s);
}
}
// ---------------------------- operaCalculadora
public void operaCalculadora() {
final double pi = 3.14158;
double rads;
switch (op)
{
case '+':
case '-':
case '*':
case '/':
case 'R':
case 'r':
resp = soma(x, y);
break;
resp = subtracao(x, y);
break;
resp = multiplicacao(x, y);
break;
if (y == 0)
erro = 1;
// divisao por zero
else
resp = divisao(x, y);
break;
if (x < 0)
erro = 2;
// raiz negativa
else
resp = raizQuadrada(x);
// Raiz Quadrada
33
break;
case 'P':
case 'p':
case 'S':
case 's':
case 'C':
case 'c':
case 'T':
case 't':
resp = power(x, y);
break;
resp = seno(x);
break;
// potencia
// seno
resp = cosseno(x);
break;
// cosseno
if (x == 90 || x == 180) {
erro = 3;
}
else {
resp = tangente(x);
// tangente
}
break;
}
}
// ---------------------------- exibeCalculadora
public void exibeCalculadora() {
switch (erro) {
case 1: JOptionPane.showMessageDialog(null, "Erro: Divisao por Zero",
"Calculadora", JOptionPane.PLAIN_MESSAGE);
break;
case 2: JOptionPane.showMessageDialog(null, "Erro: Raiz Complexa",
"Calculadora", JOptionPane.PLAIN_MESSAGE);
break;
case 3: JOptionPane.showMessageDialog(null, "Erro: Tangente Infinita",
"Calculadora", JOptionPane.PLAIN_MESSAGE);
break;
default: JOptionPane.showMessageDialog(null, "Resposta: " + resp,
"Calculadora", JOptionPane.PLAIN_MESSAGE);
}
}
// ................................................ métodos privados da classe
// ---------------------------- strChr
private boolean strChr(String s, char ch) {
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == ch) {
return(true);
}
}
return(false);
}
// ---------------------------- soma
private double soma(double x, double y) {
return(x + y);
}
// ---------------------------- subtracao
private double subtracao(double x, double y) {
return(x - y);
}
// ---------------------------- multiplicacao
34
private double multiplicacao(double x, double y) {
return(x * y);
}
// ---------------------------- divisao
private double divisao(double x, double y) {
if (y == 0) {
erro = 1;
return(-1);
}
return(x / y);
}
// ---------------------------- raizQuadrada
private double raizQuadrada(double x) {
return(Math.sqrt(x));
}
// ---------------------------- power
private double power(double x, double y) {
return(Math.pow(x, y));
}
// ---------------------------- seno
private double seno(double x) {
final double pi = 3.14158;
double rads;
rads = x * pi / 180.0;
return(Math.sin(rads));
}
// ---------------------------- cosseno
private double cosseno(double x) {
final double pi = 3.14158;
double rads;
rads = x * pi / 180.0;
return(Math.cos(rads));
}
// ---------------------------- tangente
private double tangente(double x) {
final double pi = 3.14158;
double rads;
rads = x * pi / 180.0;
return(Math.tan(rads));
}
}
Programa exemplo que utiliza a classe “Calculadora”:
// ---------------------------------------------- Fonte: Calc.java
package calc;
public class Calc {
public static void main(String[] args) {
35
Calculadora calc = new Calculadora();
calc.entradaDados();
calc.operaCalculadora();
calc.exibeCalculadora();
}
}
Programa exemplo que mostra outra forma de usar a função “strChr” oriunda da
linguagem C usando o método “indexOf”:
// --------------------------------------------------- Fonte: strchr.java
package strchr;
import java.util.Scanner;
public class strChr {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String nome, s;
do {
System.out.print("Nome: ");
nome = entrada.nextLine();
int n = nome.length();
System.out.println(nome + " seu nome tem " + n + " caracteres");
do {
System.out.print("Continua [S/N]? " );
s = entrada.nextLine();
} while ("SsNn".indexOf(s) == -1);
} while ("Nn".indexOf(s) == -1); // } while ("S".equalsIgnoreCase(s));
}
}
Resultado do Programa:
Nome: Paulo Roberto Gomes Luzzardi <enter>
Paulo Roberto Gomes Luzzardi seu nome tem 28 caracteres
Continua [S/N]? N <enter>
Modificadores de Acesso:

public: Os atributos e métodos tornam-se públicos, ou seja, qualquer outro
método pode chamar ou utilizar estes atributos e/ou métodos.

private: Somente os métodos da classe (membros) da classe podem chamar ou
utilizar atributos ou métodos privados.

protected:
Utilizado em herança simples de classe (construção de
subclasses), ou seja, uma subclasse herda todos os atributos e métodos da
classe base (superclasse). Deixa acessível os atributos e/ou métodos para
todas as outras classes (classe base) e subclasses (classe derivada).
3.3 Sobrecarga de métodos em Java
Java permite que métodos estáticos sejam sobrecarregados, desta forma, o
retorno, número de argumentos ou mesmo o tipo de dados dos argumentos possam ser
diferentes.
36
// ------------------------------------------ Fonte: SobreCarga.java
package sobrecarga;
public class SobreCarga {
public static void main(String[] args) {
imprime("Pelotas-RS");
imprime(123.45);
imprime(123.45f);
imprime(123);
imprime('A');
}
static void imprime(String s) {
System.out.println("String: " + s);
}
static void imprime(double d) {
System.out.println("Double: " + d);
}
static void imprime(float f) {
System.out.println("Float: " + f);
}
static void imprime(int i) {
System.out.println("Inteiro: " + i);
}
static void imprime(char ch) {
System.out.println("Caracter: " + ch);
}
}
Resultado do Programa:
String: Senac-RS
Double: 123.45
Float: 123.45
Inteiro: 123
Caracter: A
37
4. Métodos de entrada e saída de dados
A seguir são mostrados alguns métodos que permitem fazer entrada de dados via
teclado e saída de dados via monitor (tela).
4.1 Entrada de dados via teclado
A seguir é visto um exemplo de entrada de dados usando o pacote Scanner.
Programa exemplo (8): Entrada de Dados via teclado em terminal de texto usando a
biblioteca Scanner.
// ---------------------------------------------- Fonte: Prog8.java
package prog8;
import java.util.Scanner;
public class Prog8 {
public static void main(String[] args) {
Scanner input = new Scanner (System.in);
System.out.print("Inteiro: ");
String s = input.nextLine();
int x = Integer.parseInt(s);
System.out.println("Valor: " + x);
// ou x = input.nextInt();
}
}
Resultado do Programa:
Inteiro: 7 <enter>
Valor: 7
A seguir é visto um exemplo de entrada de dados usando o pacote swing.
Programa exemplo (9): Entrada de dados via teclado em caixa de diálogo gráfica
sobreposta a interface usando a biblioteca “swing”.
// --------------------------------------------- Fonte: Prog9.java
package prog9;
import javax.swing.*;
// carrega toda a biblioteca swing
public class Prog9 {
public static void main(String[] args) {
String s = JOptionPane.showInputDialog("String: ");
int x = Integer.parseInt(s);
JOptionPane.showMessageDialog(null, "Inteiro: " + x,
"Resultado", JOptionPane.PLAIN_MESSAGE);
// JOptionPane.showMessageDialog(null, "Inteiro: " + x);
// funciona também, pois os dois últimos argumentos podem ser suprimidos
}
}
A seguir é visto um exemplo de entrada de dados usando o pacote java.io
(BufferReader e InputStreamReader).
38
Programa exemplo (10): Entrada de dados via teclado em terminal textual usando as
bibliotecas “BufferedReader” e “InputStreamReader“ .
// ----------------------------------------------- Fonte: Prog10.java
package prog10;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Prog10 {
public static void main(String[] args) throws IOException {
BufferedReader userInput = new BufferedReader
(new InputStreamReader(System.in));
System.out.print("Nome: ");
String nome = userInput.readLine();
Integer n = nome.length();
System.out.println("Nome: " + nome + " tem " +
nome.length() + " caracteres");
}
}
Resultado do Programa:
Nome: Paulo Roberto <enter>
Nome: Paulo Roberto tem 13 caracteres
4.2 Saída de dados via tela
A seguir é visto um exemplo de saída de dados na tela usando o método
“System.out.print”.
Programa
exemplo
(11):
Saída
de
dados
via
tela
usando
“System.out.print”, “System.out.println” ou “System.out.printf”.
// -------------------------------------------- Fonte: Prog11.java
package Prog11;
import java.util.Scanner;
public class Prog11 {
public static void main(String[] args) {
Scanner entrada = new Scanner (System.in);
String s;
int x;
System.out.print("Inteiro: ");
s = entrada.nextLine();
x = Integer.parseInt(s);
System.out.println("Valor: " + x);
System.out.printf("Valor: %03d\n ", x);
}
}
39
o
método
Resultado do Programa:
Inteiro: 16 <enter>
Valor: 16
Valor: 016
A seguir é visto um exemplo de saída de dados na tela usando o pacote swing.
Programa exemplo (12): Saída de dados via tela em caixa de diálogo gráfica
sobreposta a interface usando a biblioteca “swing”.
// ------------------------------------------ Fonte: Prog12.java
package Prog12;
import javax.swing.*;
// carrega toda a biblioteca swing
public class Prog12 {
public static void main(String[] args) {
String s;
s = JOptionPane.showInputDialog("String: ");
int x = Integer.parseInt(s);
JOptionPane.showMessageDialog(null, "Inteiro: " + x,
"Resultado", JOptionPane.PLAIN_MESSAGE);
}
}
Sintaxe:
JOptionPane.showMessageDialog(null, “x = ” + x, “Título”, JOptionPane.PLAIN_MESSAGE);
null significa que a mensagem será centralizada
“x = “ + x significa que sairá na caixa de dialogo x = 5 (por exemplo)
“Título” significa o título da caixa de diálogo
JOptionPane.PLAIN_MESSAGE significa caixa sem ícone
Tabela 3: Tipos de Ícones
Tipo de Ícone
Ícone de erro
Ícone de informação “i”
Ícone de advertência “!”
Ícone de pergunta “?”
Sem ícone
Tipo de Mensagem
JOptionPane.ERROR_MESSAGE
JOptionPane.INFORMATION_MESSAGE
JOptionPane.WARNING_MESSAGE
JOptionPane.QUESTION_MESSAGE
JOptionPane.PLAIN_MESSAGE
40
5. Operadores
São símbolos especiais que obrigam o compilador a executar determinadas
operações. Estas operações podem ser aritméticas, comparativas ou lógicas.
5.1 Operadores aritméticos
São operadores que realizam uma operação matemática.
Tabela 4: Operadores aritméticos
Operador aritmético
+
*
/
%
-- ++
Ação
Subtração
Adição
Multiplicação
Divisão
Resto inteiro da divisão
Decremento/incremento
Precedência dos operadores aritméticos (Hierarquia nas Operações)
Tabela 5: Precedência dos operadores aritméticos
Hierarquia
1
2
3
4
5
6
Operação
Parênteses
Métodos
++ -- (menos unário)
* / %
+ -
Observação: Quando houver duas ou mais operações de mesma hierarquia, o compilador
executa-as da esquerda para a direita.
5.2 Operadores relacionais
São operadores que permitem comparar valores, ou seja, são utilizados
principalmemte em comandos que possuem condições.
Tabela 6: Operadores relacionais
Operador
>
>=
<
<=
==
!=
Ação
Maior que
Maior ou igual a
Menor que
Menor ou igual
Igual a
Diferente de
5.3 Operadores lógicos
São operadores utilizados em comandos que tem mais de uma condição.
Exemplo:
if (condição1 && condição2 || condição3)
41
Tabela 7: Operadores lógicos
Operador lógica
&& ou &
|| ou |
!
Ação
AND (e)
OR (ou)
NOT (não)
Observação: $$ e || são chamados Short Circuit Operator , ou seja, quando o
resultado das condições não puder mais ser alterado, há um truncamento nas próximas
condições.
Precedência (Hierarquia dos operadores)
Tabela 8: Precedência dos operadores relacionais e lógicos
Hierarquia
1
2
3
4
5
Operação
!
> >= < <=
== !=
&&
||
Observação: As expressões que utilizam operadores relacionais e lógicos retornam 0
(zero) para falso e !0 (não zero) para verdadeiro, ou seja:
true é diferente de 0 (!= 0)
e
false é igual 0 (== 0)
5.4 Incremento e decremento
São operadores aritméticos
subtração de forma simplificada.


que
permitem
realizar
operações
de
soma
e
++ adiciona (1) ao operando
subtrai (1) ao operando
As seguintes operações são equivalentes:
x++;
x = x + 1;
x--;
x = x - 1;
Observação:
Os operadores (++ ou --) podem ser colocados antes ou depois do operando.
Quando precede seu operando, Java efetua a operação de incremento ou decremento antes
de utilizar o valor do operando. Quando o operador vier depois do operando, Java
utiliza o valor do operando antes de incrementá-lo ou decrementá-lo.
Exemplo:
Equivalência
x = 10;
y = ++x;
//
y será 11
x = 10;
// x será 11
x = x + 1;
y = x;
x = 10;
y = x++;
//
y será 10
x = 10;
// x será 11
y = x;
x = x + 1;
5.5 Operador de atribuição
42
O operador de atribuição é o sinal de igual =. A sintaxe do operador de
atribuição pode ser escrito em uma das seguintes formas:
variável
variável
variável
variável
=
=
=
=
constante;
variável;
expressão;
método(x);
x
x
x
x
=
=
=
=
3;
y;
a + b;
Math.sqrt(y);
Programa exemplo (13): O programa calcula a idade de uma pessoa.
// ------------------------------------------ Fonte: Prog13.java
package Prog13;
import java.util.Scanner;
public class Prog13 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int idade, ano_atual, ano_nasceu;
// leitura do ano atual
System.out.print("Ano ATUAL: ");
s = entrada.nextLine();
ano_atual = Integer.parseInt(s);
System.out.print("Ano de NASCIMENTO: ");
s = entrada.nextLine();
// leitura do ano de nascimento
ano_nasceu = Integer.parseInt(s);
// atribuição – cálculo da idade
idade = ano_atual - ano_nasceu;
System.out.println("Sua IDADE é " + idade);
}
}
Resultado do Programa:
Ano ATUAL: 2013 <enter>
Ano de NASCIMENTO: 1962 <enter>
Sua IDADE é 51
A linguagem de programação Java permite utilizar o operador de atribuição em
expressões, junto com operadores matemáticos, lógicos, relacionais, chamada de
métodos, e outros (como foi mencionado acima).
if ((produto = x * y) < 0)
Funcionamento: Primeiramente Java atribui o valor x * y a variável produto, para
depois avaliar a expressão, ou seja, comparar se o produto é menor (<) que zero.
5.6 Casts
É possível forçar que o resultado de uma expressão seja de um determinado
tipo. Para tanto deve ser utilizado uma construção chamada de cast, ou seja, pode
43
ser utilizado para "tipar" uma variável com um tipo diferente do resultado da
expressão.
variável = (tipo) expressão;
Programa exemplo (14): O programa imprime na tela o resultado de uma divisão.
// -------------------------------------------- Fonte: Prog14.java
package Prog14;
import java.util.Scanner;
public class Prog14 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int x, y;
float resp;
System.out.print("x = ");
s = entrada.nextLine();
x = Integer.parseInt(s);
System.out.print("y = ");
s = entrada.nextLine();
y = Integer.parseInt(s);
// é necessário um cast (float) pois a divisão de dois
resp = (float) x / y;
// inteiros resulta em um inteiro
System.out.printf("Divisao = %.2f\n", resp);
}
}
Resultado do Programa:
x = 3 <enter>
y = 4 <enter>
Divisao = 0,75
Observação: Em Java, o tipo resultante de um inteiro dividido por outro inteiro é um
inteiro, logo, deve-se utilizar um cast (float) para que o tipo resultante atribuído
a variável resp seja float.
5.7 Expressões
Uma expressão em Java é qualquer combinação válida de
(aritméticos, relacionais, lógicos), constantes, variáveis e métodos.
Exemplo:
c = Math.sqrt (a) + b / 3.4;
44
operadores
6. Métodos para funções matemáticas padrões
Java possui uma classe: Math que possui diversos métodos para resolver
funções matemáticas. Algumas são descritas a seguir:
6.1 Math.abs
O método Math.abs retorna o valor positivo (absoluto).
Sintaxe:
int Math.abs(int x);
float Math.abs(float x);
long Math.abs(long x);
double Math.abs(double x);
6.2 Math.asin
O método Math.asin retorna o valor do arco seno. A variável x deve estar em
radianos.
Sintaxe: double Math.asin (double x);
Faixa: -pi / 2 à pi / 2
6.3 Math.acos
O método Math.acos retorna o valor do arco cosseno. A variável x deve estar
em radianos.
Sintaxe: double Math.acos (double x);
Faixa: 0 à pi
6.4 Math.atan
O método Math.atan retorna o valor do arco tangente. A variável x deve estar
em radianos.
Sintaxe: double Math.atan (double x);
Faixa: -pi / 2 à pi / 2
6.5 Math.sin
O método Math.sin retorna o valor do seno. A variável x deve estar em
radianos.
Sintaxe: double Math.sin (double x);
Faixa: -1 à 1
6.6 Math.cos
O método Math.cos retorna o valor do cosseno. A variável x deve estar em
radianos.
45
Sintaxe: double Math.cos (double x);
Faixa: -1 à 1
46
6.7 Math.tan
O método Math.tan retorna o valor da tangente. A variável x deve estar em
radianos.
Sintaxe: double Math.tan (double x);
6.8 Math.exp
O método Math.exp retorna o valor do expoente (ex).
Sintaxe: double Math.exp (double x);
6.9 Math.pow
O método Math.pow (power) retorna o valor da potência (xy).
Sintaxe: double Math.pow (double x, double y);
6.10 Math.sqrt
O método Math.sqrt (square root) retorna o valor da raiz quadrada.
Sintaxe: double Math.sqrt (double x);
6.11 Math.log
O método Math.log retorna o valor do logaritmo natural.
Sintaxe: double Math.log (double x);
6.12 Double.parseDouble
O método Double.parseDouble converte string em ponto flutuante.
Sintaxe: double Double.parseDouble (String s);
6.13 Integer.parseInt
O método aInteger.parseInt converte uma string em inteiro.
Sintaxe: int Integer.parseInt (String s);
6.14 Long.parseLong
O método Long.parseLong converte uma string em inteiro longo.
Sintaxe: long Long.parseLong (String s);
47
6.15 Math.log10
O método Math.log10 retorna o logarítmo na base 10.
Sintaxe: double Math.log10 (double x);
6.16 Math.random
O método Math.random retorna um número double aleatário.
Sintaxe: double Math.random (void);
Faixa: 0.0 à 100.0
public static int geraNumeroAleatorio(int n) {
int num = 1 + (int)(Math.random() * n);
return(num);
}
// gera um número de 1 até n
6.17 Math.PI
O método Math.PI retorna o valor do pi radianos.
Sintaxe: double Math.PI (void);
Valor: 3.141592653589793
6.18 Conversão de graus para radianos
Figura 2: Conversão de graus para radianos
Conversão de graus para radianos:
rads = graus * Math.PI / 180.0;
Conversão de radianos para graus:
graus = rads * 180.0 / Math.PI;
48
7. Comandos
7.1 Tipos de comandos
7.1.1 Sequência
São comandos, que no fluxo de controle do programa, são sempre executados
passando a execução para a próxima instrução, ou seja, todos os comandos de
seqüência são executados desde que eles não dependem de um comando de seleção.
Exemplo: (todas as instruções abaixo são de seqüência)
System.out.print("Digite uma letra: ");
// imprime na tela
s = entrada.nextLine();
// entrada de dados via teclado
resp = valor * 1.25;
// atribuição é um comando de seqüência
7.1.2 Seleção
São comandos, que no fluxo de controle do programa, permitem a seleção entre
duas ou mais instruções, ou seja, este tipo de comando faz com que alguns comandos
não sejam executados.
Exemplo:
if (numero % 2 == 0) {
// testa se o número é par ou ímpar
System.out.println("Número: PAR");
}
else {
System.out.println("Número: ÍMPAR");
}
ou
Programa Exemplo (15): Programa extrai a raiz quadrada de um número.
// ------------------------------------------ Fonte: Prog15.java
package Prog15;
import java.util.Scanner;
public class Prog15 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
double x, raiz;
System.out.print("Digite um valor: ");
s = entrada.nextLine();
x = Double.parseDouble(s);
if (x < 0) {
// esta instrução só é executada se o valor de x for negativo
x = Math.abs(x);
}
raiz = Math.sqrt(x);
System.out.printf("Raiz Quadrada: %.2f\n", raiz);
}
}
49
Resultado do Programa:
Digite um valor: 12 <enter>
Raiz Quadrada: 3,46
50
Operador Ternário (?):
Funcionamento:
comando2.
Se
a
condição for verdadeira, executa comando1 senão executa
condição ? comando1 : comando2;
|
^
^
|
|
|
+--------+
|
|
|
+-------------------+
Exemplo (1): int menor = x <= y ? x : y;
// se x <= y ... menor = x;
// se x > y ... menor = y;
Exemplo (2): int menor;
x <= y ? menor = x : menor = y;
// se x <= y ... menor = x;
// se x > y ... menor = y;
// --------------------------------------------------------------- Fonte: Ternario.java
package ternario;
import java.util.Scanner;
public class Ternario {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
System.out.print("Digite um valor: ");
s = entrada.nextLine();
int x = Integer.parseInt(s);
System.out.print("Digite outro valor: ");
s = entrada.nextLine();
int y = Integer.parseInt(s);
int menor = x < y ? x : y;
System.out.println("menor: " + menor);
int maior = x > y ? x : y;
System.out.println("maior: " + maior);
}
}
Resultado do Programa:
Digite
Digite
menor:
maior:
um Valor: 45 <enter>
outro Valor: 34 <enter>
34
45
7.1.3 Repetição
São comandos, que no fluxo de controle do programa, permitem a repetição de
uma ou mais instruções.
51
Programa Exemplo (16): O programa exibe na tela de 0 até 9.
// ----------------------------------------------- Fonte: Prog16.java
package prog16;
public class Prog16 {
public static void main(String[] args) {
final int n = 10;
int i = 0;
do {
System.out.println("n = " + i);
i++;
} while (i < n);
}
}
Resultado do Programa:
n
n
n
n
n
n
n
n
n
n
=
=
=
=
=
=
=
=
=
=
0
1
2
3
4
5
6
7
8
9
7.2 Comando if
O comando if é um comando de seleção que permite selecionar um comando entre
dois outros comandos (comandos simples) ou dois conjuntos de comandos (comandos
compostos). Isto é feito através da avaliação de uma condição. O resultado desta
avaliação (teste da condição) pode ser verdadeiro (true) ou falso (false).
Dependendo deste resultado um dos comandos é executado e o outro não.
Sintaxe:
if (condição) {
comando 1;
}
else {
comando 2;
if (condição) {
comando;
}
ou
}
Observação: O else é opcional.
Se a condição for avaliada como verdadeira (qualquer valor diferente de 0), o
comando 1 será executado, caso contrário (condição falsa, valor igual a zero) o
comando 2 será executado. Comando 1, comando 2 ou comando podem ser simples ou
compostos (quando há mais de um comando ligado a outro, deve-se utilizar chaves ({
}). Veja exemplos abaixo
if (condição)
if (condição)
52
{
{
comando 1;
comando 2;
}
else
comando 1;
comando 2;
comando 3;
}
{
comando 3;
comando 4;
// todos os comando são compostos
}
Programa exemplo (17): O usuário digita um número e o programa diz se este é par ou
ímpar.
// ------------------------------------------- Fonte: Prog17.java
package prog17;
import javax.swing.*;
public class Prog17 {
public static void main(String[] args) {
String s;
int numero;
s = JOptionPane.showInputDialog("Digite um número: ");
numero = Integer.parseInt(s);
if ((numero % 2) == 0) {
JOptionPane.showMessageDialog(null, "Número é PAR",
"Números", JOptionPane.PLAIN_MESSAGE);
}
else {
JOptionPane.showMessageDialog(null, "Número é IMPAR",
"Números", JOptionPane.PLAIN_MESSAGE);
}
}
}
7.2.1 if encadeados
Um if aninhado (ou encadeado) é um comando if dentro de outro comando if ou
if ... else.
Programa exemplo (18): O usuário digita um número e o programa diz se este é zero,
positivo ou negativo.
// -------------------------------------------- Fonte: Prog18.java
package prog18;
import javax.swing.*;
public class Prog18 {
public static void main(String[] args) {
String s;
int num;
s = JOptionPane.showInputDialog("Digite um número: ");
num = Integer.parseInt(s);
if (num == 0) {
JOptionPane.showMessageDialog(null, "Número é Zero",
53
"Verifica", JOptionPane.PLAIN_MESSAGE);
}
else {
if (num > 0) {
JOptionPane.showMessageDialog(null, "Número é Positivo",
"Verifica", JOptionPane.PLAIN_MESSAGE);
}
else {
JOptionPane.showMessageDialog(null, "Número é Negativo",
"Verifica", JOptionPane.PLAIN_MESSAGE);
}
}
}
}
7.3 O comando switch
O comando switch é um comando de seleção que permite selecionar um comando
entre vários outros comandos. Isto é feito através da comparação de uma variável a
um conjunto de constantes. Cada um dos comandos está ligado a uma constante.
54
Sintaxe:
switch (variável)
{
case constante_1 : seqüência de comandos;
break;
case constante_2 : seqüência de comandos;
break;
.
.
.
default: seqüência de comandos;
}
O programa testa uma variável sucessivamente contra uma lista de constantes
inteiras ou caracteres (int, char ou String). Depois de encontrar uma coincidência,
o programa executa o comando ou bloco de comandos que estejam associados àquela
constante. O comando default é executado se não houver nenhuma coincidência.
O comando break é utilizado para obrigar a saída do comando switch.
A opção default é opcional.
Observação: A variável não pode ser real (float ou double).
Programa exemplo (19): O programa recebe um dígito de 0 à 9 e imprime na tela, este
dígito, por extenso. Neste exemplo a variável dígito é inteira.
// ---------------------------------------------- Fonte: Prog19.java
package prog19;
import javax.swing.*;
public class Prog19 {
public static void main(String[] args) {
String s;
int digito;
s = JOptionPane.showInputDialog("Digito: ");
digito = Integer.parseInt(s);
switch (digito) {
case 0: JOptionPane.showMessageDialog(null, "Zero",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 1: JOptionPane.showMessageDialog(null, "Um",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 2: JOptionPane.showMessageDialog(null, "Dois",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 3: JOptionPane.showMessageDialog(null, "Três",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 4: JOptionPane.showMessageDialog(null, "Quatro",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 5: JOptionPane.showMessageDialog(null, "Cinco",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
55
case 6: JOptionPane.showMessageDialog(null, "Seis",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 7: JOptionPane.showMessageDialog(null, "Sete",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 8: JOptionPane.showMessageDialog(null, "Oito",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 9: JOptionPane.showMessageDialog(null, "Nove",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
default: JOptionPane.showMessageDialog(null,
"ERRO: Não é um Dígito", "Digito", JOptionPane.PLAIN_MESSAGE);
}
}
}
Programa exemplo (20): O programa recebe um dígito de 0 à 9 e imprime na tela, este
dígito, por extenso. Neste exemplo a variável dígito é caracter, por causa disto as
constantes estão entre apostrofes.
// ----------------------------------------- Fonte: prog20.java
package prog20;
import javax.swing.*;
public class Prog20 {
public static void main(String[] args) {
String s;
char digito;
s = JOptionPane.showInputDialog("Digito: ");
digito = s.charAt(0);
switch (digito) {
case '0': JOptionPane.showMessageDialog(null, "Zero",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '1': JOptionPane.showMessageDialog(null, "Um",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '2': JOptionPane.showMessageDialog(null, "Dois",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '3': JOptionPane.showMessageDialog(null, "Três",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '4': JOptionPane.showMessageDialog(null, "Quatro",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '5': JOptionPane.showMessageDialog(null, "Cinco",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '6': JOptionPane.showMessageDialog(null, "Seis",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '7': JOptionPane.showMessageDialog(null, "Sete",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '8': JOptionPane.showMessageDialog(null, "Oito",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case '9': JOptionPane.showMessageDialog(null, "Nove",
56
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
default: JOptionPane.showMessageDialog(null,
"ERRO: Não é um Dígito", "Digito", JOptionPane.PLAIN_MESSAGE);
}
}
}
Programa exemplo (21): O programa constrói um menu com três métodos: inclusão,
alteração e término.
// ------------------------------------------ Fonte: prog21.java
package prog21;
import java.util.Scanner;
public class Prog21 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
char opcao;
System.out.println("[I]nclusão");
System.out.println("[A]lteração");
System.out.println("[T]érmino");
System.out.print("Qual a opção: ");
s = entrada.nextLine();
opcao = s.charAt(0);
switch (opcao) {
case 'i':
case 'I': inclusao();
break;
case 'a':
case 'A': alteracao();
break;
case 't':
case 'T': termino();
break;
default: System.out.println("ERRO: Opção Inválida");
}
}
static void inclusao() {
System.out.println("Opção Escolhida: Inclusão");
}
static void alteracao() {
System.out.println("Opção Escolhida: Alteração");
}
static void termino() {
System.out.println("Opção Escolhida: Término");
}
}
7.4 Comando while
O comando while é um comando de repetição que permite executar um comando
(simples) ou vários comandos (composto) diversas vezes. Isto é feito através da
avaliação de uma condição. Enquanto a condição for
verdadeira os comandos são
repetidos. Quando a condição se tornar falsa o comando while é finalizado. O teste
57
da condição é feita no início do comando, ou seja, antes que todos os comandos sejam
executados.
Observação: Note que os comandos podem não ser executados nenhuma vez, basta a
condição começar como falsa.
Sintaxe:
while (condição) {
comando;
}
ou
while (condição)
{
comando 1;
comando 2;
}
Condição: Qualquer expressão válida em Java com resultado 0 ( false) ou !0 (true).
Na condição podem ser utilizados ainda variáveis, constan-tes, métodos, operadores
(aritméticos, relacionais e lógicos).
Funcionamento do comando: O loop (laço) é repetido enquanto a condição for
verdadeira. Quando a condição se tornar falsa o controle do programa passa para a
próxima instrução. O laço while verifica a condição no início do laço, por causa
disto, normalmente, a variável de controle do laço deve ser inicializado.
Exemplo:
int i = 0;
// inicialização da variável de controle
while (i <= 10)
{
// condição i <= 10
System.out.printf(“i = %d\n”, i);
i = i + 1;
// incremento
}
Comando: Pode ser um comando vazio, simples ou composto que serão repetidos.
Comando vazio: while (1); // comando while não repete nenhum comando
for (int i = 0; i <= 1000; i++);
// comando for não repete nenhum comando
Verifique: Note que no final dos dois comandos ( while e for) existe apenas um
ponto-e-vírgula, isto é o sinal de comando vazio, ou seja, os comandos while e for
que teriam outros comandos não os tem, caracterizando comandos vazios.
Problema freqüente de digitação: Muitas vezes o programador insere um ponto-evírgula no final de um comando for ou while por engano. Isto é um grave problema,
pois este ponto-e-vírgula (inserido acidentalmente) faz com que os comandos que
seriam repetidos, não são. Veja o exemplo abaixo:
Exemplo:
for (int x = 1; x <= 10; x++);
// note o ponto-e-vírgula no final do comando for
System.out.printf(“x = %d\n”, x);
// é impresso x = 11 na tela, porque?
Explicação: O comando System.out.printf não faz parte do comando if devido ao
ponto-e-vírgula no comando for. O comando for termina quando a variável de controle
x chega ao valor 11.
Comando correto:
for (int x = 1; x <= 10; x++) {
System.out.printf(“x = %d\n”, x);
58
}
Programa exemplo (22): O programa imprime caracteres de ‘A’ até ‘Z’ na tela.
// ----------------------------------------- Fonte: Prog22.java
package prog22;
public class Prog22 {
public static void main(String[] args) {
char letra = 'A'; // inicialização da variável de controle
while (letra != 'Z') {
System.out.printf ("Letra: %c\n", letra);
letra++;
// incremento
}
}
}
Resultado do Programa:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
7.5 O comando for
O comando for é um comando de repetição que permite executar um comando
(comando simples) ou vários comandos (comando composto) diversas vezes. Isto é feito
através da avaliação de uma condição. Enquanto a condição for
verdadeira os
comandos são repetidos. Quando a condição se tornar falsa o comando for é
finalizado.
Sintaxe:
for (inicialização; condição; incremento ou decremento) {
comando;
}
Exemplos:
59
Com uma variável de controle:
for (int i = 0;i < 9;i++) {
System.out.println(i);
}
Com duas variável de controle:
for (int i = 1, int j = 5;i != j;i++, j--) {
System.out.println(i + “-“ + j);
}
Inicialização: É um comando de atribuição (ou vários, separados por vírgula) que o
compilador utiliza para inicializar a(s) variável(is) de controle do laço.
Condição: É uma expressão qualquer, que testa a variável de controle do laço contra
algum valor para determinar quando o laço terminará.
Incremento ou decremento: Define a maneira como a(s) variável(is) de controle do
laço serão alteradas após a repetição do laço.
O laço (for) é repetido enquanto a condição é verdadeira.
A condição é sempre testada no começo do laço.
Qualquer uma das 3 partes do comando for (inicialização; condição; incremento)
podem ser qualquer expressão válida em Java.



Programa exemplo (23): O programa imprime de 1 até 10 na tela.
// --------------------------------------------- Fonte: prog23.java
package prog23;
public class Prog23 {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
// inicialização: i = 1
System.out.printf("%d\n",i);
// condição: i <= 10
}
// incremento: i++
}
}
Programa exemplo (24): O programa imprime na tela:
i = 1 - j = 9
i = 2 - j = 8
i = 3 – j = 7
// --------------------------- Fonte: Prog24.java
i = 4 – j = 6
package prog24;
public class Prog24 {
public static void main(String[] args) {
for (int i = 1,int j = 9; i != j; i++,j--) {
System.out.printf("i = %d - j = %d\n", i ,j);
}
}
}
Resultado do Programa:
i
i
i
i
=
=
=
=
1
2
3
4
-
j
j
j
j
=
=
=
=
9
8
7
6
60
O laço for é equivalente ao seguinte comando:
inicialização;
while (condição)
{
comando;
incremento;
}
// ou decremento
ou
inicialização;
do {
comando;
incremento;
} while (condição);
// ou decremento
7.6 O loop do { } while
O comando do ... while é um comando de repetição que permite executar um
comando (comando simples) ou vários comandos (comando composto) diversas vezes. Isto
é feito através do teste de uma condição. Enquanto a condição for verdadeira os
comandos são repetidos. Quando a condição se tornar falsa o comando do ... while é
finalizado. O teste da condição é feita no final do comando, ou seja, depois que os
comandos são executados (Note que os comandos são executados pelo menos uma vez).
Sintaxe:
do {
comando;
} while (condição);


Repete o laço enquanto a condição for verdadeira.
Testa a condição no final, fazendo com que o laço seja executado pelo menos uma
vez.
Programa exemplo (25): Imprime na tela de 1 até 10.
// ----------------------------------------------- Fonte: Prog25.java
package prog25;
public class Prog25 {
public static void main(String[] args) {
int i = 1;
do {
System.out.printf("i = %d\n",i);
i++;
} while (i <= 10);
}
}
Resultado do Programa:
i = 1
61
i
i
i
i
i
i
i
i
i
=
=
=
=
=
=
=
=
=
2
3
4
5
6
7
8
9
10
7.7 Interrupção de loops
7.7.1 O comando break
Quando o programa encontra o comando break dentro de um laço, ele
imediatamente encerra o laço, e o controle do programa segue para o próximo comando
após o laço.
Programa exemplo (26): O programa imprime na tela a tecla digitada pelo usuário até
que ele digite <F> ou <f>.
// ---------------------------------------------- Fonte: Prog26.java
package prog26;
public class Prog26 {
public static void main(String[] args) throws Exception {
char tecla;
do {
System.out.print("Tecla ou [F]im: ");
tecla = (char) System.in.read();
if (tecla == 'F' || tecla == 'f') {
// encerra o laço quando o usuário teclar 'F' ou 'f'
break;
}
System.out.printf("Tecla: %c - Codigo: %d\n",
tecla, (int) tecla);
} while (true);
// laço eterno
}
}
Resultado do Programa:
Tecla ou [F]im: a <enter>
Tecla: a - Codigo: 97
Tecla ou [F]im: Tecla: <enter>
- Codigo: 10
// enter que o usuário digitou
Tecla ou [F]im: b <enter>
Tecla: b - Codigo: 98
Tecla ou [F]im: Tecla: <enter>
- Codigo: 10
Tecla ou [F]im: A <enter>
Tecla: A - Codigo: 65
Tecla ou [F]im: Tecla: <enter>
- Codigo: 10
Tecla ou [F]im: B <enter>
Tecla: B - Codigo: 66
Tecla ou [F]im: Tecla: <enter>
- Codigo: 10
Tecla ou [F]im: f <enter>
62
7.7.2 O comando continue
O comando continue em vez de forçar o encerramento, força a próxima interação
do laço e "pula", ou seja, não executa o código que estiver depois do comando
continue.
Programa exemplo (27): O programa imprime na tela somente os números pares de 0 até
100.
// ------------------------------------------ Fonte: Prog27.java
package prog27;
public class Prog27 {
public static void main(String[] args) {
for (int i = 0; i < 30; i++) {
if (i % 2 == 1) {
continue;
}
// imprime somente números pares
System.out.printf("Par: %d\n", i);
}
}
// 0 é par, 1 é impar
}
Resultado do Programa:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
Par:
0
2
4
6
8
10
12
14
16
18
20
22
24
26
28
Nos laços while e do {} while um comando continue faz com que o controle do
programa execute diretamente o teste da condição e depois continue o processo do
laço.
No caso do comando for, o programa primeiro executa o incremento (ou
decremento) do laço e, depois, executa o teste da condição antes de finalmente fazer
o laço continuar.
63
7.8 O método System.exit ()
O método System.exit aborta o programa em qualquer situação.
Modo de usar:
System.exit(0); ou
System.exit(1);
8. Saída formatada (System.out.printf)
Como na linguagem C, as saídas (impressões) na tela podem ser formatadas em
Java.
Sintaxe: System.out.printf ("string de controle", lista de variáveis);
String de controle: Formada pelos caracteres que o método imprime na tela, e pelos
comandos de formatação (%c, %s, %d, %f) que definem a maneira como as variáveis
serão impressas e caracteres especiais (\n, \t, ...).
Tabela 9: Comandos de formatação
Código
%s
%d
%i
%o
%u
%x
%X
%f
%e
%g
%E
%G
%c
%%
Tipo
String
int
int
int
int
int
int
float
float
float
float
float
char
nada
Formato
String (vetor de caracteres)
Inteiro decimal com sinal
Inteiro decimal com sinal
Inteiro octal sem sinal
Inteiro decimal sem sinal
Inteiro hexadecimal sem sinal (com a, b, c, d, e, f)
Inteiro hexadecimal sem sinal (com A, B, C, D, E, F)
Valor com sinal da forma [-]dddd.dddd
Valor com sinal da forma [-]d.dddd e [+/-]ddd
Valor com sinal na forma e ou f baseado na precisão do valor dado
Mesmo que e, mas com E para expoente
Mesmo que g, mas com E para expoente
Um caracter
O caracter % é impresso
Flags (Bandeiras):



(-) Alinha o resultado à esquerda. Preenche o restante do campo com brancos. Se não é
colocado, alinha o resultado à direita e preenche o restante à esquerda com zeros ou brancos.
(+) O resultado sempre começa com o sinal + ou (#) Especifica que o argumento será impresso usando uma das formas alternativas
Formas alternativas:


0
x ou X
É colocado zeros (0) antes do argumento
É colocado 0x (ou 0X) antes do argumento
64
Especificadores de largura do campo a ser impresso (exemplos):
Tabela 10: Especificadores de largura do campo
Prefixo
%-+#0
%-+#
%-+0
%-+
%-#0
%-#
%-0
%%+#0
%+#
%+0
%+
%#0
%#
%0
%
6d
+00555
+555
+00555
+555
000555
555
000555
555
+00555
+555
+00555
+555
000555
555
000555
555
6o
01053
01053
01053
1053
001053
01053
01053
1053
01053
01053
01053
1053
001053
01053
001053
1053
8x
0x0022b
0x22b
000022b
22b
0x00022b
0x22b
0000022b
22b
0x0022b
0x22b
000022b
22b
0x00022b
0x22b
0000022b
22b
65
10.2e
+5.50e+000
+5.50e+000
+5.50e+000
+5.50e+000
05.50e+000
5.50e+000
05.50e+000
5.50e+000
+5.50e+000
+5.50e+000
+5.50e+000
+5.50e+000
05.50e+000
5.50e+000
05.50e+000
5.50e+000
10.2f
+000005.50
+5.50
+000005.50
+5.50
0000005.50
5.50
0000005.50
5.50
+000005.50
+5.50
+000005.50
+5.50
0000005.50
5.50
0000005.50
5.50
9. Lista de exercícios (comandos)
9.1 Escreva um programa em Java que recebe dois valores via teclado: cateto
adjacente (b) e cateto oposto (a) e calcula o valor da hipotenusa dado pela
seguinte fórmula:
Fórmula:
h2 = a2 + b2
Exemplo (Tela):
Cateto adjacente (b): 3 <enter>
Cateto oposto (a): 4 <enter>
Hipotenusa: 5
9.2 Escreva um programa em Java que lê 4 notas via teclado: n1, n2, n3 e n4 obtidas
por um aluno em 4 avaliações. Calcule a média utilizando a seguinte fórmula:
n1 + n2 * 2 + n3 * 3 + n4
Média = --------------------------7
A seguir imprima na tela a média e o conceito do aluno baseado na seguinte tabela:
Média
9,0 ou acima de 9,0
entre 7,5 (inclusive) e 9,0
entre 6,0 (inclusive) e 7,5
abaixo de 6,0
Conceito
A
B
C
D
9.3 Escreva um programa em Java que recebe via teclado: comprimento da
circunferência. O programa deve calcular e imprimir na tela o diâmetro e o raio da
circunferência (veja exemplo abaixo).
Exemplo:
Comprimento da circunferência: 36 <enter>
Diâmetro: 11.46
Raio: 5.73
Continua [S/N]? N <enter>
comprimento da circunferência = 2 . PI . raio
diâmetro = 2 . raio
Observação: Programa termina se usuário digitar ‘N’ ou ‘n’ na pergunta: Continua [S/N]?
9.4 Desenvolva um programa em Java que recebe via teclado: peso da carne que será
vendida (em quilos) e preço por quilo. O programa deve calcular e imprimir na tela o
total a pagar, o valor pago ao ICMS (17%) e o lucro líquido do açougue.
Exemplo (Tela):
Peso: 3.5 <enter>
66
Preço por Kg (R$): 4.90 <enter>
Total a pagar: 17.15
ICMS (17%): 2.91
Lucro líquido do açougue (R$): 14.24
Sair [S/N]? n <enter>
Peso: 1.5 <enter>
Preço por Kg (R$): 9.00 <enter>
Total a pagar: 13.5
ICMS (17%): 2.29
Lucro líquido do açougue (R$): 11.21
Sair [S/N]? S <enter>
9.5 Escreva um programa em Java que recebe via teclado: tipo de animal [1] Gado,
[2] Eqüinos ou [3] Ovinos, preço unitário do animal e quantidade de animais
comprados. O programa deve calcular e imprimir na tela: preço total pago e a
comissão do escritório de remate (gado - 5%, eqüinos - 7% e ovinos - 3%), conforme
exemplo abaixo:
Exemplo (Tela):
Tipo de animal [1] Gado, [2] Eqüinos ou [3] Ovinos: 1 <enter>
Preço unitário do animal (R$): 200 <enter>
Quantidade de animais: 10 <enter>
Preço total pago (R$): 2100.00
Comissão a pagar (R$): 100.00
Continua [S/N]? s <enter>
Tipo de animal [1] Gado, [2] Eqüinos ou [3] Ovinos: 2 <enter>
Preço unitário do animal (R$): 1000 <enter>
Quantidade de animais: 1 <enter>
Preço total pago (R$): 1070.00
Comissão a pagar (R$): 70.00
Continua [S/N]? N <enter>
9.6 Reescreva o programa anterior recebendo via teclado uma letra para o tipo de
animal [G]ado, [E]qüinos ou [O]vinos, preço unitário do animal e quantidade de
animais comprado. O programa deve calcular e imprimir na tela: preço total pago e a
comissão do escritório de remate (gado: 5%, eqüinos: 7% e ovinos: 3%), conforme
exemplo abaixo:
Exemplo (Tela):
Tipo de animal [G]ado, [E]qüinos ou [O]vinos: g <enter>
Preço unitário do animal (R$): 200 <enter>
Quantidade de animais: 10 <enter>
Preço total pago (R$): 2100.00
Comissão a pagar (R$): 100.00
Continua [S/N]? s <enter>
9.7 Escreva um programa em Java que recebe via teclado: a data de hoje da seguinte
forma: dia, mês, ano e a sua idade, da seguinte forma: anos, meses e dias vividos.
O programa deve calcular e imprimir a data de nascimento no seguinte formato:
dd/mm/aaaa.
Exemplo (Tela):
Qual a data de hoje:
Dia: 16 <enter>
Mês: 6 <enter>
Ano: 2003 <enter>
Qual a sua idade:
Anos: 41 <enter>
Meses: 4 <enter>
67
Dias: 6 <enter>
Data de Nascimento: 10/02/1962
Continuar [S/N]? s <enter>
9.8 Escreva um programa em Java que recebe via teclado um número inteiro de 0 à 99.
O programa deve imprimir na tela este número por extenso (conforme exemplo abaixo).
O programa termina quando o usuário digitar 0 (zero).
Exemplo: Número [0..99]: 23 <enter>
Vinte e três
Número [0..99]: 45 <enter>
Quarenta e cinco
Número [0..99]: 0 <enter>
9.9 Escreva um programa em Java que recebe via teclado: quantidade de litros
vendidos, tipo de combustível ([A]lcool, [G]asolina ou [D]iesel) e o tipo de
pagamento ([P]razo ou [V]ista). O programa deve calcular e imprimir na tela: total
à prazo, desconto e o total à vista. O programa termina quando o usuário digitar
'N' ou 'n' na pergunta "Continua [S/N]?".
Tela de execução:
Valores:
Quantidade de litros? 50 <enter>
Álcool - 1,23
Tipo de combustível [A]lcool, [G]asolina ou [D]iesel ? G <enter> Gasolina - 2,19
Tipo de pagamento [P]razo ou a [V]ista ? V <enter>
Diesel - 1,46
Total à prazo (R$) : 109.50
Desconto (R$): 5.48
Desconto à vista: 5%
Total à vista (R$): 104.02
Continua [S/N]? N <enter>
9.10 Escreva um programa em Java que recebe via teclado duas notas: nota1 e nota2.
O programa deve imprimir na tela a média, o conceito do aluno (dado pela tabela
abaixo) e a situação (aprovado, exame ou reprovado):
Conceito
A
B
C
D
Nota1 + Nota2
Média = ----------------2
Média
9,0 à 10,0
7,0 à 8,9
6,0 à 6,9
0,0 à 5,9
Situação
Aprovado
Aprovado
Exame
Reprovado
Exemplo:
Nota1: 7 <enter>
Nota2: 8 <enter>
Média: 7.5
Conceito: B
Situação: Aprovado
Sair [S/N]? s <enter>
Observação: Programa termina se o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?
9.11 Escreva um programa em Java que recebe via teclado uma temperatura e o tipo de
conversão (converter para: [C]elsius ou [F]ahrenheit). Calcule e imprima na tela a
temperatura correspondente a solicitação do usuário, conforme exemplos abaixo:
Exemplo:
Temperatura: 30 <enter>
Tipo de conversão (converte para: [C]elsius ou [F]ahrenheit): F <enter>
Temperatura em Fahrenheit: 86
Continua [S/N]? S <enter>
Temperatura: 86 <enter>
Tipo de conversão (converte para: [C]elsius ou [F]ahrenheit): C <enter>
68
Temperatura em Celsius: 30
Continua [S/N]? n <enter>
Fórmula:
C
9 . --- =
5
F -
32
9.12 Escreva um programa em Java que recebe via teclado: graus (0 à 360), minutos
(0 à 59) e segundos (0 à 59). O programa deve calcular e imprimir na tela o ângulo
em graus, dado pela seguinte fórmula:
ângulos em graus = graus +
minutos
---------- +
60
segundos
---------3600
Exemplo:
Graus: 45 <enter>
Minutos: 45 <enter>
Segundos: 45 <enter>
Ângulo em Graus: 45.76
Continua [S]im ou [N]ão? S <enter>
Graus: 45 <enter>
Minutos: 10 <enter>
Segundos: 15 <enter>
Ângulo em Graus: 45.17
Continua [S]im ou [N]ão? N <enter>
Observação: Imprimir mensagens de erro se os valores de entrada estiverem fora da faixa:
ERRO: Graus fora da faixa, ERRO: Minutos fora da faixa ou ERRO: Segundos fora da faixa.
9.13 Escreva um programa em Java que recebe via teclado: sexo ([M]asculino ou
[F]eminino), altura e peso da pessoa. O programa deve calcular e imprimir na tela:
peso ideal, diferença de peso e situação (MAGRO, IDEAL ou GORDO) (conforme exemplo
abaixo):
Exemplo: Sexo [M]asculino ou [F]eminino: M <enter>
Altura: 1.65 <enter>
Peso: 92 <enter>
Peso Ideal: 62.0
Diferença de Peso: 30.0
Situação: GORDO
Sair [S/N]? s <enter>
PIM = 72,7 x altura – 58
PIF = 62,1 x altura – 44,7
MAGRO
IDEAL
GORDO
-------------------|-------------------|---------------------5%
pi
5%
Observação: Programa termina se o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?
69
10. Vetores, Matrizes e Strings
Um vetor é uma coleção de variáveis de mesmo tipo (agregados homogêneos) que
são referenciadas pelo mesmo nome, utilizando-se um índice para diferencia-los.
Um vetor consiste em locações contíguas de memória, ou seja, os elementos
encontram-se em sequência (contiguidade física). O menor endereço corresponde ao
primeiro elemento, e o maior corresponde ao último elemento.
Uma vantagem na utilização de um vetor é poder armazenar vários valores
(elementos), na memória RAM, ao mesmo tempo, permitindo, por exemplo, compará-los e
classificá-los.
Exemplo: Vetor unidimensional de inteiros (idades).
Tabela 11: Exemplo de um vetor unidimensional
Índice
Valor
0
24
1
12
2
36
3
41
10.1 Vetores
Vetor (matriz de uma dimensão - 1D) é um tipo especial de matriz que possui
apenas um índice, ou seja, permite armazenar variáveis unidimensionais (permite
representar uma tabela).
tipo_dado [] nome_do_vetor = new tipo_dado [número_de_elementos];
Onde:
tipo_dado: tipo de dado de cada elemento ( char, byte, int, short, long, float,
double).
nome_do_vetor: nome da variável que irá representar o vetor
número_de_elementos: número total de elementos do vetor
primeiro elemento: 0
último elemento: número_de_elementos – 1
número de bytes ocupados na memória RAM:
número_de_elementos x quantidade_de_bytes_de_um_elemento
Exemplo: int [] x = new int[10];
// 10 elementos: x[0] à x[9]
primeiro elemento: x[0]
último elemento: x[número_de_elementos – 1], ou seja, x[9]
número de bytes: 10 x 4 = 40 bytes (um inteiro ocupa 4 bytes)
70
10.2 Strings
Um objeto do tipo String (cadeia de caracteres) pode ser copiado para um
vetor de caracteres. Veja o exemplo a seguir:
ASCII: Americam Standard Code for Information Interchange.
url: http://www.asciitable.com
Programa Exemplo (28): Programa cópia todos os caracteres de uma String para um
vetor de caracteres.
// ----------------------------------------- Fonte: Prog28.java
package prog28;
import java.util.Scanner;
public class Prog28 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
System.out.print("String: ");
s = entrada.nextLine();
int n = s.length();
char [] vetorCaracter = new char[n];
for (int i = 0;i < s.length();i++) {
vetorCaracter[i] = s.charAt(i);
}
System.out.print("Vetor: ");
for (int i = n - 1;i >= 0;i--) {
System.out.print(vetorCaracter[i]);
}
System.out.println();
}
}
Resultado do Programa:
String: pelotas <enter>
Vetor: satolep
10.3 Matrizes (Multidimensional)
tipo_dado [][] nome_matriz = new tipo_dado [tamanho][tamanho];
Exemplo: float [][] y = new float [5][5];
// matriz 2D
Para acessar o elemento 3, 4 da matriz y, deve-se escrever y[3][4]. Note que
o primeiro elemento é y[0][0] e o último elemento é y[4][4]. O total de elementos é
25.
Programa Exemplo (28a): O programa possui uma matriz bidimensional para gerar e
exibir na tela “n” palpites para a Mega Sena.
// ------------------------------------------- Fonte: Prog28a.java
71
package prog28a;
import javax.swing.*;
public class Prog28a {
public static void main(String[] args) {
int n = entradaDados();
int [][] sena = new int [n][6];
geraPalpites(n, sena);
sort(n, sena);
exibePalpites(n, sena);
}
// --------------------------- entradaDados
static int entradaDados() {
String s;
s = JOptionPane.showInputDialog("Numero de Palpites: ");
int n = Integer.parseInt(s);
return(n);
}
// --------------------------- geraPalpites
static void geraPalpites(int n, int [][] sena) {
int num;
boolean repetido;
for (int i = 0;i < n;i++) {
for (int j = 0;j < 6;j++) {
do {
num = (int) (1 + (Math.random() * 60));
System.out.println(num);
repetido = testaRepetido(num, sena[i]);
if (!repetido) {
sena[i][j] = num;
}
} while (repetido);
}
}
}
// --------------------------- testaRepetido
static boolean testaRepetido(int num, int [] sena) {
for (int i = 0;i < 6;i++) {
if (num == sena[i]) {
return(true);
}
}
return(false);
}
// --------------------------- sort
static void sort(int n, int [][] sena) {
for (int k = 0;k < n;k++) {
for (int i = 0;i < 5;i++) {
for (int j = i+1;j < 6;j++) {
if (sena[k][i] > sena[k][j]) {
int temp = sena[k][i];
sena[k][i] = sena[k][j];
sena[k][j] = temp;
}
72
}
}
}
}
// --------------------------- exibePalpites
static void exibePalpites(int n, int [][] sena) {
for (int i = 0;i < n;i++) {
String extenso = "";
for (int j = 0;j < 6;j++) {
extenso = extenso + sena[i][j] + " ";
}
JOptionPane.showMessageDialog(null,
"Palpite:
JOptionPane.PLAIN_MESSAGE);
}
}
}
"
+
extenso,
"Mega
Sena",
10.4 Vetor de Strings
Para criar um vetor de Strings deve-se declarar assim:
String [] nome = new String[3];
nome[0] = “Senac”;
nome[1] = “Furg”;
nome[2] = “UFPel”;
String [] s = {“Pelotas”, “Rio Grande“, “Bagé}”;
Tabela 12: Exemplo de um vetor de strings
0
1
2
3
4
0
‘S’
‘e’
‘n’
‘a’
‘c’
1
‘F’
‘u’
‘r’ ‘g’
2
‘U’
‘F’
‘P’
‘e’
‘l’
Cria um vetor com três Strings. Para acessar uma String em particular deve-se
especificar o índice entre colchetes, ou seja, nome[0], nome[1] ou nome[2].
10.5 Inicialização de matrizes e vetores
tipo_dado [][] nome_matriz = {lista_valores};
lista_valores: lista de constantes separadas por vírgulas que são compatíveis em
tipo com o tipo base da matriz.
Exemplo:
int [] i = {0,1,2,3,4,5,6,7,8,9};
// 10 elementos
Observação: Quando um vetor é declarado e inicializado (ao mesmo tempo) o número de
elementos (neste caso 10) pode ser suprimido, ou seja, neste caso é opcional (veja
exemplo anterior).
10.6 Inicialização de um vetor de caracteres
char [] nome_vetor
= {lista_de_caracteres};
73
Exemplo:
char [] str = {‘s’, ‘i’, ‘m’};
0
‘s
’
1
‘i’
2
‘m’
10.7 Inicialização de matrizes multidimensionais
int [][] y = { {1,1}, {2,4}, {3,9}, {4,16} };
y[0][0]
y[0][1]
y[1][0]
y[1][1]
=
=
=
=
1
1
2
4
y[2][0]
y[2][1]
y[3][0]
y[3][1]
=
=
=
=
3
9
4
16
10.8 Inicialização de vetores e matrizes sem tamanho
Na inicialização de uma matriz (ou vetor), se não for especificado seu
tamanho, então o compilador Java cria uma matriz (ou vetor) grande o suficiente para
conter todos os inicializadores presentes.
Exemplo:
char [] s = {’p’,’a’,’u’,’l’,’o’};
//
s
ocupa
5
bytes
Programa exemplo (29): O programa permite armazenar n nomes e idades em dois
vetores.
// ---------------------------------------------- Fonte: prog29.java
package prog29;
import java.util.Scanner;
public class Prog29 {
public static void main(String[] args) throws Exception{
Scanner entrada = new Scanner(System.in);
String s;
String [] nome;
int [] idade;
int numElementos;
char ch;
System.out.print("Número de Elementos: ");
s = entrada.nextLine();
numElementos = Integer.parseInt(s);
nome = new String[numElementos];
idade = new int[numElementos];
for (int i = 0;i < numElementos;i++) {
System.out.print("Nome: ");
nome[i] = entrada.nextLine();
System.out.print("Idade: ");
s = entrada.nextLine();
idade[i] = Integer.parseInt(s);
}
for (int i = 0; i < numElementos; i++) {
System.out.printf("| %-41s | %d | \n", nome[i], idade[i]);
}
}
74
}
Resultado do Programa:
Número de Elementos: 3 <enter>
Nome: Paulo Roberto <enter>
Idade: 51 <enter>
Nome: Renato Luis <enter>
Idade: 49 <enter>
Nome: Francisco Carlos <enter>
Idade: 53 <enter>
| Paulo Roberto
| Renato Luis
| Francisco Carlos
| 51 |
| 49 |
| 53 |
Programa exemplo (30): O programa realiza a soma de duas matrizes (A e B)
bidimensionais, gerando uma matriz resultante C.
// ---------------------------------------------- Fonte: Prog30.java
package prog30;
import java.util.Scanner;
public class Prog30 {
public static void main(String[] args) {
final int MAX = 10;
Scanner entrada = new Scanner(System.in);
String s;
int [][] a = new int [MAX][MAX];
int [][] b = new int [MAX][MAX];
int [][] c = new int [MAX][MAX];
int col, lin, j, m, n;
System.out.print("Informe a ORDEM da MATRIZ: (mxn)\n");
do {
System.out.printf("Número de linhas (m): ");
s = entrada.nextLine();
m = Integer.parseInt(s);
} while (m < 1 || m > MAX);
// m de 1 à 10
do {
System.out.print("Número de colunas (n): ");
s = entrada.nextLine();
n = Integer.parseInt(s);
} while (n < 1 || n > MAX);
// n de 1 à 10
for (lin = 1;lin <= m;lin++) {
for (col = 1;col <= n;col++) {
System.out.printf("A[%d,%d] = ",lin,col);
s = entrada.nextLine();
a[lin][col] = Integer.parseInt(s);
System.out.printf("B[%d,%d] = ",lin,col);
s = entrada.nextLine();
b[lin][col] = Integer.parseInt(s);
}
}
System.out.println();
for (lin = 1;lin <= m;lin++) {
for (col = 1;col <= n;col++) {
c[lin][col] = a[lin][col] + b[lin][col];
System.out.printf("C[%d,%d] = %d\n",lin,col,c[lin][col]);
}
}
}
}
75
Resultado do Programa:
Informe a ORDEM da MATRIZ: (mxn)
Número de linhas (m): 2 <enter>
Número de colunas (n): 2 <enter>
A[1,1] = 1 <enter>
B[1,1] = 2 <enter>
A[1,2] = 3 <enter>
B[1,2] = 4 <enter>
A[2,1] = 5 <enter>
B[2,1] = 6 <enter>
A[2,2] = 7 <enter>
B[2,2] = 8 <enter>
C[1,1]
C[1,2]
C[2,1]
C[2,2]
=
=
=
=
3
7
11
15
10.9 Classificação de dados ou ordenação (sort)
Para exemplificar melhor as variáveis do tipo vetor, abaixo são mostrados
dois tipos de ordenação, também chamado sort (classificação de dados):
Programa exemplo (31): O programa classifica os nomes digitados pelo usuário.
// -------------------------------------------- Fonte: Prog31.java
package prog31;
import java.util.Scanner;
public class Prog31 {
public static void main(String[] args) {
String [] nome;
int numElementos;
Scanner entrada = new Scanner(System.in);
String s;
System.out.print("Número de Elementos: ");
s = entrada.nextLine();
numElementos = Integer.parseInt(s);
nome = new String[numElementos];
for (int i = 0;i < numElementos;i++) {
System.out.print("Nome: ");
nome[i] = entrada.nextLine();
}
for (int i = 0; i < numElementos - 1; i++) {
for (int j = i+1; j < numElementos; j++) {
if (nome[i].compareTo(nome[j]) > 0) {
String temp = nome[i];
nome[i] = nome[j];
nome[j] = temp;
}
}
}
System.out.printf("\nNomes ORDENADOS\n");
for (int i = 0; i < numElementos; i++) {
System.out.printf("Nome: %s\n", nome[i]);
}
76
}
}
Resultado do Programa:
Número de Elementos: 5 <enter>
Nome: Eva <enter>
Nome: Beatriz <enter>
Nome: Carla <enter>
Nome: Ana <enter>
Nome: Debora <enter>
Nomes
Nome:
Nome:
Nome:
Nome:
Nome:
ORDENADOS
Ana
Beatriz
Carla
Debora
Eva
Observação: O método compareTo é descrito no próximo capítulo.
Programa exemplo (32): O programa utiliza um método de sort chamado bubble sort
(método da bolha) para classificar nomes.
// ------------------------------------------- Fonte: Prog32.java
package prog32;
import java.util.Scanner;
public class Prog32 {
public static void main(String[] args) {
String [] nome;
int numElementos;
Scanner entrada = new Scanner(System.in);
String s;
boolean sort;
System.out.print("Numero de Elementos: ");
s = entrada.nextLine();
numElementos = Integer.parseInt(s);
nome = new String[numElementos];
for (int i = 0;i < numElementos;i++) {
System.out.print("Nome: ");
nome[i] = entrada.nextLine();
}
int k = numElementos - 1;
do {
sort = false;
for (int i = 0; i < k; i++) {
if (nome[i].compareTo(nome[i+1]) > 0) {
String temp = nome[i];
nome[i] = nome[i+1];
nome[i+1] = temp;
sort = true;
}
}
k--;
} while (sort);
System.out.printf("\nNomes ORDENADOS\n");
for (int i = 0; i < numElementos; i++) {
System.out.printf("Nome: %s\n", nome[i]);
77
}
}
}
Resultado do Programa:
Número de Elementos: 5 <enter>
Nome: Eva <enter>
Nome: Beatriz <enter>
Nome: Carla <enter>
Nome: Ana <enter>
Nome: Debora <enter>
Nomes
Nome:
Nome:
Nome:
Nome:
Nome:
ORDENADOS
Ana
Beatriz
Carla
Debora
Eva
10.10 Lista de exercícios (vetores)
10.10.1 Escreva um programa em Java que recebe via teclado um conjunto de letras
(máximo 20). Armazene todas as letras em um vetor (letras) até que o usuário digite
um F ou f. Logo após copie todas as letras ( em ordem inversa ) para outro vetor
(inverso). Ao final imprima os dois vetores.
Exemplo: Letra: L <enter>
Letra: I
Letra: M
Letra: A
Letra: f
LIMA
AMIL
<enter>
<enter>
<enter>
<enter>
10.10.2 Escreva um programa em Java que recebe via teclado: número de
respectivas idades. Armazene todas as idades em um vetor (idade).
entrada de todas as idades, o programa deve receber via teclado:
consulta. O programa deve imprimir na tela, o número de idades antes
consulta e o número de idades depois da idade de consulta.
idades e as
Logo após a
idade para
da idade de
Exemplo: Número de idades: 6 <enter>
Idade: 30 <enter>
Idade: 60 <enter>
Idade: 10 <enter>
Idade: 50 <enter>
Idade: 20 <enter>
Idade: 40 <enter>
Idade para consulta: 50 <enter>
Antes: 3
Depois: 2
Continua [S/N]? n <enter>
10.10.3 Escreva um programa em Java que recebe via teclado um conjunto de números
inteiros (máximo 50). Armazene todos os números inteiros em um vetor até que o
usuário digite 0 (zero). Logo após permita ao usuário consultar um número informando
o seu valor. O programa deve imprimir na tela a posição do número no vetor ou ERRO:
Número não encontrado (veja exemplos abaixo):
Exemplo: Número: 50 <enter>
Número: 30 <enter>
78
Número: 20 <enter>
Número: 10 <enter>
Número: 40 <enter>
Número: 0 <enter>
Valor: 20 <enter>
Posição no vetor: 2
Valor: 40 <enter>
Posição no vetor: 4
Valor: 60 <enter>
ERRO: Número não encontrado
Valor: 0 <enter>
Observação: O programa termina quando o usuário digitar 0 (zero).
10.10.4 Escreva um programa em Java que recebe via teclado "n" conceitos (A, B, C, D
e E) (máximo 25) até que o usuário digite F ou f. Armazene todos os conceitos em um
vetor (conceito). Imprima na tela o número de alunos: aprovados (A, B e C),
reprovados (D) e os infreqüentes (E).
Exemplo: Conceito: B <enter>
Conceito: A <enter>
Conceito: E <enter>
Conceito: B <enter>
Conceito: D <enter>
Conceito: C <enter>
Conceito: A <enter>
Conceito: E <enter>
Conceito: f <enter>
5 Aprovado(s)
1 Reprovado(s)
2 Infreqüente (s)
10.10.5 Escreva um programa em Java que recebe via teclado “n” (máximo 50) nomes.
A entrada dos nomes termina quando o usuário digitar apenas <enter>. Logo após a
entrada de todos os nomes o programa deve permitir a entrada via teclado de uma
letra. O programa deve imprimir na tela todos os nomes que começam com a letra
especificada pelo usuário. O programa termina quanto o usuário digitar “” (nada)
na entrada da letra (conforme exemplos abaixo):
Exemplo:
Nome: Paulo <enter>
Nome: Roberto <enter>
Nome: Renato <enter>
Nome: Pedro <enter>
Nome: Fabio <enter>
Nome: <enter>
Letra: R <enter>
Nome: Roberto
Nome: Renato
Letra: P <enter>
Nome: Paulo
Nome: Pedro
Letra: T <enter>
Letra: <enter>
10.10.6 Escreva um programa em Java que recebe via teclado “n” (máximo 30) nomes e
idades. A entrada dos dados termina quando o usuário digitar 'N' ou 'n' na pergunta
"Continua [S/N]?". Logo após a entrada de todos os dados o programa deve imprimir na
tela todos os nomes e idades desde o mais velho até o mais novo.
Exemplo:
Nome: Ana <enter>
Idade: 12 <enter>
79
Continua [S/N]? s <enter>
Nome: Beatriz <enter>
Idade: 13 <enter>
Continua [S/N]? s <enter>
Nome: Carla <enter>
Idade: 14 <enter>
Continua [S/N]? N <enter>
Carla
14
Beatriz
13
Ana
12
80
11. Manipulação de Strings
A linguagem Java possui uma classe especifica para manipular strings, ou
seja, cadeia de caracteres.
11.1 Métodos para manipular Strings
Considere que: String s = “Pelotas”;
A seguir são descritos os principais métodos que permitem manipular objetos
do tipo String.
Sintaxe: char charAt(int index);
Retorna o caracter do índice especifiado.
Modo de usar:
String s = “Pelotas”;
ch = s.charAt(0);
Onde: char ch;
// ch = ‘P’;
Sintaxe: int compareTo(Object o);
Compara a String com um Objeto.
Sintaxe: int compareTo(String anotherString);
Compara duas Strings lexicograficamente.
Sintaxe: int compareToIgnoreCase(String str);
Compara duas Strings lexicograficamente, ignorando diferenças entre maíusculas e
minísculas.
Sintaxe: String concat(String str);
Concatena a String especificada no fim desta String.
Sintaxe: boolean contentEquals(StringBuffer sb);
Retorna “true” se e somente se esta String representa a mesma sequência de
caracteres do que a “StringBuffer” especificada.
Sintaxe: static String copyValueOf(char[] data);
Retorna uma String que representa a sequência de caracteres do vetor especificado.
Sintaxe: static String copyValueOf(char[] data, int offset, int count);
Retorna uma String que representa uma sequência de caracteres do vetor especificado.
Sintaxe: boolean endsWith(String suffix);
Testa se esta String termina com o sufixo especificado.
Sintaxe: boolean equals(Object anObject);
Compara esta String com o objeto especificado.
Sintaxe: boolean equalsIgnoreCase(String anotherString);
Compara esta String com outra String, ignorando maiúsculas e minúsculas.
Sintaxe: byte[] getBytes();
81
Codifica esta String em uma sequência de bytes usando o conjunto de caracteres,
armazenando o resultaod em um novo vetor de bytes.
Sintaxe: byte[] getBytes(String charsetName);
Codifica esta String em uma sequência de bytes usando o conjunto de caracteres do
nome, armazenando o resultado dentro do novo vetor.
Sintaxe: void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin);
Cópia esta seqüência de caracteres em um vetor de caracteres destino.
Sintaxe: int hashCode();
Retorna o código hash desta String.
Sintaxe: int indexOf(int ch);
Retorna o índice dentro desta seqüência
especificado ou -1 se não encontrar.
da
primeira
Sintaxe: int indexOf(int ch, int fromIndex);
Retorna o índice dentro desta String da primeira
especificado, iniciando a busca no índice espeficidado.
Sintaxe: int indexOf(String str);
Retorna o índice dentro desta
especificada.
String
da
ocorrência
ocorrência
do
caracter
do
caracter
primeira
ocorrência
da
substring
Sintaxe: int indexOf(String str, int fromIndex);
Retorna o índice dentro desta String da primeira
especificada, iniciando a busca no índice espeficidado.
ocorrência
da
substring
Sintaxe: String intern();
Retorna uma representação canônica da String objeto.
Sintaxe: int lastIndexOf(int ch);
Retorna o índice dentri desta String da última ocurrência do caracter
especificado.
Sintaxe: int lastIndexOf(int ch, int fromIndex);
Retorna o índice dentro desta String da última ocurrência do caracter especificado,
pesquisando para trás começando no índice especificado.
Sintaxe: int lastIndexOf(String str);
Retorna o índice dentro desta seqüência da ocorrência mais à direita da subseqüência
especificada.
Sintaxe: int lastIndexOf(String str, int fromIndex);
Retorna o índice dentro desta String da última ocorrência da substring especificada,
buscando para trás começando o índice especificado.
Sintaxe: int length();
Retorna o comprimento desta String.
Sintaxe: boolean matches(String regex);
Diz se esta seqüência corresponde a expressão regular ou não.
82
Sintaxe: boolean regionMatches(boolean ignoreCase, int toffset, String other, int
ooffset, int len);
Testa se duas regiões das Strings são iguais.
Sintaxe: boolean regionMatches(int toffset, String other, int ooffset, int len);
Testa se duas regiões das Strings são iguais.
Sintaxe: String replace(char oldChar, char newChar);
Retorna uma nova String resultante da troca de todas as ocorrências do “oldChar”
nesta String com “newChar.
Sintaxe: String replaceAll(String regex, String replacement);
Substitui cada subseqüência da seqüência de caracteres que corresponde a expressão
regular com a substituição dadas.
Sintaxe: String replaceFirst(String regex, String replacement);
Substitui as primeiras substrings dessa String que corresponde à expressão regular
com a substituição dadas.
Sintaxe: String[] split(String regex);
Divide essa String em pedaços em torno da expressão regular.
Sintaxe: String[] split(String regex, int limit);
Divide essa String em pedaços em torno da expressão regular.
Sintaxe: boolean startsWith(String prefix);
Testa se esta String começa com o prefixo especificada.
Sintaxe: boolean startsWith(String prefix, int toffset);
Testa se essa String começa com o prefixo especificad
especificado.
começando
no
Sintaxe: CharSequence subSequence(int beginIndex, int endIndex);
Retorna uma nova String de caracteres que é uma subseqüência desta seqüência.
Sintaxe: String substring(int beginIndex);
Retorna uma nova String que é uma substring desta String.
Sintaxe: String substring(int beginIndex, int endIndex);
Retorna uma nova String que é uma substring desta string.
Sintaxe: char[] toCharArray();
Converte esta String em um novo vetor de caracteres.
Sintaxe: String toLowerCase();
Converte todos os caracteres desta String para minúsculos.
Sintaxe: String toString();
Este objeto (que já é uma String) é retornado.
Sintaxe: String toUpperCase();
Converte todos os caracteres desta String para maiúsculos.
Sintaxe: String trim();
83
índice
Retorna uma cópia desta String.
Sintaxe: static String valueOf(boolean b);
Retorna uma representação String do argumento “boolean”.
Sintaxe: static String valueOf(char c);
Retorna uma representação String do argumento “char”.
Sintaxe: static String valueOf(char[] data);
Retorna uma representação String do argumento “char []”.
Sintaxe: static String valueOf(char[] data, int offset, int count);
Retorna uma representação String do argumento “char [[]”.
Sintaxe: static String valueOf(double d);
Retorna uma representação String do argumento “double”.
Sintaxe: static String valueOf(float f);
Retorna uma representação String do argumento “float”.
Sintaxe: static String valueOf(int i);
Retorna uma representação String do argumento “int”.
Sintaxe: static String valueOf(long l);
Retorna uma representação String do argumento “long”.
Sintaxe: static String valueOf(Object obj);
Retorna uma representação String do argumento “Object”.
Exemplos:
a) Exemplo do uso de toUpperCase e toLowerCase:
// ----------------------------------------------------- Fonte: ToUpperCase.java
package touppercase;
public class ToUpperCase {
public static void main(String[] args) {
String s = "Paulo Roberto Gomes Luzzardi";
System.out.println("Nome: " + s);
System.out.println("Nome: " + s.toUpperCase());
System.out.println("Nome: " + s.toLowerCase());
}
}
Resultado do Programa:
Nome: Paulo Roberto Gomes Luzzardi
Nome: PAULO ROBERTO GOMES LUZZARDI
Nome: paulo roberto gomes luzzardi
b) Exemplo do uso de length, charAt e indexOf:
// ------------------------------------------------------ Fonte: Inverte.java
package inverte;
84
import java.util.Scanner;
public class Inverte {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String s;
int n;
char op;
do {
System.out.print("Nome: ");
s = input.nextLine();
System.out.print("Invertido: ");
n = s.length();
// número de caracteres da String s
for (int i = n-1;i >= 0;i--) {
System.out.print(s.charAt(i));
// acesso a cada caracter de s
}
System.out.println();
do {
System.out.print("Continua [S/N]? ");
s = input.nextLine();
op = s.charAt(0);
} while ("SsNn".indexOf(op) == -1);
// verifica se op é “SsNn”
} while ("Ss".indexOf(op) != -1); // } while ("S".equalsIgnoreCase(s));
}
}
Resultado do Programa:
Nome: pelotas <enter>
Invertido: satolep
Continua [S/N]? S <enter>
Nome: satolep <enter>
Invertido: pelotas
Continua [S/N]? N
c) Exemplo do uso de String.format:
// -------------------------------------------- Fonte: StringFormat.java
package stringformat;
public class StringFormat {
public static void main(String[] args) {
float numero = 123.456789f;
String formato = String.format("%.3f", numero);
//JOptionPane.showMessageDialog(null, "numero: " + formato);
System.out.printf("Número: %.4f\n", numero);
System.out.println("Número Formatado: " + formato);
}
}
Resultado do Programa:
Número: 123,4568
Número Formatado: 123,457
11.2 Lista de exercícios (Strings)
85
11.2.1 Escreva um programa em Java que recebe via teclado um nome. Logo após a
entrada do nome imprima: número de letras maiúsculas, número de letras minúsculas,
número de vogais e o número de consoantes, conforme exemplo abaixo:
Exemplo:
Nome: Faculdade de Tecnologia Senac <enter>
(3) maiúscula(s)
(23) minúscula(s)
(12) vogais(s)
(14) consoante(s)
11.2.2 Escreva um programa em Java que recebe via teclado uma palavra e uma letra.
Logo após a entrada do nome e da letra imprima o número de letras que existe no
nome ou ERRO: Não existe a letra (?) na palavra (?), conforme exemplo abaixo:
Exemplo:
Palavra: Luzzardi <enter>
Letra: z <enter>
2 letra(s)
Continua [S]im ou [N]ão? S <enter>
Palavra: Luzzardi <enter>
Letra: w <enter>
ERRO: Não existe a letra (w) na palavra (Luzzardi)
Continua [S]im ou [N]ão? N <enter>
Observação: O programa deve ser encerrado quando o usuário digitar “N” ou “n” na pergunta: Continua
[S]im ou [N]ão?.
11.2.3 Escreva um programa em Java que recebe via teclado uma palavra
e uma
posição. O programa deve imprimir na tela, a letra antecessora, a letra (da referida
posição) e a letra sucessora, conforme exemplo abaixo:
Exemplo: Palavra: Universidade <enter>
Posição: 7 <enter>
Antecessora: s
Letra: i
Sucessora: d
Observação: O programa deve imprimir na tela as seguintes mensagens de erro, se for o caso: Letra
antecessora não existe, Letra sucessora não existe ou Posição inválida.
11.2.4 Escreva um programa em Java que recebe via teclado um nome. O programa deve
imprimir, na tela, as palavras do nome em ordem inversa, uma por linha, conforme
exemplo abaixo:
Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter>
Luzzardi
Gomes
Roberto
Paulo
11.2.5 Escreva um programa em Java que recebe via teclado um nome. Logo após a
entrada do nome o programa deve imprimir (EM LETRA MAIÚSCULA) o sobrenome da
pessoa, conforme exemplos abaixo:
Exemplo:
Nome: Paulo Roberto Gomes Luzzardi <enter>
Sobrenome: LUZZARDI
Sair [S/N]? N <enter>
Nome: Renato Souza <enter>
Sobrenome: SOUZA
Sair [S/N]? s <enter>
86
Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?
11.2.6 Escreva um programa em Java que recebe via teclado um nome. Logo após a
entrada do nome o programa deve imprimir na tela: sobrenome, primeiro nome e demais
nomes abreviados, conforme exemplos abaixo:
Exemplo:
Nome: Paulo Roberto Gomes Luzzardi <enter>
Autor: Luzzardi, Paulo R. G.
Sair [S/N]? N <enter>
Nome: Renato Lima Souza <enter>
Autor: Souza, Renato L.
Sair [S/N]? s <enter>
Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?
11.2.7 Escreva um programa em Java que recebe via teclado o nome de um estado. Logo
após a entrada do nome do estado imprima: a sigla do estado (2 letras maiúsculas),
conforme exemplos abaixo:
Exemplo:
Estado: Rio Grande do Sul <enter>
Sigla: RS
Estado: são paulo <enter>
Sigla: SP
Estado: rio de janeiro <enter>
Sigla: RJ
Estado: <enter>
Observação: O programa encerra quando o usuário digitar apenas <enter> na entrada do nome do estado.
11.2.8 Escreva um programa em Java que recebe via teclado uma palavra, início e
fim. Logo após a entrada de todos os dados imprima a string resultante ou ERRO: Fim
inválido ou Início inválido, conforme exemplos abaixo:
Exemplo:
Palavra: universidade <enter>
Início: 7 <enter>
Fim: 11 <enter>
String resultante: idade
Continua [S/N]? s <enter>
Palavra: eletricidade <enter>
Início: 7 <enter>
Fim: 15 <enter>
ERRO: Fim Inválido
Continua [S/N]? N <enter>
Observação: O programa termina quando o usuário digitar ‘N’ ou ‘n’ na pergunta: Continua [S/N]?.
87
12. Métodos estáticos definidos pelo programador
A linguagem de programação Java permite que o programador crie e utilize seus
próprios métodos estáticos.
Forma Geral:
static tipo_do_retorno nome_do_método (tipo_dado_base parâmetros ou argumentos) {
tipo_dado_base variáveis;
corpo do método;
return(x);
}
tipo_do_retorno: Especifica o tipo de dado que será retornado pelo método. O retorno
do método é feito pelo comando return (valor).
Parâmetros ou argumentos: É uma lista, separada por vírgulas, com os nomes das
variáveis (e seus tipos) que receberão os argumentos quando o método for chamado ou
executado.
Método procedural: É um tipo especial de método que não possui retorno, ou seja, é
simplesmente um procedimento. Um método deste tipo é void.
Exemplo: Programa que gera 10 números aleatórios, usando um método estático escrito
pelo programador.
// ----------------------------------------------- Fonte: rand.java
package rand;
public class Rand {
public static void main(String[] args) {
for (int i = 1;i <= 10;i++) {
System.out.println("Valor: " + random(10));
}
}
// ----------------------------------------------- random
static int random (int n) {
int t;
t = (int) (Math.random() * n);
return(t);
}
}
Resultado do Programa:
0.5051108207316423
Valor: 5
0.32587482295637693
Valor: 3
0.5022622828080121
Valor: 5
0.12280582088438263
Valor: 1
88
0.6698515942322978
Valor: 6
0.23904184275698248
Valor: 2
0.8321167764574124
Valor: 8
0.7770564673470854
Valor: 7
0.1130461920867929
Valor: 1
0.29725902364100654
Valor: 2
Chamada do método: n = random(10); // retorna um número aleatório entre 0 e 9
Programa exemplo (33): O programa possui um método estático que calcula o inverso
1/x.
// ---------------------------------------------- Fonte: Prog33.java
package prog33;
import java.util.Scanner;
public class Prog33 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
double inv, x;
System.out.print("x = ");
s = entrada.nextLine();
x = Double.parseDouble(s);
inv = inverso (x);
// chamada do método inverso
System.out.printf("Inverso = %.2f\n", inv);
}
// ----------------------------- Método definido pelo programador
static double inverso (double x) {
double i;
i = (double) 1 / x;
return(i);
}
}
Resultado do Programa:
x = 4 <enter>
Inverso = 0,25
89
12.1 Valores de retorno
Todas os métodos, exceto aqueles que são declaradas como sendo do tipo void,
devolvem um valor. O valor é devolvido (retornado) pelo método através do comando
return.
Normalmente são escritas três tipos de métodos:
a) Métodos que efetuam operações com os parâmetros e retornam um valor com base nas
operações.
Programa exemplo (34): O programa calcula e imprime na tela o valor da potência x y
através de um método estático chamado: potencia.
// --------------------------------------------- Fonte: Prog34.java
package prog34;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
double base,resp;
int expoente;
System.out.print("Base: ");
s = entrada.nextLine();
base = Double.parseDouble(s);
System.out.print("Expoente: ");
s = entrada.nextLine();
expoente = Integer.parseInt(s);
// chamada do método potencia
resp = potencia(base, expoente);
System.out.printf("Potencia = %7.2f\n",resp);
}
// ----------------------------- Método definido pelo programador
static double potencia (double x, int y) {
double valor;
valor = Math.exp ( Math.log (x ) * y );
return(valor);
}
}
Resultado do Programa:
Base: 3 <enter>
Expoente: 4 <enter>
Potencia = 81,00
b) Métodos que manipulam informações e retornam um valor que simplesmente indica o
sucesso ou o fracasso da manipulação.
Programa exemplo (35): O programa calcula e verifica o determinante de uma equação
de segundo grau através de um método estático chamado: verificaDeterminante.
90
// ------------------------------------------ Fonte: Prog35.java
package prog35;
import java.util.Scanner;
public class Prog35 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
float a, b, c;
int retorno;
System.out.print("a = ");
s = entrada.nextLine();
a = Float.parseFloat(s);
System.out.print("b = ");
s = entrada.nextLine();
b = Float.parseFloat(s);
System.out.print("c = ");
s = entrada.nextLine();
c = Float.parseFloat(s);
retorno = verificaDeterminante(a, b, c);
if (retorno == 0) {
System.out.println("Determinante ZERO");
} else {
if (retorno > 0) {
System.out.println("Determinante POSITIVO");
} else {
System.out.println("Determinante NEGATIVO");
}
}
}
// ---------------------------- metodo definido pelo programador
static int verificaDeterminante(float a, float b, float c) {
float det;
det = b * b - 4 * a * c;
if (det == 0) {
return (0);
} else {
if (det > 0) {
return (1);
} else {
return (-1);
}
}
}
}
Resultado do Programa:
a = 1 <enter>
b = 2 <enter>
c = 3 <enter>
Determinante NEGATIVO
c) Métodos que não retornam nenhum valor, ou seja, são puramente procedimentos.
Programa exemplo (36): O programa possui um método estático imprime um número (int
ou float) através do método chamado: imprimeNumero.
// -------------------------------------- Fonte: Prog36.java
91
package prog36;
import java.util.Scanner;
public class Prog36 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int x;
float y;
System.out.print("Digite um Numero: ");
s = entrada.nextLine();
x = Integer.parseInt(s);
imprimeNumero(x);
System.out.print("Digite outro Numero: ");
s = entrada.nextLine();
y = Float.parseFloat(s);
imprimeNumero(y);
}
// ----------------------------- ImprimeNumero
static void imprimeNumero(int n) {
System.out.println("Numero digitado foi " + n);
}
// ----------------------------- ImprimeNumero
static void imprimeNumero(float n) {
System.out.println("Numero digitado foi " + n);
}
}
Resultado do Programa:
Digite
Número
Digite
Número
um número: 3 <enter>
digitado foi 3
outro número: 4 <enter>
digitado foi 4.0
Observação: Note que o método imprimeNumero foi sobrecarregado, ou seja, ele
funciona quando o argumento é int ou float.
12.2 Passagem de parâmetros por valor
Forma de chamada de um método, onde o valor do argumento é apenas copiado
para o parâmetro formal do método. Portanto, alterações feitas nos parâmetros não
terão efeito nas variáveis utilizadas para chamá-la.
Programa exemplo (37): O programa possui um método que desenha um retângulo na
tela.
// ------------------------------------------- Fonte: Prog37.java
package prog37;
public class Prog37 {
public static void main(String[] args) {
desenhaRetangulo(1, 1, 9, 9);
92
}
// ------------------------ desenhaRetangulo
static void desenhaRetangulo(int ci, int li, int cf, int lf) {
int c, l;
System.out.print(" ");
for (c = ci; c <= cf; c++) {
System.out.print(c);
}
System.out.println();
for (l = li; l <= lf; l++) {
System.out.print(l + ":");
for (c = ci; c <= cf; c++) {
System.out.print("#");
}
System.out.println();
}
}
}
Onde: ci -> coluna inicial
li -> linha inicial
cf -> coluna final
lf -> linha final
Atenção: Os argumentos do método recebem, respectivamente: ci=1, li=1, cf=20 e
lf=10.
Resultado do Programa:
123456789
1:#########
2:#########
3:#########
4:#########
5:#########
6:#########
7:#########
8:#########
9:#########
12.3 Passagem de parâmetros por referência
A passagem de parâmetros ou argumentos por referência em Java acontece
somente com qualquer tipo de dado do tipo vetor ou matriz, ou seja, não é possível
fazer passagem de argumento por referência com variáveis do tipo: char, byte, int,
short, long, float ou double.
Programa exemplo (38): O programa tem um método que troca o valor de duas
variáveis.
// ------------------------------------------------- Fonte: Prog38.java
package prog38;
public class Prog38 {
public static void main(String[] args) {
int [] x = {3, 4};
93
// foi impresso na tela Vetor: 3 | 4
System.out.printf("Vetor: %d - %d\n", x[0], x[1]);
troca(x);
// foi impresso na tela Vetor: 4 | 3
System.out.printf("Vetor: %d - %d\n", x[0], x[1]);
}
// ------------------------------------- troca
static void troca (int [] x) {
int temp = x[0];
x[0] = x[1];
x[1] = temp;
}
}
Resultado do Programa:
Vetor: 3 - 4 - 5
Vetor: 4 - 5 – 3
12.4 Métodos que devolvem valores não-inteiros
Todas os métodos que devolvem valores não-inteiros devem ter seu tipo de
retorno declarado.
tipo_do_retorno nome_do_metodo (tipo_dado_base parâmetros);
Programa exemplo (39): O programa calcula e imprime na tela a divisão de dois
valores usando um método estático chamado divisão.
// ------------------------------------------ Fonte: prog39.java
package prog39;
import java.util.Scanner;
public class Prog39 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int x, y;
float resposta;
System.out.printf("x = ");
s = entrada.nextLine();
x = Integer.parseInt(s);
System.out.printf("y = ");
s = entrada.nextLine();
y = Integer.parseInt(s);
resposta = divisao( x, y);
System.out.printf("Divisão = %7.2f\n",resposta);
}
// ----------------------------- método definido pelo programador
static float divisao (int x, int y) {
return( (float) x / y );
}
94
}
Resultado do Programa:
Vetor: 3 - 4 - 5
Vetor: 4 - 5 - 3
12.5 Argumentos do main (String [] args)
O método estático main possui um argumento args intrínsecos utilizados para
receber parâmetros da linha de comando do Sistema Operacional.
args – Vetor de Strings
Programa exemplo (40): O programa recebe parâmetros do Sistema Operacional (uma
palavra qualquer) e imprime a palavra em sentido inverso. O programa deve ser
executado via terminal do Sistema Operacional da seguinte forma:
Execução pela linha de comandos (terminal):
$ java Prog40 pelotas <enter>
Resultado na tela: satolep
Programa recebe:
argv[0] = “pelotas”
// --------------------------------------- Fonte: Prog40.java
package prog40;
public class Prog40 {
public static void main(String[] args) {
int n, argc = args.length;
if (argc != 1) {
System.out.printf("Sintaxe: Prog40 <palavra>\n");
}
else {
System.out.print("Palavra: ");
n = args[0].length();
for (int i = n-1; i >= 0; i--) {
System.out.printf("%c", args[0].charAt(i));
}
System.out.println();
}
}
}
Resultado do Programa:
MacBook-Air-de-Paulo:prog40 pluzzardi$ java Prog40 pelotas <enter>
Palavra: satolep
MacBook-Air-de-Paulo:prog40 pluzzardi$
95
Programa exemplo (41): O programa deve receber parâmetros pelo Sistema Operacional
(conjunto de caracteres) e deve ordenar (coloca em ordem alfabética), imprimindo-os
a seguir.
Execução pela linha de comandos: $ java Prog41 dbeacgf <enter>
Resultado na tela: abcdefg
Programa recebe:
agv[0] = “dbeacgf”
// ------------------------------------- Fonte: Prog41.java
package prog41;
public class Prog41 {
public static void main(String[] args) {
int argc = args.length;
int numCar;
if (argc != 1) {
System.out.printf("Sintaxe: Prog41 <palavra> \n");
}
else {
numCar = args[0].length();
char [] ch = new char[numCar];
for (int i = 0;i < numCar;i++) {
ch[i] = args[0].charAt(i);
}
for (int i = 0; i < numCar-1; i++) {
for (int j = i+1; j < numCar; j++) {
if (ch[i] > ch[j]) {
char temp = ch[i];
ch[i] = ch[j];
ch[j] = temp;
}
}
}
for (int i = 0;i < numCar;i++) {
System.out.printf("%c", ch[i]);
}
System.out.printf("\n");
}
}
}
Resultado do Programa:
MacBook-Air-de-Paulo:prog41 pluzzardi$ java Prog41 dbeacgf <enter>
abcdefg
MacBook-Air-de-Paulo:prog41 pluzzardi$
12.6 Recursividade
Um método é recursivo se este fizer uma chamada a si própria.
Programa exemplo (42): O programa calcula o fatorial de um número recursivamente.
96
// ------------------------------------------ Fonte: Prog42.java
package prog42;
import java.util.Scanner;
public class Prog42 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int n;
long fat;
do {
do {
System.out.printf("n = ");
s = entrada.nextLine();
n = Integer.parseInt(s);
} while (n < 0 || n > 19);
fat = fatorial(n);
System.out.printf("Fatorial: %d\n", fat);
} while (n != 0);
}
// ----------------------------------------- fatorial
static long fatorial(int num) {
if (num == 0) {
return 1;
}
return(num * fatorial(num - 1));
}
// recursividade
}
Resultado do Programa:
n = 5 <enter>
Fatorial: 120
n = 10 <enter>
Fatorial: 3628800
n = 15 <enter>
Fatorial: 1307674368000
n = 16 <enter>
Fatorial: 20922789888000
n = 17 <enter>
Fatorial: 355687428096000
n = 18 <enter>
Fatorial: 6402373705728000
n = 19 <enter>
Fatorial: 121645100408832000
n = 20 <enter>
n = 0 <enter>
Fatorial: 1
Programa exemplo (43): O programa calcula a soma de um número recursivamente.
// ------------------------------------------- Fonte: Prog43.java
package prog43;
import java.util.Scanner;
public class Prog43 {
97
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int n;
long sum;
do {
do {
System.out.printf("n = ");
s = entrada.nextLine();
n = Integer.parseInt(s);
} while (n < 0 || n > 19);
if (n > 0) {
sum = soma(n);
System.out.printf("Soma: %d\n", sum);
}
} while (n != 0);
}
// ----------------------- soma
static long soma(int n) {
long s;
if (n == 1) {
return(1);
}
s = n + soma(n-1);
return(s);
// recursividade
}
}
Resultado do Programa:
n = 1
Soma:
n = 2
Soma:
n = 3
Soma:
n = 4
Soma:
n = 0
<enter>
1
<enter>
3
<enter>
6
<enter>
10
<enter>
12.7 Lista de Exercícios (métodos)
12.7.1 Escreva em Java o método númeroPalavras. O método recebe uma String (nome) e
retorna o número de palavras do nome (veja exemplo abaixo):
// ------------------------------------------------------ Fonte: teste.java
package teste;
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String nome;
int n;
System.out.print("Nome: ");
98
nome = entrada.nextLine();
n = numeroPalavras(nome);
System.out.printf("Seu nome tem %d palavra(s)\n", n);
}
// ---------------------------- numeroPalavras
}
Exemplo:
Nome: Paulo Roberto Gomes Luzzardi <enter>
Seu nome tem 4 palavra(s)
12.7.2 Escreva em Java o método verificaQuadrante. O método recebe um valor para x
e um valor para y e retorna o número do quadrante (1, 2, 3 ou 4).
// --------------------------------------------------------- Fonte: teste.java
package teste;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int x, y, n;
System.out.print("x: ");
s = entrada.nextLine();
x = Integer.parseInt(s);
System.out.print("y: ");
s = entrada.nextLine();
y = Integer.parseInt(s);
n = verificaQuadrante(x, y);
System.out.printf("Quadrante: %d\n", n);
}
// ---------------------------- verificaQuadrante
}
Exemplo:
x: 1 <enter>
y: 2 <enter>
Quadrante: 1
|
2
|
________________________
|
3
|
4
1
12.7.3 Escreva o método: final_da_placa. O método recebe uma placa de automóvel no
formato: xxx9999 e retorna o último dígito da placa.
// ------------------------------------------------------------ Fonte: teste.java
package teste;
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String placa;
99
char fim;
System.out.print("Qual a placa de seu carro [xxx9999]: ");
placa = entrada.nextLine();
fim = finalPlaca(placa);
System.out.printf("Final da Placa é: %c\n", fim);
}
// ---------------------------- finalPlaca
}
Exemplo:
Qual a Placa de seu carro [xxx9999]: IDJ7345 <enter>
Final da Placa é: 5
12.7.4 Escreva o método numVogais. O método recebe uma String (nome) e retorna a
quantidade de vogais da String.
// ------------------------------------------------------------ Fonte: teste.java
package teste;
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String nome;
int vogais;
System.out.print("Nome: ");
nome = entrada.nextLine();
vogais = numVogais(nome);
System.out.printf("Vogais: %d\n", vogais);
}
// -------------------------- numVogais
}
Exemplo:
Nome: Paulo <enter>
Vogais: 3
12.7.5 Escreva o método calculaHipotenusa. O método recebe o cateto adjacente (b) e
o cateto oposto (a) e retorna o valor da hipotenusa dado pela seguinte fórmula:
Fórmula:
h2
= a2 + b2
// ------------------------------------------------------------ Fonte: teste.java
package teste;
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
100
String s;
float a, b, h;
System.out.print("Cateto Adjacente: ");
s = entrada.nextLine();
a = Float.parseFloat(s);
System.out.print("Cateto Oposto: ");
s = entrada.nextLine();
b = Float.parseFloat(s);
h = calculaHipotenusa(a, b);
System.out.printf("Hipotenusa: %f\n", h);
}
// ---------------------------- calculaHipotenusa
}
Exemplo:
Cateto Adjacente: 3 <enter>
Cateto Oposto: 3 <enter>
Hipotenusa: 4.242640
12.7.6 Escreva em Java o método calculaReajuste. O método recebe o valor do salário
e o índice de reajuste e retorna o salário atualizado.
// ------------------------------------------------------------ Fonte: teste.java
package teste;
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
float salario, indice, reajuste;
System.out.print("Salário (R$): ");
s = entrada.nextLine();
salario = Float.parseFloat(s);
System.out.print("Índice de Reajuste: ");
s = entrada.nextLine();
indice = Float.parseFloat(s);
reajuste = calculaReajuste(salario, indice);
System.out.printf("Salário Atualizado (R$): %.2f\n", reajuste);
}
// ---------------------------- calculaReajuste
}
Exemplo:
Salário (R$): 1000 <enter>
Índice de Reajuste: 10 <enter>
Salário Atualizado (R$): 1100
101
13. Classes (Interface ou Coleção) existentes em Java (Container)
Java possui diversas classes pré-existentes chamadas container. Um container
ou coleção é simplesmente um objeto que agrupa múltiplos elementos em uma única
unidade. As coleções são utilizadas para armazenar, recuperar e manipular dados
agregados.
A seguir pode-se ver algumas classes, coleções ou implementações existentes
em Java:
Tabela 13: Lista de Container
Container
Descrição
Array
DList
SList
HashMap
OrderedMap
HashSet
OrderedSet
PriorityQueue
Queue
Stack
Deque
Array expansível
Lista Duplamente Encadeada
Lista Encadeada Simples
fast associative container
associative container
fast set or multiset
set or multiset
array-based heap
Fila (Interface)
Pilha
Fila Dupla (duas entradas e duas saídas)
Collection FrameWork (Coleções)
Pacote: import java.util.*;
Uma coleção é um objeto que representa um grupo de objetos. Um “Collection
Framework” é uma arquitetura para representar e manipular coleções independente dos
detalhes de sua
Implementações.
implementação.
Uma
coleção
é
composta
Interfaces
Figura 3: Arquitetura das Interfaces
Implementações
102
de
Interfaces
e
Sets(Conjuntos): HashSet, LinkedHashSet, TreeSet, EnumSet
Lists (Listas): Vector, Stack, LinkedSet, ArrayList
Queue (Filas): PriorityQueue
Maps: HashTable, HashMap, LinkedHashMap, WeakHashMap, IdentityHashMap, TreeMap
A seguir são descritos alguns destes elementos:
Vector (Vetor)
import java.util.Vector;
A classe Vector é utilizada em uma estrutura de dados armazenada em um vetor,
ou seja, uma lista de elementos.
A seguir são descritos os principais métodos da classe Vector.
Sintaxe: void add(int index, Object element);
Insere um elemento especificado na posição especificada no Vetor.
Sintaxe: boolean add(Object o);
Anexa o elemento especificado no fim do Vetor.
Sintaxe: boolean addAll(Collection c);
Anexa todos os elementos da coleção especificada no final do Vetor, na ordem que
eles são retornados pelo iterador da coleção especificada.
Sintaxe: boolean addAll(int index, Collection c);
Insere todos os elementos na coleção especificada no Vetor na posição especificada.
Sintaxe: void addElement(Object obj);
Adiciona o componente especificado no fim do Vetor, aumentando se tamanho em um.
Sintaxe: int capacity();
Retorna a corrente capacidade do Vetor.
Sintaxe: void clear();
Remove todos os elementos do Vetor.
Sintaxe: Object clone();
Retorna um clone do Vetor.
Sintaxe: boolean contains(Object elem);
Testa se um objeto específico é um componente do Vetor.
Sintaxe: boolean containsAll(Collection c);
Retorna true se o Vetor contém todos os elementos da coleção específica.
Sintaxe: void copyInto(Object[] anArray);
Copia os componentes do Vetor para o Array especificado.
Sintaxe: Object elementAt(int index);
103
Retorna o componente especificado pelo “index”.
Sintaxe: Enumeration elements();
Retorna uma enumeração dos componentes do Vetor.
Sintaxe: void ensureCapacity(int minCapacity);
Aumenta a capacidade do Vetor, se necessário, estando certo que de poder armazenar o
número de componentes especificados pelo argumento “mincapacity.
Sintaxe: boolean equals(Object o);
Compara o objeto especificado com o Vetor pela igualdade.
Sintaxe: Object firstElement();
Retorna o primeiro componente (o item de “index” 0) do Vetor.
Sintaxe: Object get(int index);
Retorna o elemento da posição especificada do Vetor.
Sintaxe: int hashCode();
Retorna o valor do código “hash” do Vetor.
Sintaxe: int indexOf(Object elem);
Procura a primeira ocorrência de um dado argumento, testando a igualdade pelo método
“equals.
“
Sintaxe: int indexOf(Object elem, int index);
Procura pela primeira ocorrência de um dado argumento, começando a busca pelo
“index”, e testando pela igualdade usando o métod “equals.
“
Sintaxe: void insertElementAt(Object obj, int index);
Insere o objeto especificado como um componente no Vetor no “index” especificado.
Sintaxe: boolean isEmpty();
Testa se o Vetor não tem componentes.
Sintaxe: Object lastElement();
Retorna o último componente do Vetor.
Sintaxe: int lastIndexOf(Object elem);
Retorna o “index” da última ocorrência do objeto especificado no Vetor.
Sintaxe: int lastIndexOf(Object elem, int index);
Procura para trás por um objeto especificado, começando no “index” especificado e
retorna um “index” para ele.
Sintaxe: Object remove(int index);
Remove o elemento da posição especificada no Vetor.
Sintaxe: boolean remove(Object o);
Remove a primeira ocorrência do elemento especificado no Vetor, se o Vetor não
contém o elemento, ele não é alterado.
Sintaxe: boolean removeAll(Collection c);
Remove do Vetor todos os elementos que contém a coleção especificada.
104
Sintaxe: void removeAllElements();
Remove todos os componentes do Vetor e seta o tamanho em zero.
Sintaxe: boolean removeElement(Object obj);
Remove a primeira (menor indexado) ocorrência do argumento do Vetor.
Sintaxe: void removeElementAt(int index);
Deleta o componente com “index” especificado.
Sintaxe:protected void removeRange(int fromIndex, int toIndex);
Remove da lista todos os elementos escolhidos entre o “fromIndex” (inclusive) e
“toIndex” (exclusive).
Sintaxe: boolean retainAll(Collection c);
Mantém somente os elementos do Vetor que contém a coleção especificada.
Sintaxe: Object set(int index, Object element);
Troca o elemento da posição especificada do Vetor com o elemento especificado.
Sintaxe: void setElementAt(Object obj, int index);
Seta o componente com “index” especificado do Vetor para o objeto especificado.
Sintaxe: void setSize(int newSize);
Seta o tamanho do Vetor.
Sintaxe: int size();
Retorna o número de componentes do Vetor.
Sintaxe: List subList(int fromIndex, int toIndex);
Retorna uma visão da porção da Lista entre “fromIndex” (inclusive) e “toIndex”
(exclusive).
Sintaxe: Object[] toArray();
Retorna um array contendo todos os elementos no Vetor na ordem correta.
Sintaxe: Object[] toArray(Object[] a);
Retorna um array contendo todos os elementos no Vetor ordem correta; o tipo
“runtime” do array especificado é retornado.
Sintaxe: String toString();
Retorna uma string do Vetor, contendo uma representação de cada elemento.
Sintaxe: void trimToSize();
Ajusta a capacidade do Vetor para a atual dimensão do Vetor.
Programa Exemplo (3): Exemplo de um vetor usando a classe “Vector”.
// ------------------------------------------- Fonte: Prog3.java
package Prog3;
import java.util.Vector;
import javax.swing.JOptionPane;
public class Prog3 {
105
public static void main(String[] args) {
Vector vetor = new Vector();
String s, extenso = "";
int u = -1, nodo;
do {
u++;
s = JOptionPane.showInputDialog("Nodo: ");
nodo = Integer.parseInt(s);
if (nodo != 0) {
vetor.add(nodo);
// vetor.add(u, nodo);
}
} while (nodo != 0);
extenso = vetor.toString();
int n = vetor.size();
/* ------------------------------------------------- outra forma
for (int i = 0; i < n;i++)
extenso = extenso + vetor.get(i) + " ";
---------------------------------------------------------------*/
JOptionPane.showMessageDialog(null, "Elementos: " + n +
"\nVetor: " + extenso, "Vector",
JOptionPane.PLAIN_MESSAGE);
}
}
Resultado do Programa:
10
20
30
40
50
Vetor: [10, 20, 30, 40, 50]
Programa Exemplo (3a): Exemplo de um vetor usando a classe “Vector”, inserindo em
uma determinada posição.
// --------------------------------------------- Fonte: Prog3a.java
package prog3a;
import java.util.Vector;
import javax.swing.*;
public class Prog3a {
public static void main(String[] args) {
Vector vetor = new Vector();
String s, extenso = "";
int nodo, pos;
do {
s = JOptionPane.showInputDialog("Nodo: ");
nodo = Integer.parseInt(s);
if (nodo != 0) {
s = JOptionPane.showInputDialog("Posicao: ");
pos = Integer.parseInt(s);
if (pos >= 0 && pos <= vetor.size()) {
vetor.add(pos, nodo);
}
else {
JOptionPane.showMessageDialog(null, "ERRO: Posição Inválida ",
106
"Vector", JOptionPane.PLAIN_MESSAGE);
}
}
exibeVector(vetor);
} while (nodo != 0);
int n = vetor.size();
for (int i = 0; i < n;i++)
extenso = extenso + vetor.get(i) + " ";
JOptionPane.showMessageDialog(null, "Elementos: " + n +
"\nVetor: " + extenso, "Vector", JOptionPane.PLAIN_MESSAGE);
}
static void exibeVector(Vector vetor) {
System.out.printf("Indice: ");
for (int i = 0;i < vetor.size();i++) {
System.out.printf("%2d ", i);
}
System.out.println();
System.out.print(" Vetor: ");
for (int i = 0;i < vetor.size();i++) {
System.out.printf("%2d ", vetor.get(i));
}
System.out.println();
}
}
Resultado do Programa:
Nodo: 10 <enter>
Posição: 0 <enter>
Indice: 0
Vetor: 10
Nodo: 20 <enter>
Posição: 1 <enter>
Indice: 0 1
Vetor: 10 20
Nodo: 30 <enter>
Posição: 2 <enter>
Indice: 0 1 2
Vetor: 10 20 30
Nodo: 40 <enter>
Posição: 6 <enter>
ERRO: Posição Inválida
Indice: 0 1 2
Vetor: 10 20 30
Nodo: 0 <enter>
Indice: 0 1 2
Vetor: 10 20 30
Elemento: 10
Elemento: 20
Elemento: 30
Número de Elementos: 3
Vetor: 10 20 30
Programa Exemplo (3b): Exemplo de um vetor usando a classe “Vector” e a classe
“ArrayList”, inserindo inteiros e caractere (uso do toArray).
// -------------------------------------------- Fonte: toArray.java
package toarray;
import java.util.*;
public class toArray {
107
public static void main(String[] args) {
ArrayList lista = new ArrayList();
lista.add(10);
lista.add(30);
lista.add(40);
lista.add(1, 20);
System.out.println("ArrayList: " + lista);
Object [] objeto = lista.toArray();
System.out.print("Objetos: ");
for(int i = 0;i < lista.size();i++) {
System.out.print(objeto[i] + " ");
}
System.out.println();
Vector vetor = new Vector();
vetor.add('A');
vetor.add('C');
vetor.add('D');
vetor.add(1, 'B');
System.out.println("Vector: " + vetor);
Object [] objet = vetor.toArray();
System.out.print("Objetos: ");
for(int i = 0;i < vetor.size();i++) {
System.out.print(objet[i] + " ");
}
System.out.println();
}
}
Resultado do Programa:
ArrayList: [10, 20, 30, 40]
Objetos: 10 20 30 40
Vector: [A, B, C, D]
Objetos: A B C D
Stack (Pilha)
import java.util.Stack;
A classe Stack é utilizada para armazenar elementos em uma Pilha.
A seguir são descritos os principais métodos da classe Stack.
Sintaxe: boolean empty();
Testa se a pilha está vazia.
Sintaxe: Object peek();
Verifica o objeto que está no topo da pilha sem removê-lo da pilha.
Sintaxe: Object pop();
Remove o objeto do topo da pilha e returna o valor do objeto.
Sintaxe: Object push(Object item);
108
Insere um item no topo da pilha.
Sintaxe: int search(Object o);
Retorna a posição baseado na posição de onde o objeto se encontra da pilha.
Programa Exemplo (4): Exemplo de uma pilha usando a classe “Stack”.
// --------------------------------------------- Fonte: Prog4.java
package Prog4;
import java.util.Stack;
import javax.swing.*;
public class Prog4 {
public static void main(String[] args) {
Stack pilha = new Stack();
String s, extenso = "";
int nodo;
do {
s = JOptionPane.showInputDialog("Nodo: ");
nodo = Integer.parseInt(s);
if (nodo != 0) {
pilha.push(nodo);
}
} while (nodo != 0);
do {
extenso = extenso + pilha.pop() + " ";
} while (!pilha.empty());
JOptionPane.showMessageDialog(null, "Pilha: " + extenso,
"Stack", JOptionPane.PLAIN_MESSAGE);
}
}
LinkedList (Lista Encadeada Simples)
import java.util.LinkedList;
A lista LinkedList é utilizada para armazenar elementos em uma lista
encadeada simples, ou seja, lista alocada dinamicamente, onde a lista cresce
enquanto houver memória livre.
A seguir são descritos os principais métodos de uma LinkedList.
Sintaxe: void add (int index, Object element);
Insere o elemento especificado na posição especificada da lista.
Sintaxe: boolean add (Objetc o);
Anexa o elemento especificado no fim da lista.
Sintaxe: boolean addAll (Collection c);
Anexa todos os elementos da coleção especificada no fim da lista, na ordem que eles
são retornados do iterador da coleção especificado.
Sintaxe: boolean addAll (int index, Collection c);
Insere todos os elementos da coleção especificada dentro da lista, começando na
posição especificada.
109
Sintaxe: void addFirst (Object o);
Insere um dado elemento no começo da lista.
Sintaxe: void addLast (Object o);
Anexa um dado elemento no fim da lista.
Sintaxe: void clear ();
Remove todos os elementos da lista.
Sintaxe: Object clone ();
Retorna uma cópia superficial do LinkedList.
Sintaxe: boolean contains (Object o);
Retorna verdadeiro (true) se a lista contém o elemento especificado.
Sintaxe: Object get (int index);
Retorna o elemento da posição especificada na lista.
Sintaxe: Object getFirst ();
Retorna o primeiro elemento da lista.
Sintaxe: Object getLast ();
Retorna o último elemento da lista.
Sintaxe: int indexOf (Object o);
Retorna o índice da lista da primeira ocorrência do elemento especificado, ou -1 se
a Lista não contém este elemento.
Sintaxe: int lastIndexOf (Object o);
Retorna o índice da lista da última ocorrência do elemento especificado, ou -1 se a
lista não contém este elemento.
Sintaxe: ListIterator listIterator (int index);
Retorna um iterador da lista dos elementos da lista (na sequência correta),
começando na posição especificada na lista.
Sintaxe: Object remove (int index);
Remove o elemento da posição especificada na lista.
Sintaxe: boolean remove (Object o);
Remove a primeira ocorrência do elemento especificado na lista.
Sintaxe: Object removeFirst ();
Remove e retorna o primeiro elemento da lista.
Sintaxe: Objetc removeLast ();
Removes e retorna o último elemento da lista.
Sintaxe: Object set (int index, Object element);
Troca o elemento da posição especificada na lista pelo o elemento especificado.
Sintaxe: int size ();
Retorna o número de elementos na lista.
Sintaxe: Object [] toArray ();
Retorna um “array” (vetor) contendo todos os elementos da lista na ordem correta.
110
Sintaxe: Object [] toArray (Object [] a);
Retorna um “array” (vetor) contendo todos os elementos da lista na ordem correta.
Queue (Fila)
import java.util.Queue;
A interface Queue é utilizada para armazenar elementos em uma Fila.
A seguir são descritos os principais métodos da interface queue.
Sintaxe: E element();
Recupera, mas não remove, o primeiro da fila.
Sintaxe: boolean offer(E o);
Insere um elemento especificado dentro desta fila, se possível.
Sintaxe: E peek();
Recupera, mas não remove, o primeiro desta fila, retornando null se esta fila está
vazia.
Sintaxe: E poll();
Recupera e remove o primeiro desta fila, ou null se esta fila está vazia.
Sintaxe: E remove();
Recupera e remove o primeiro desta fila.
Programa Exemplo
“LinkedList”.
(5):
Exemplo
de
uma
fila
usando
a
classe
// -------------------------------------- Fonte: Prog5.java
package Prog5;
import java.util.LinkedList;
import java.util.Queue;
import javax.swing.*;
public class Prog5 {
public static void main(String[] args) {
Queue fila = new LinkedList();
// Fila com uma Lista Encadeada Simples
String s, extenso = "";
int nodo;
do {
s = JOptionPane.showInputDialog("Nodo: ");
nodo = Integer.parseInt(s);
if (nodo != 0) {
fila.offer(nodo);
}
} while (nodo != 0);
do {
extenso = extenso + fila.poll() + " ";
} while (!fila.isEmpty());
JOptionPane.showMessageDialog(null, "Fila: " + extenso, "Queue",
JOptionPane.PLAIN_MESSAGE);
111
“Queue”
+
}
}
Observação: No programa exemplo, a fila ( queue) foi implementada como uma lista
encadeada simples (LinkedList).
Diferenças entre Classe e Interface
Uma interface em Java é uma classe abstrata onde todos os métodos são
abstratos (abstract) e públicos (public), e todos os atributos são estáticos
(static) e constantes tipadas (final). Ela é semelhante a especificação de uma
classe abstrata pura, com uma diferença: os métodos das classes abstratas podem ou
não ser implementados nas classes que a estendem, já os métodos das interfaces tem
que ser obrigatoriamente implementados nas classes que as implementam.
Uma interface permite estabelecer uma padronização que deve ser obedecida
pela classe que a implementa. Quando uma classe implementa uma interface, ela deve
garantir que todas as funcionalidades especificadas pela interface estarão presentes
na classe.
A sintaxe da declaração de uma interface é parecida na definição de classes,
porém seu corpo define apenas as assinaturas dos métodos e constantes contidos na
interface.
Arrays (array)
import java.util.Arrays;
A classe Arrays pode ser utilizada em variáveis do tipo vetor.
Exemplo:
final int MAX = 50;
int [] vetor = new int[MAX];
A seguir são descritos os principais métodos da classe Array.
Sintaxe: static int binarySearch(byte[] a, byte key);
Procura em um vetor de “byte” especificado por um valor específico
algoritmo binário de busca.
usando
Sintaxe: static int binarySearch(char[] a, char key);
Procura em um vetor de “char” especificado por um valor específico
algoritmo binário de busca.
usando
Sintaxe: static int binarySearch(double[] a, double key);
Procura em um vetor de “double” especificado por um valor específico
algoritmo binário de busca.
usando
Sintaxe: static int binarySearch(float[] a, float key);
Procura em um vetor de “float” especificado por um valor específico
algoritmo binário de busca.
usando
Sintaxe: static int binarySearch(int[] a, int key);
Procura em um vetor de “int” especificado por um valor específico
algoritmo binário de busca.
usando
112
Sintaxe: static int binarySearch(long[] a, long key);
Procura em um vetor de “long” especificado por um valor específico
algoritmo binário de busca.
usando
Sintaxe: static int binarySearch(Object[] a, Object key);
Procura em um vetor de “Object” especificado por um valor específico
algoritmo binário de busca.
usando
Sintaxe: static int binarySearch(short[] a, short key);
Procura em um vetor de “short” especificado por um valor específico
algoritmo binário de busca.
usando
Sintaxe: static boolean deepEquals(Object[] a1, Object[] a2);
Retorna “true” se os dois arrays especifiados são iguais.
Sintaxe: static int deepHashCode(Object[] a);
Retorna o código “hash” baseado na localização do array especificado.
Sintaxe: static String deepToString(Object[] a);
Retorna em forma de “string” a localização do array especificado.
Sintaxe: static boolean equals(boolean[] a, boolean[] a2);
Retorna “true” se os dois arrays especificados de “boolean” são iguais.
Sintaxe: static boolean equals(byte[] a, byte[] a2);
Retorna “true” se os dois arrays especificados de “byte” são iguais.
Sintaxe: static boolean equals(char[] a, char[] a2);
Retorna “true” se os dois arrays especificados de “char” são iguais.
Sintaxe: static boolean equals(double[] a, double[] a2);
Retorna “true” se os dois arrays especificados de “double” são iguais.
Sintaxe: static boolean equals(float[] a, float[] a2);
Retorna “true” se os dois arrays especificados de “float” são iguais.
Sintaxe: static boolean equals(int[] a, int[] a2);
Retorna “true” se os dois arrays especificados de “int []” são iguais.
Sintaxe: static boolean equals(long[] a, long[] a2);
Retorna “true” se os dois arrays especificados de “long []” são iguais.
Sintaxe: static boolean equals(Object[] a, Object[] a2);
Retorna “true” se os dois arrays especificados de “Object []” são iguais.
Sintaxe: static boolean equals(short[] a, short[] a2);
Retorna “true” se os dois arrays especificados de “short” são iguais.
Sintaxe: static void fill(boolean[] a, boolean val);
Atribui um valor booleano especificado para cada elemento da matriz de booleanos.
Sintaxe: static void fill(boolean[] a, int fromIndex, int toIndex, boolean val);
113
Atribui um valor booleano especificado para cada elemento da faixa da matriz de
booleanos.
Sintaxe: static void fill(byte[] a, byte val);
Atribui um valor “byte” especificado para cada elemento da matriz de bytes.
Sintaxe: static void fill(byte[] a, int fromIndex, int toIndex, byte val);
Atribui um valor “byte” especificado para cada elemento da faixa da matriz de
bytes.
Sintaxe: static void fill(char[] a, char val);
Atribui um valor “char” especificado para cada elemento da matriz de caracteres.
Sintaxe: static void fill(char[] a, int fromIndex, int toIndex, char val);
Atribui um valor “char” especificado para cada elemento da faixa da matriz de
caracteres.
Sintaxe: static void fill(double[] a, double val);
Atribui um valor “double” especificado para
“doubles”.
cada
elemento
da
matriz
de
Sintaxe: static void fill(double[] a, int fromIndex, int toIndex, double val);
Atribui um valor ““double” especificado para cada elemento da faixa da matriz de
“doubles.
Sintaxe: static void fill(float[] a, float val);
Atribui um valor “float” especificado para cada elemento da matriz de ”floats”.
Sintaxe: static void fill(float[] a, int fromIndex, int toIndex, float val);
Atribui um valor ““float” especificado para cada elemento da faixa da matriz de
“floats”.
Sintaxe: static void fill(int[] a, int val);
Atribui um valor “int” especificado para cada elemento da matriz de ”ints”.
Sintaxe: static void fill(int[] a, int fromIndex, int toIndex, int val);
Atribui um valor “int []” especificado para cada elemento da faixa da matriz de
inteiros.
Sintaxe: static void fill(long[] a, int fromIndex, int toIndex, long val);
Atribui um valor “long []” especificado para cada elemento da faixa da matriz de
inteiros longos.
Sintaxe: static void fill(long[] a, long val);
Atribui um valor “long []” especificado para cada elemento da matriz de ”longs”.
Sintaxe: static void fill(Object[] a, int fromIndex, int toIndex, Object val);
Atribui um valor “Object []” especificado para cada elemento da faixa da matriz de
objetos.
Sintaxe: static void fill(Object[] a, Object val);
Atribui um valor “Object” especificado para
”Objects”.
114
cada
elemento
da
matriz
de
Sintaxe: static void fill(short[] a, int fromIndex, int toIndex, short val);
Atribui um valor “short []” especificado para cada elemento da faixa da matriz de
inteiros curtos.
Sintaxe: static void fill(short[] a, short val);
Atribui um valor “short []” especificado para cada elemento da matriz de inteiros
curtos.
Sintaxe: static int hashCode(boolean[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static int hashCode(byte[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static int hashCode(char[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static int hashCode(double[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static int hashCode(float[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static int hashCode(int[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static int hashCode(long[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static int hashCode(Object[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static int hashCode(short[] a);
Retorna o código “hash” com base no conteúdo da array especificada.
Sintaxe: static void sort(byte[] a);
Ordena o array especificado de “byte” em ordem ascendente numérica.
Sintaxe: static void sort(byte[] a, int fromIndex, int toIndex);
Ordena a faixa do array especificado de “byte” em ordem ascendente numérica.
Sintaxe: static void sort(char[] a);
Ordena o array especificado de “char” em ordem ascendente numérica.
Sintaxe: static void sort(char[] a, int fromIndex, int toIndex);
Ordena a faixa do array especificado de “char” em ordem ascendente numérica.
Sintaxe: static void sort(double[] a);
Ordena o array especificado de “double” em ordem ascendente numérica.
Sintaxe: static void sort(double[] a, int fromIndex, int toIndex);
Ordena a faixa do array especificado de “double” em ordem ascendente numérica.
Sintaxe: static void sort(float[] a);
115
Ordena o array especificado de “float” em ordem ascendente numérica.
Sintaxe: static void sort(float[] a, int fromIndex, int toIndex);
Ordena a faixa do array especificado de “float” em ordem ascendente numérica.
Sintaxe: static void sort(int[] a);
Ordena o array especificado de “int” em ordem ascendente numérica.
Sintaxe: static void sort(int[] a, int fromIndex, int toIndex);
Ordena a faixa do array especificado de “int” em ordem ascendente numérica.
Sintaxe: static void sort(long[] a);
Ordena o array especificado de “long” em ordem ascendente numérica.
Sintaxe: static void sort(long[] a, int fromIndex, int toIndex);
Ordena a faixa do array especificado de “long” em ordem ascendente numérica.
Sintaxe: static void sort(Object[] a);
Ordena o array especificado de “Object” em ordem ascendente numérica, de acordo
com a ordem natutal dos elementos.
Sintaxe: static void sort(Object[] a, int fromIndex, int toIndex);
Ordena a faixa do array especificado de “Object” em ordem ascendente numérica.
Sintaxe: static void sort(short[] a);
Ordena o array especificado de “short” em ordem ascendente numérica.
Sintaxe: static void sort(short[] a, int fromIndex, int toIndex);
Ordena a faixa do array especificado de “short” em ordem ascendente numérica.
Sintaxe: static String toString(boolean[] a)
Retorna uma “string” o conteúdo do array de “boolean” especificado.
Sintaxe: static String toString(byte[] a);
Retorna uma “string” o conteúdo do array de “byte” especificado.
Sintaxe: static String toString(char[] a);
Retorna uma “string” o conteúdo do array de “char” especificado.
Sintaxe: static String toString(double[] a);
Retorna uma “string” o conteúdo do array de “double” especificado.
Sintaxe: static String toString(float[] a);
Retorna uma “string” o conteúdo do array de “float” especificado.
Sintaxe: static String toString(int[] a);
Retorna uma “string” o conteúdo do array de “int []” especificado.
Sintaxe: static String toString(long[] a);
Retorna uma “string” o conteúdo do array de “long []” especificado.
Sintaxe: static String toString(Object[] a);
Retorna uma “string” o conteúdo do array de “Object []” especificado.
116
Sintaxe: static String toString(short[] a);
Retorna uma “string” o conteúdo do array de “short []” especificado.
Programa Exemplo (6): Exemplo de programa que usa a classe “Arrays” para ordenar
(sort) um vetor.
// --------------------------------------------- Fonte: Prog6.java
package Prog6;
import java.util.Arrays;
import javax.swing.JOptionPane;
public class Prog6 {
public static void main(String[] args) {
final int MAX = 5;
int [] vetor = new int[MAX];
int u = -1, n = 0, x;
String s;
do {
u++;
// ultimo elemento
n++;
// numero de elementos
s = JOptionPane.showInputDialog("Valor: ");
x = Integer.parseInt(s);
if (x != 0) {
vetor[u] = x;
}
else {
u--;
}
} while (x != 0 && n < MAX);
Arrays.sort(vetor);
// Arrays.sort(v, 0, n);
// vetor, início (incluso), fim + 1 (não incluso)
String extenso = Arrays.toString(vetor);
/*
for (int i = 0;i < vetor.length;i++) {
if (vetor[i] != 0) {
extenso += vetor[i] + " ";
}
}
*/
JOptionPane.showMessageDialog(null, "Array: " + extenso,
"Array", JOptionPane.PLAIN_MESSAGE);
}
}
ArrayList (lista de arrays)
A classe ArrayList possui os mesmos métodos da classe Vector.
Programa Exemplo (7): Programa mostra um exemplo de dois arrays que armazenam
respectivamente: nomes e idades.
// ------------------------------------------- Fonte: Prog7.java
117
package Prog7;
import java.util.ArrayList;
public class Prog7 {
public static void main(String[] args) {
ArrayList <String> nome = new ArrayList <String> ();
nome.add("Paulo Roberto");
nome.add("Renato Luis");
nome.add("Francisco Carlos");
nome.add("Ana Maria");
nome.add("Julia Helena");
ArrayList idade = new ArrayList ();
idade.add(48);
idade.add(46);
idade.add(50);
idade.add(53);
idade.add(52);
int n = nome.size();
for (int i = 0;i < n;i++) {
System.out.printf("Nome: %-20s Idade: %d\n", nome.get(i),
idade.get(i));
}
}
}
Resultado do Programa:
Nome:
Nome:
Nome:
Nome:
Nome:
Paulo Roberto
Renato Luis
Francisco Carlos
Ana Maria
Julia Helena
Idade:
Idade:
Idade:
Idade:
Idade:
48
46
50
53
52
118
14. Entrada e saída em disco (Arquivos)
Em Java é possível manipular arquivos através da classe File (Arquivo).
14.1 Métodos para manipular arquivos em Java
A seguir são descritos os principais métodos para manipular arquivos em Java:
Sintaxe: boolean canRead();
Testa se o aplicativo pode ler o arquivo indicado pelo “pathname” (caminho)
indicado.
Sintaxe: boolean canWrite();
Testa se o aplicativo pode modificar para o arquivo indicado pelo “pathname”
(caminho) indicado.
Sintaxe: int compareTo(File pathname);
Compara dois “pathnames” lexicograficamente.
Sintaxe: int compareTo(Object o);
Compara o “pathname” com outro objeto.
Sintaxe: boolean createNewFile();
Cria um novo arquivo vazio com o nome do “pathname”, se e somente se um arquivo
com este nome ainda não existe.
Sintaxe: static File createTempFile(String prefix, String suffix);
Cria um arquivo vazio no diretório de arquivos temporários, usando o prefixo e o
sufixo dado para gerar o seu nome.
Sintaxe: static File createTempFile(String prefix, String suffix, File directory);
Cria um novo arquivo vazio no diretório especificado, usando o prefixo e o sufixo
dado pela String para gerar o seu nome.
Sintaxe: boolean delete();
Deleta o arquivo ou diretório informado no “pathname”.
Sintaxe: void deleteOnExit();
Solicita que o arquivo ou diretório indicado por este “pathname” ser excluído
quando a máquina virtual termina.
Sintaxe: boolean equals(Object obj);
Testa se o “pathname” é igual ao objeto indicado.
Sintaxe: boolean exists();
Testa se o arquivo ou diretório indicado para este “pathname” existe.
Sintaxe: File getAbsoluteFile();
Retorna a forma absoluta do “pathname”.
Sintaxe: String getAbsolutePath();
Retorna uma String absoluta do “pathname”.
119
Sintaxe: File getCanonicalFile();
Retorna a forma canônica do “pathname”.
Sintaxe: String getCanonicalPath();
Retorna uma String canônica do “pathname”.
Sintaxe: String getName();
Retorna o nome do arquivo ou diretório indicado pelo “pathname”.
Sintaxe: String getParent();
Retorna uma String do caminho pai, esse caminho abstrato, ou nulo se este caminho
não é nome de um diretório pai.
Sintaxe: File getParentFile();
Retorna o caminho abstrato pai deste caminho, ou nulo se este caminho não é nome de
um diretório pai.
Sintaxe: String getPath();
Converte este “pathname” em uma String do “pathname”.
Sintaxe: int hashCode();
Calcula o código “hash” para este “pathname”.
Sintaxe: boolean isAbsolute();
Testa se este “pathname” é absoluto
Sintaxe: boolean isDirectory();
Testa se o arquivo indicado por este caminho (pathname) é um diretório.
Sintaxe: boolean isFile();
Testa se o arquivo indicado por este caminho (pathname) é um arquivo (file).
Sintaxe: boolean isHidden();
Testa se o arquivo indicado por este caminho (pathname) é um arquivo escondido.
Sintaxe: long lastModified();
Retorna o tempo em que o arquivo indicado por este caminho foi modificado pela
última vez.
Sintaxe: long length();
Retorna o comprimento do arquivo indicado pelo “pathname”.
Sintaxe: String[] list();
Retorna um vetor de Strings com os nomes dos arquivos e diretórios no diretório
indicado por este caminho.
Sintaxe: String[] list(FilenameFilter filter);
Retorna um vetor de Strings com os nomes de arquivos e diretórios no diretório
indicado por este caminho que satisfaçam o filtro especificado.
Sintaxe: File[] listFiles();
Retorna um vetor de “pathnames” indicando os arquivos no diretório indicado por
este caminho.
120
Sintaxe: File[] listFiles(FileFilter filter);
Retorna um vetor de “pathnames” indicando os arquivos e diretórios no diretório
indicado por este caminho que satisfaçam o filtro especificado.
Sintaxe: File[] listFiles(FilenameFilter filter);
Retorna um vetor de “pathnames” indicando os arquivos e diretórios no diretório
indicado por este caminho que satisfaçam o filtro especificado.
Sintaxe: static File[] listRoots();
Lista o sistema de arquivos disponíveis principais(root).
Sintaxe: boolean mkdir();
Cria o diretório chamado por este caminho.
Sintaxe: boolean mkdirs();
Cria o diretório chamado por este
necessários, mas inexistentes.
“pathname”, incluindo os diretórios pai
Sintaxe: boolean renameTo(File dest);
Renomeia o arquivo indicado pelo “pathname”.
Sintaxe: boolean setLastModified(long time);
Define o tempo da última modificação do arquivo ou diretório chamado por este
caminho.
Sintaxe: boolean setReadOnly();
Marca o arquivo ou diretório chamado por este caminho que só são permitidas
operações de leitura.
Sintaxe: String toString();
Retorna uma String “pathname” deste caminho.
Sintaxe: URI toURI();
Constrói um arquivo: URI que representa esse caminho.
Sintaxe: URL toURL();
Converte este caminho em um arquivo: URL.
14.2 Abertura de um arquivo texto
A seguir serão vistos alguns programas exemplos mostrando a manipulação de
arquivos em Java.
Programa exemplo (44): O programa abre um arquivo texto e exibe o número de bytes
do referido arquivo.
// ----------------------------------------- Fonte: prog44.java
package prog44;
import java.io.File;
public class Prog44 {
121
public static void main(String[] args) {
String nomeArquivo = "/Users/pluzzardi/luzzardi.txt";
File arqTexto = new File(nomeArquivo);
if (arqTexto.exists()) {
long bytes = arqTexto.length();
System.out.println("Arquivo: " + nomeArquivo);
System.out.println("Bytes: " + bytes);
} else {
System.out.println("ERRO: Arquivo não existe");
}
}
}
Resultado do Programa:
Arquivo: /Users/pluzzardi/luzzardi.txt <enter>
Bytes: 131
14.3 Listar um diretório
Programa exemplo (45): O programa exibe na tela (lista) os arquivos e diretórios do
“pathname” especificado.
// ------------------------------------------- Fonte: Prog45.java
package prog45;
import java.io.File;
public class Prog45 {
public static void main(String[] args) {
File diretorio = new File("//Users//pluzzardi");
String [] arquivos = diretorio.list();
for (int i = 0;i < arquivos.length; i++) {
File filho = new File(diretorio, arquivos[i]);
System.out.println(filho.getAbsolutePath());
}
}
}
Resultado do Programa:
/Users/pluzzardi/.bash_history
/Users/pluzzardi/.CFUserTextEncoding
/Users/pluzzardi/.config
/Users/pluzzardi/.cups
/Users/pluzzardi/.dropbox
/Users/pluzzardi/.DS_Store
/Users/pluzzardi/.gbas
/Users/pluzzardi/.local
/Users/pluzzardi/.netbeans-derby
/Users/pluzzardi/.ssh
/Users/pluzzardi/.Trash
/Users/pluzzardi/.viminfo
/Users/pluzzardi/Desktop
/Users/pluzzardi/Documents
/Users/pluzzardi/Downloads
/Users/pluzzardi/Dropbox
/Users/pluzzardi/frutas.luz
/Users/pluzzardi/Frutas.txt
/Users/pluzzardi/Leitura.zip
122
/Users/pluzzardi/Library
/Users/pluzzardi/luzzardi.dat
/Users/pluzzardi/Luzzardi.txt
/Users/pluzzardi/Movies
/Users/pluzzardi/Music
/Users/pluzzardi/NetBeansProjects
/Users/pluzzardi/nomes.sort
/Users/pluzzardi/nomes.txt
/Users/pluzzardi/palavras.dat
/Users/pluzzardi/pessoa.dat
/Users/pluzzardi/pessoas.dat
/Users/pluzzardi/Pictures
/Users/pluzzardi/Projects
/Users/pluzzardi/Public
Programa exemplo (46): O programa exibe na tela (lista) os arquivos e diretórios do
“pathname” especificado pelo usuário.
// -------------------------------------------- Fonte: Prog46.java
package prog46;
import java.io.File;
import java.util.Scanner;
public class Prog46 {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("Pathname: ");
String nomeDiretorio = entrada.nextLine();
File diretorio = new File(nomeDiretorio);
String [] arquivos = diretorio.list();
for (int i = 0;i < arquivos.length;i++) {
File filho = new File(diretorio, arquivos[i]);
System.out.println(filho.getAbsolutePath());
}
}
}
Resultado do Programa:
Pathname: /Users/pluzzardi <enter>
/Users/pluzzardi/.bash_history
/Users/pluzzardi/.CFUserTextEncoding
/Users/pluzzardi/.config
/Users/pluzzardi/.cups
/Users/pluzzardi/.dropbox
/Users/pluzzardi/.DS_Store
/Users/pluzzardi/.gbas
/Users/pluzzardi/.local
/Users/pluzzardi/.netbeans-derby
/Users/pluzzardi/.ssh
/Users/pluzzardi/.Trash
/Users/pluzzardi/.viminfo
/Users/pluzzardi/Desktop
/Users/pluzzardi/Documents
/Users/pluzzardi/Downloads
/Users/pluzzardi/Dropbox
/Users/pluzzardi/frutas.luz
/Users/pluzzardi/Frutas.txt
/Users/pluzzardi/Leitura.zip
/Users/pluzzardi/Library
/Users/pluzzardi/luzzardi.dat
123
/Users/pluzzardi/Luzzardi.txt
/Users/pluzzardi/Movies
/Users/pluzzardi/Music
/Users/pluzzardi/NetBeansProjects
/Users/pluzzardi/nomes.sort
/Users/pluzzardi/nomes.txt
/Users/pluzzardi/palavras.dat
/Users/pluzzardi/pessoa.dat
/Users/pluzzardi/pessoas.dat
/Users/pluzzardi/Pictures
/Users/pluzzardi/Projects
/Users/pluzzardi/Public
14.4 Manipulação de um arquivo de palavras
A seguir são mostrados alguns programas exemplos que manipulam um arquivo
contendo palavras. Veja o formato no exemplo abaixo:
5 <enter>
carambola
beringela
abacate
ervilha
damasco
Programa exemplo (47): O programa permite criar
(palavras.dat) permitindo a gravação destas palavras.
// --------------------------------------------- Fonte: Prog47.java
package prog47;
import java.io.File;
import java.io.FileWriter;
import java.util.Scanner;
public class Prog47 {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String diretorio = "/Users/pluzzardi";
File arquivo = new File(diretorio, "palavras.dat");
if (!arquivo.exists()) {
FileWriter file = new FileWriter(arquivo);
System.out.print("Número de Palavras: ");
String s = entrada.nextLine();
int numPalavras = Integer.parseInt(s);
file.write((byte)numPalavras);
file.write('\n');
for (int i = 1;i <= numPalavras;i++) {
System.out.print("Palavra: ");
byte a = (byte) System.in.read();
while(a != '\n') {
file.write(a);
a = (byte) System.in.read();
}
file.write('\n');
}
file.close();
}
else {
124
um
arquivo
de
palavras
System.out.println("ERRO: Arquivo já existe");
}
}
}
Exemplo de gravação no arquivo “palavras.dat”:
Número de palavras: 5 <enter>
Palavra: carambola <enter>
Palavra: beringela <enter>
Palavra: abacate <enter>
Palavra: ervilha <enter>
Palavra: damasco <enter>
Arquivo gerado:
5
carambola
beringela
abacate
ervilha
damasco
Programa exemplo (48): O programa permite abrir o arquivo de palavras
(palavras.dat) e exibe-os na tela.
// ------------------------------------------ Fonte: Prog48.java
package prog48;
import java.io.File;
import java.io.FileReader;
public class Prog48 {
public static void main(String[] args) throws Exception {
String diretorio = "/Users/pluzzardi";
File arquivo = new File(diretorio, "palavras.dat");
byte a;
if (arquivo.exists()) {
FileReader file = new FileReader(arquivo);
int numPalavras = file.read();
file.read();
for (int i = 1;i <= numPalavras;i++) {
System.out.print("Palavra: ");
a = (byte) file.read();
while(a != '\n') {
System.out.printf("%c", a);
a = (byte) file.read();
}
System.out.println();
}
file.close();
}
else {
System.out.println("ERRO: Arquivo não existe");
}
}
}
Resultado do Programa:
125
Palavra:
Palavra:
Palavra:
Palavra:
Palavra:
carambola
beringela
abacate
ervilha
damasco
Programa exemplo (49): O programa permite consultar o arquivo de palavras
(palavras.dat). Para tanto é solicitado, ao usuário, o número do registro para ser
calculado a posição deste registro no arquivo. Logo após o registro é exibido na
tela.
// ----------------------------------------- Fonte: Prog49.java
package prog49;
import java.io.*;
import java.util.*;
public class Prog49 {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String s;
String diretorio = "/Users/pluzzardi";
File arquivo = new File(diretorio, "palavras.dat");
FileInputStream in = new FileInputStream(arquivo);
InputStreamReader conversor = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(conversor);
FileReader file = new FileReader(arquivo);
if (arquivo.exists()) {
System.out.println("Arquivo: " + arquivo);
int numPalavras = file.read();
// descarta a primeira linha
String temp = buffer.readLine();
System.out.println("Total de Palavras: " + numPalavras);
String [] linha = new String[numPalavras + 1];
for (int i = 0;i < numPalavras;i++) {
linha[i] = buffer.readLine();
}
buffer.close();
in.close();
file.close();
int pos;
do {
System.out.print("Posição [1.." + numPalavras +
"] ou [0] Sair: ");
s = entrada.nextLine();
pos = Integer.parseInt(s);
if (pos >= 1 && pos <= numPalavras) {
System.out.println("Palavra: " + linha[pos - 1]);
}
else {
if (pos != 0) {
System.out.println("ERRO: Posição Inválida");
}
}
} while (pos != 0);
}
else {
System.out.println("ERRO: Arquivo não existe");
}
}
126
}
Resultado do Programa:
Arquivo: /Users/pluzzardi/palavras.dat <enter>
Total de Palavras: 5
Posição [1..5] ou [0] Sair: 1 <enter>
Palavra: carambola <enter>
Posição [1..5] ou [0] Sair: 2 <enter>
Palavra: beringela <enter>
Posição [1..5] ou [0] Sair: 3 <enter>
Palavra: abacate <enter>
Posição [1..5] ou [0] Sair: 4 <enter>
Palavra: ervilha <enter>
Posição [1..5] ou [0] Sair: 5 <enter>
Palavra: damasco <enter>
Posição [1..5] ou [0] Sair: 6 <enter>
ERRO: Posição Inválida
Posição [1..5] ou [0] Sair: 0 <enter>
14.5 Arquivo Texto
A seguir é mostrado um programa que lê um arquivo texto contendo:
a) Total de Palavras
b) Lista de Palavras (nome de frutas)
Arquito Texto: Frutas.txt
15
abacaxi
abacate
banana
pitanga
goiaba
morango
carambola
kiwi
laranja
bergamota
tomate
uva
caqui
lima
jaca
// ---------------------------------------------- Fonte: Leitura.java
package leitura;
import java.io.*;
public class Leitura {
public static void main(String[] args) {
int linhas = 0;
int max = 0;
String palavras [], linha;
String nomeArquivo = "/Users/pluzzardi/Frutas.txt";
try {
FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto);
127
max = Integer.parseInt(leitor.readLine());
palavras = new String[max];
System.out.println("Total de palavras: " + max);
int i = 0;
while ((linha = leitor.readLine()) != null) {
palavras[i] = linha;
System.out.println("Palavra: " + palavras[i]);
linhas++;
i++;
}
int n = (int) (Math.random() * max);
System.out.println("Palavra Sorteada: " + palavras[n]);
} catch(IOException e){
System.out.println("Erro: Problema com o Arquivo ");
}
}
}
Resultado do Programa:
Total de palavras: 15
Palavra: abacaxi
Palavra: abacate
Palavra: banana
Palavra: pitanga
Palavra: goiaba
Palavra: morango
Palavra: carambola
Palavra: kiwi
Palavra: laranja
Palavra: bergamota
Palavra: tomate
Palavra: uva
Palavra: caqui
Palavra: lima
Palavra: jaca
Palavra Sorteada: carambola
A seguir é mostrado um outro programa que lê um arquivo texto exibindo:
(a)número de linhas e (b) número de bytes.
// --------------------------------------------------- Fonte: Bytes.java
package bytes;
import java.io.*;
import java.util.Scanner;
public class Bytes {
public static void main(String[] args) {
int linhas = 0;
long bytes = 0;
String buffer;
Scanner input = new Scanner(System.in);
String nomeArquivo;
System.out.print("Nome do Arquivo: ");
nomeArquivo = input.nextLine();
try {
FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto);
int i = 0;
while ((buffer = leitor.readLine()) != null) {
128
bytes = bytes + buffer.length();
linhas++;
i++;
}
System.out.println(linhas + " Linha(s)");
System.out.println(bytes + " Byte(s)");
} catch(IOException e){
System.out.println("Erro: Problema com o Arquivo");
}
}
}
Resultado do Programa:
Nome do Arquivo: /Users/pluzzardi/NetBeansProjects/Bytes/src/bytes/bytes.java <enter>
37 Linha(s)
987 Byte(s)
A seguir é mostrado um outro programa que lê um arquivo texto exibindo:
a) Todas as linhas do arquivo texto com seu respectivo número
b) Número de Linhas
c) Número de Bytes
// --------------------------------------------------- Fonte: Listar.java
package listar;
import java.io.*;
import java.util.Scanner;
public class Listar {
public static void main(String[] args) {
int linhas = 0;
long bytes = 0;
String buffer;
Scanner input = new Scanner(System.in);
String nomeArquivo;
System.out.print("Nome do Arquivo: ");
nomeArquivo = input.nextLine();
try {
FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto);
int i = 0;
while ((buffer = leitor.readLine()) != null) {
bytes = bytes + buffer.length();
linhas++;
System.out.printf("%2d: %s\n", linhas, buffer);
i++;
}
System.out.println(linhas + " Linha(s)");
System.out.println(bytes + " Byte(s)");
} catch(IOException e){
System.out.println("Erro: Problema com o Arquivo");
}
}
}
Resultado do Programa:
129
Nome do Arquivo: /Users/pluzzardi/Frutas.txt <enter>
1: 15
2: abacaxi
3: abacate
4: banana
5: pitanga
6: goiaba
7: morango
8: carambola
9: kiwi
10: laranja
11: bergamota
12: tomate
13: uva
14: caqui
15: lima
16: jaca
16 Linha(s)
93 Byte(s)
A seguir é mostrado um outro programa que lê um arquivo texto e o número de
uma linha e exibe: (a) A linha especificada
// ------------------------------------------------------------ Fonte: Linha.java
package linha;
import java.io.*;
import java.util.Scanner;
public class Linha {
public static void main(String[] args) {
int linha = 0, numLinha;
String s, buffer;
Scanner input = new Scanner(System.in);
String nomeArquivo;
boolean listou = false;
System.out.print("Nome do Arquivo: ");
nomeArquivo = input.nextLine();
try {
FileReader arqTexto = new FileReader(nomeArquivo);
BufferedReader leitor = new BufferedReader(arqTexto);
System.out.print("Número da Linha: ");
s = input.nextLine();
numLinha = Integer.parseInt(s);
int i = 0;
while ((buffer = leitor.readLine()) != null) {
linha++;
if (linha == numLinha) {
System.out.printf("%2d: %s\n", linha, buffer);
listou = true;
}
i++;
}
} catch(IOException e){
System.out.println("Erro: Problema com o Arquivo");
}
if (!listou) {
System.out.println("ERRO: Linha não Encontrada");
}
}
}
Resultado do Programa:
130
Nome do Arquivo: /Users/pluzzardi/Frutas.txt <enter>
Número da Linha: 5 <enter>
5: pitanga
O seguinte programa mostra como gravar três informações em um arquivo texto
(Pessoa.dat): nome, idade e sexo de diversas pessoas.
// -------------------------------------------------------- Fonte: WriteDados.java
package writedados;
import java.io.File;
import java.io.FileWriter;
import java.util.Scanner;
public class WriteDados {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String s;
String diretorio = "/Users/pluzzardi/";
File arquivo = new File(diretorio, "Pessoa.dat");
if (!arquivo.exists()) {
FileWriter file = new FileWriter(arquivo);
do {
System.out.print("Nome: ");
String nome = entrada.nextLine();
file.write(nome);
file.write(":");
System.out.print("Idade: ");
String idade = entrada.nextLine();
file.write(idade);
file.write(":");
System.out.print("Sexo [M/F]: ");
s = entrada.nextLine();
char sexo = s.charAt(0);
file.write(sexo);
file.write(":");
System.out.print("Continua [S/N]? ");
do {
s = entrada.nextLine();
} while ("SsNn".indexOf(s) == -1);
} while ("S".equalsIgnoreCase(s));
file.close();
} else {
System.out.println("ERRO: Arquivo já existe");}
System.exit(0);
}
}
Resultado do Programa:
Nome: Paulo Roberto <enter>
Idade: 51 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? s <enter>
Nome: Renato Luis <enter>
Idade: 49 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? s <enter>
Nome: Francisco Carlos <enter>
Idade: 53 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? n <enter>
131
O seguinte programa mostra como recarregar as três informações gravadas em um
arquivo texto acima (Pessoa.dat).
// -------------------------------------------------------- Fonte: ReadDados.java
package readdados;
import
import
import
import
import
import
import
java.io.File;
java.io.FileReader;
java.io.BufferedInputStream;
java.io.BufferedReader;
java.io.FileInputStream;
java.io.InputStreamReader;
java.util.Scanner;
public class ReadDados {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String diretorio = "/Users/pluzzardi/";
File arquivo = new File(diretorio, "Pessoa.dat");
FileInputStream in = new FileInputStream(arquivo);
InputStreamReader conversor = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(conversor);
if (arquivo.exists()) {
FileReader file = new FileReader(arquivo);
String linha = buffer.readLine();
// lê todos os dados
System.out.println("Linha: " + linha);
String[] partes = linha.split(":");
int n = partes.length;
System.out.println("Partes: " + n);
for (int i = 0; i < n; i = i + 3) {
System.out.println("Nome: " + partes[i]);
System.out.println("Idade: " + Integer.parseInt(partes[i + 1]));
System.out.println("Sexo: " + partes[i + 2]);
}
file.close();
buffer.close();
} else {
System.out.println("ERRO: Arquivo já existe");
}
System.exit(0);
}
}
Resultado do Programa:
Linha: Paulo Roberto:51:m:Rento Luis:49:m:Francisco Carlos:53:m:
Partes: 9
Nome: Paulo Roberto
Idade: 51
Sexo: m
Nome: Rento Luis
Idade: 49
Sexo: m
Nome: Francisco Carlos
Idade: 53
Sexo: m
14.6 Lista de exercícios (arquivos)
132
14.6.1 Escreva um programa em Java que recebe via teclado o nome de um arquivo
texto. O programa deve imprimir na tela o número de bytes (caracteres) e o número
de linhas do arquivo ou ERRO: Arquivo não existe.
Exemplo:
Nome do arquivo texto: LISTA.JAVA <enter>
(12345) Bytes
(44) Linhas
ou
ERRO: Arquivo não existe
14.6.2 Escreva um programa em Java que recebe via teclado o nome de um arquivo
texto. O programa deve permitir ao usuário consultar o arquivo através da entrada
via teclado do número da linha. O programa deve imprimir a linha especificada ou
ERRO: Linha não existe (zero para abandonar).
Exemplo:
Nome do arquivo texto: LISTA.JAVA <enter>
Número de linha: 7 <enter>
7: int i, j, k;
Número de linha: 70 <enter>
ERRO: Linha não existe
Número de linha: 0 <enter>
// saída do programa
ERRO: Arquivo não existe
14.6.3 Escreva um programa em Java que recebe via teclado o nome de dois arquivos
texto (origem e destino). O programa deve copiar o conteúdo do arquivo origem para o
arquivo destino.
Exemplo:
Arquivo origem: LISTA.JAVA <enter>
Arquivo destino: LISTA.tmp <enter>
(20345) Bytes copiados
14.6.4 Escreva um programa em Java que recebe via teclado o nome do arquivo texto
fonte e o nome do arquivo texto destino. O programa deve converter o arquivo para
maiúsculo ou minúsculo (conforme escolha do usuário) gerando o arquivo texto
destino.
Exemplo:
Arquivo fonte: LISTA.JAVA <enter>
Arquivo destino: LISTA.TMP <enter>
[+] Maiúsculo ou [-] Minúsculo: + <enter>
(1234) Bytes convertidos
14.6.5 Escreva um programa em Java que recebe via teclado o nome de um arquivo
texto e uma palavra. O programa deve imprimir todas as linhas que possuem esta
palavra.
133
Exemplo:
Nome do arquivo texto: PALAVRA.JAVA <enter>
Palavra: if <enter>
23: if (a == b) {
33: if (ch == '\n') {
37: if (compara(linha,palavra)) {
41: if (ch != '\n') {
59: if (linha[i] == palavra[0]) {
65: if (linha[k] != palavra[j]) {
69: if (achei) {
14.6.6 Escreva um programa em Java que recebe via teclado o nome de um arquivo
texto. O programa deve permitir ao usuário consultar o arquivo através da entrada
via teclado do número inicial e número final. O programa deve imprimir desde a
linha inicial até a linha final ou ERRO: Linhas não existem.
Exemplo:
Nome do arquivo
Número inicial:
Número final: 9
7: int i, j, k;
8: char tecla;
9: long bytes =
texto: LISTA.JAVA <enter>
7 <enter>
<enter>
0;
ou
Número inicial: 70 <enter>
Número final: 90 <enter>
ERRO: Linhas não existem
14.6.7 Escreva um programa em Java (grava.java) que recebe via teclado o nome de um
arquivo texto. O programa deve permitir ao usuário inserir nomes neste arquivo via
teclado. O programa termina quando o usuário digitar <enter> na entrada do nome.
Exemplo:
Nome do arquivo texto: NOMES.TXT <enter>
Nome: Beatriz <enter>
Nome: Eva <enter>
Nome: Debora <enter>
Nome: Carla <enter>
Nome: Fatima <enter>
Nome: Ana <enter>
Nome: <enter>
14.6.8 Escreva um programa em Java (ler.java) que recebe via teclado o nome de um
arquivo texto. O programa deve ler e imprimir na tela todos os nomes armazenados no
arquivo pelo programa "grava.java".
Exemplo:
134
Nome do arquivo texto: NOMES.TXT <enter>
Nome: Beatriz
Nome: Eva
Nome: Debora
Nome: Carla
Nome: Fatima
Nome: Ana
14.6.9 Escreva um programa em Java (sort.java) que recebe via teclado o nome de um
arquivo texto origem e um destino. O programa deve ler, ordenar e gravar novamente
os nomes no arquivo destino.
Exemplo:
Nome do arquivo texto origem: NOMES.TXT <enter>
Nome do arquivo texto destino: NOMES.SRT <enter>
Ok, arquivo ordenado e copiado
Observação: Utilize o programa anterior (ler.java) para ver os nomes ordenados.
14.6.10 Escreva um programa em Java que recebe via teclado o nome de um arquivo
texto. O programa deve permitir ao usuário inserir nome, idade e sexo ([M]asculino
ou [F]eminino) neste arquivo via teclado. O programa termina quando o usuário
digitar <enter> na entrada do nome.
Exemplo:
Nome do arquivo texto: DADOS.TXT <enter>
Nome: Paulo Roberto <enter>
Idade: 41 <enter>
Sexo [M/F]: m <enter>
Nome: Renato Luis <enter>
Idade: 38 <enter>
Sexo [M/F]: m <enter>
Nome: Ana Maria <enter>
Idade: 44 <enter>
Sexo [M/F]: f <enter>
Nome: <enter>
14.6.11 Escreva um programa em Java que recebe via teclado o nome de um arquivo
texto. O programa deve ler e imprimir na tela todos os dados (nome, idade e sexo)
armazenados no arquivo pelo programa "14.6.10" (veja exemplo abaixo).
Exemplo:
Nome do arquivo texto: DADOS.TXT <enter>
Nome: Paulo Roberto
Idade: 41
Sexo: MASCULINO
Nome: Renato Luis
Idade: 38
Sexo: MASCULINO
Nome: Ana Maria
Idade: 44
135
Sexo: FEMININO
14.6.12 Escreva um programa em Java que recebe via teclado o nome de um arquivo
texto. O programa deve verificar a quantidade de homens e a quantidade de mulheres
no aquivo criado pelo programa "14.6.10".
Exemplo:
Nome do arquivo texto: DADOS.TXT <enter>
(2) Homens
(1) Mulheres
14.7 Acesso randômico em arquivos texto
É possível acessar um arquivo texto de forma randômica (aleatória), ou seja,
não puramente sequencial como é o padrão. Desta forma, pode-se acessar qualquer
linha de um arquivo texto.
Programa exemplo (14.6.2b):
package prog14_6_2b;
import java.io.RandomAccessFile;
import java.io.IOException;
import java.util.Scanner;
public class Prog14_6_2b {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String linha;
System.out.print("Nome do Arquivo Texto: ");
String nomeArquivo = input.nextLine();
try {
int nl;
RandomAccessFile file = new RandomAccessFile(nomeArquivo, "r");
do {
boolean encontrouLinha = false;
System.out.print("Linha: ");
String s = input.nextLine();
nl = Integer.parseInt(s);
int linhas = 0;
while ((linha = file.readLine()) != null) {
linhas++;
if (nl == linhas) {
System.out.println(nl + ": " + linha);
encontrouLinha = true;
}
}
if (!encontrouLinha) {
System.out.println("ERRO: Linha não existe");
}
file.seek(0);
// volta para a primeira linha
} while (nl != 0);
file.close();
} catch (IOException e) {
System.out.println("Erro: Problema com o Arquivo");
}
136
}
}
Resultado do Programa:
Nome do arquivo texto: LISTA.JAVA <enter>
Número de linha: 7 <enter>
7: int i, j, k;
Número de linha: 70 <enter>
ERRO: Linha não existe
Número de linha: 0 <enter>
ERRO: Arquivo não existe
14.8 Arquivo binário de objetos em Java
Em Java é possível gravar e carregar dados em arquivos binários que nada mais
são que são filas de bytes. Abaixo são vistos dois programas: (a) BinaryWrite grava
dados (nome idade e sexo) que são armazenados em um ArrayList e (b) programa
BinaryRead recupera os dados (como uma lista de dados) gravados no arquivo binário
gerado pelo programa BunaryWrite.
// ---------------------------------------------- Fonte: BinaryWrite.java
package binarywrite;
import
import
import
import
import
import
java.io.File;
java.io.ObjectOutputStream;
java.io.FileOutputStream;
java.io.IOException;
java.util.ArrayList;
java.util.Scanner;
public class BinaryWrite {
public static void main(String[] args) throws IOException {
Scanner input = new Scanner(System.in);
String s;
ArrayList pessoa = new ArrayList();
System.out.print("Nome do Arquivo Binário: ");
String nomeArquivo = input.nextLine();
try {
File file = new File(nomeArquivo);
ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(file));
do {
System.out.print("Nome: ");
String nome = input.nextLine();
System.out.print("Idade: ");
s = input.nextLine();
int idade = Integer.parseInt(s);
System.out.print("Sexo [M/F]: ");
s = input.nextLine();
char sexo = s.charAt(0);
pessoa.add(nome);
pessoa.add(idade);
pessoa.add(sexo);
do {
System.out.print("Continua [S/N]? ");
s = input.nextLine();
} while ("SsNn".indexOf(s) == -1);
} while ("Nn".indexOf(s) == -1);
output.writeObject(pessoa);
// grava ArrayList
output.close();
137
} catch (Exception e) {
System.out.println(e.toString());
}
}
}
Resultado do Programa:
Nome do Arquivo Binário: /Users/pluzzardi/pessoa.dat <enter>
Nome: Paulo <enter>
Idade: 51 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? s <enter>
Nome: Renato <enter>
Idade: 49 <enter>
Sexo [M/F]: M <enter>
Continua [S/N]? s <enter>
Nome: Francisco <enter>
Idade: 53 <enter>
Sexo [M/F]: m <enter>
Continua [S/N]? s <enter>
Nome: Ana <enter>
Idade: 55 <enter>
Sexo [M/F]: f <enter>
Continua [S/N]? s <enter>
Nome: Julia <enter>
Idade: 54 <enter>
Sexo [M/F]: F <enter>
Continua [S/N]? N <enter>
// ---------------------------------------------- Fonte: BinaryRead.java
package binaryread;
import
import
import
import
import
java.io.File;
java.io.FileInputStream;
java.io.ObjectInputStream;
java.util.ArrayList;
java.util.Scanner;
public class BinaryRead {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("Nome do Arquivo Binário: ");
String nomeArquivo = entrada.nextLine();
try {
File file = new File(nomeArquivo);
ObjectInputStream input = new ObjectInputStream(new FileInputStream(file));
Object pessoa = input.readObject();
System.out.println(pessoa.toString());
} catch (Exception e) {
System.out.println(e.toString());
}
}
}
Resultado do Programa:
Nome do Arquivo Binário: /Users/pluzzardi/pessoa.dat <enter>
[Paulo, 51, m, Renato, 49, M, Francisco, 53, m, Ana, 55, f, Julia, 54, F]
138
15. Conceitos diversos em Java
15.1 Operadores bit a bit
Se referem ao teste, ajuste ou troca de bits reais por um byte ou palavra
(podem ser dos tipos char, int, byte, short ou long).
139
Tabela 14: Operadores bit a bit
Operador
&
|
^
~
>>
<<
Ação
And
Or
Or exclusivo (XOr)
Complemento de um (Not)
Deslocar para a direita (shift)
Deslocar para a esquerda (shift)
Deslocamento (shift): variável >> número de deslocamentos;
Exemplo:
// ---------------------------------------------- Fonte: bit.java
package bit;
public class Bit {
public static void main(String[] args) {
int a = 128, b, c;
-> 10000000
b = a >> 1;
c = b << 1;
System.out.printf("a = %d\n",a);
System.out.printf("b = %d\n",b);
System.out.printf("c = %d\n",c);
-> 0100000
-> 1000000
}
}
Resultado do Programa:
a = 128
b = 64
c = 128
15.2 Formas abreviadas de Java
Java tem abreviações especiais que simplificam a codificação de um certo tipo
de comando de atribuição.
Exemplo:
x = x + 10;
... pode ser escrito como ...
x += 10;
Esta forma abreviada funcionará com todos os operadores aritméticos de Java.
Forma normal: variável = variável operador constante;
x = x + 7;
Forma abreviada:
variável operador= constante;
x += 7;
140
16. Listas Lineares: Pilha, Fila e Fila Circular
A seguir é visto a implementação de uma Pilha, uma Fila e uma Fila Circular
implementada em um vetor de inteiros.
Pilha: Estrutura linear organizada de forma que a entrada e a saída dos dados é
feita na mesma extremidade.
Forma de acesso: LIFO (Last Input First Output), ou seja, o último elemento a
entrar na pilha é o primeiro a sair dela.
Fila: Estrutura linear organizada em forma que a entrada dos dados é feita por uma
extremidade da lista linear e, a saída, é feita na outra extremidade.
Forma de acesso: FIFO (First Input First Output), ou seja, o primeiro elemento a
entrar na fila é o primeiro a sair da fila.
E - Entrada de Dados
S - Saída de Dados
Figura 4: Representação de uma fila e uma pilha
Funcionamento desta pilha:
Funcionamento desta fila:
Entrada: 1, 2 e 3
Saída: 3, 2 e 1
Entrada: 1, 2 e 3
Saída: 1, 2 e 3
16.1 Implementação de um lista em vetor
A seguir é visto um programa em Java que simula uma lista linear armazenada
em um vetor. Note que o número de elementos da lista é armazenado no primeiro nodo
do vetor, ou seja, v[0].
Programa exemplo (50): O programa permite inserir números inteiros em uma Lista
Linear implementada em um vetor. Quando o número digitado for igual à zero (0),
todos os números da lista são listados.
// ----------------------------------------------- Fonte: Prog50.java
141
package prog50;
import javax.swing.*;
public class Prog51 {
final static int SUCESSO = 0;
final static int LISTA_CHEIA = 1;
final static int LISTA_VAZIA = 2;
public static void main(String[] args) {
final int m = 7;
int [] v = new int [m];
int valor;
int erro = 0;
criaLista(v);
do {
String s = JOptionPane.showInputDialog("Elemento: ");
valor = Integer.parseInt(s);
if (valor != 0)
erro = incluiFim(m, v, valor);
if (erro == LISTA_CHEIA)
{
JOptionPane.showMessageDialog(null,
"Erro: Lista Cheia", "Atenção", JOptionPane.PLAIN_MESSAGE);
exibeLista(v);
return;
}
} while (valor != 0);
exibeLista(v);
}
// -------------------------------------------------- criaLista
static void criaLista(int [] v) {
v[0] = 0;
// armazena o número de elementos da lista
}
// -------------------------------------------------- incluiFim
static int incluiFim(int m, int [] v, int valor) {
int n = v[0];
if (n < m-1)
{
v[0]++;
v[v[0]] = valor;
return(SUCESSO);
}
else
return(LISTA_CHEIA);
}
// -------------------------------------------------- exibeLista
static void exibeLista(int [] v) {
String s = "";
int n = v[0];
if (n == 0)
JOptionPane.showMessageDialog(null,
"Erro: Lista Vazia", "Atenção", JOptionPane.PLAIN_MESSAGE);
else
{
142
for (int i = 1; i <= n; i++)
s = s + v[i] + " ";
JOptionPane.showMessageDialog(null, "Lista: " + s,
"Lista", JOptionPane.PLAIN_MESSAGE);
}
}
}
Programa exemplo (51): O programa permite inserir ([I]nício, [P]osição ou [F]im)
números inteiros em uma Lista Linear implementada em um vetor. Quando o número
digitado for igual à zero (0), todos os números da lista são exibidos na tela.
// --------------------------------------------------------- Fonte: Prog51.java
package prog51;
import javax.swing.*;
public class Prog51 {
final static int SUCESSO = 0;
final static int LISTA_CHEIA = 1;
final static int LISTA_VAZIA = 2;
public static void main(String[] args) {
final int m = 7;
int [] v = new int [m];
String s;
int valor, pos, n;
char ch, op;
int erro = 0;
criaLista(v);
do {
s = JOptionPane.showInputDialog("Elemento: ");
valor = Integer.parseInt(s);
if (valor != 0)
{
s = JOptionPane.showInputDialog(
"[I]inicio, [P]osição ou [F]im: ");
op = s.charAt(0);
switch (op)
{
case 'I':
case 'i': erro = incluiInic(m, v, valor);
break;
case 'P':
case 'p': n = tamanhoLista(v);
do {
s = JOptionPane.showInputDialog(
"Posição [1.." + n + "]: ");
pos = Integer.parseInt(s);
} while (pos < 1 && pos > n);
erro = incluiPos(m, v, valor, pos);
break;
case 'F':
case 'f': erro = incluiFim(m, v, valor);
break;
}
if (erro == LISTA_CHEIA)
{
JOptionPane.showMessageDialog(null,
"Erro: Lista Cheia", "Atenção", JOptionPane.PLAIN_MESSAGE);
exibeLista(v);
return;
143
}
}
} while (valor != 0);
exibeLista(v);
}
// -------------------------------------------------- criaLista
static void criaLista(int [] v) {
v[0] = 0;
// armazena o número de elementos
}
// -------------------------------------------------- incluiFim
static int incluiFim(int m, int [] v, int valor) {
int n = v[0];
if (n < m - 1)
{
v[0]++;
v[v[0]] = valor;
return(SUCESSO);
}
else
return(LISTA_CHEIA);
}
// -------------------------------------------------- incluiInic
static int incluiInic(int m, int [] v, int valor) {
int n = v[0];
if (n < m - 1)
{
v[0]++;
for (int i = n + 1;i >= 2;i--)
v[i] = v[i-1];
v[1] = valor;
return(SUCESSO);
}
else
return(LISTA_CHEIA);
}
// -------------------------------------------------- incluiPos
static int incluiPos(int m, int [] v, int valor, int pos) {
int n = v[0];
if (n < m - 1)
{
v[0]++;
if (pos == v[0] - 1)
{
v[v[0]] = v[n];
v[n] = valor;
}
else
{
for (int i = n + 1;i >= pos;i--)
{
v[i] = v[i-1];
System.out.println("Valor: " + v[i]);
}
v[pos] = valor;
}
return(SUCESSO);
144
}
else
return(LISTA_CHEIA);
}
// -------------------------------------------------- tamanhoLista
static int tamanhoLista(int [] v) {
return(v[0]);
}
// -------------------------------------------------- exibeLista
static void exibeLista(int [] v) {
String s = "";
int n = v[0];
if (n == 0)
JOptionPane.showMessageDialog(null,
"Erro: Lista Vazia", "Atenção", JOptionPane.PLAIN_MESSAGE);
else
{
for (int i = 1; i <= n; i++)
s = s + v[i] + " ";
JOptionPane.showMessageDialog(null, "Lista: " + s,
"Lista", JOptionPane.PLAIN_MESSAGE);
}
}
}
16.2 Implementação de uma Pilha
A seguir é mostrado uma implementação de Pilha usando a classe Pilha.
Programa exemplo (52): O programa permite inserir números inteiros em uma Pilha
usando uma classe Pilha implementada pelo programador. Quando o número digitado for
igual à zero (0), todos os números da pilha são listados.
// -------------------------------------------------------- Fonte: Prog52.java
package prog52;
import java.util.Scanner;
public class Prog52 {
public static void main(String[] args) {
Pilha pilha = new Pilha(5);
Scanner entrada = new Scanner(System.in);
String s;
int nodo;
do {
System.out.print("Elemento: ");
s = entrada.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0)
pilha.push(nodo);
} while (nodo != 0);
pilha.exibe();
}
}
// ---------------------------------------------------------- Fonte: Pilha.java
145
package prog52;
public class Pilha {
private int topo;
private int [] dados;
// ----------------------------------------------- construtor
public Pilha(int numElementos) {
dados = new int[numElementos];
topo = -1;
}
// construtor
// ------------------------------------------------ push
public void push(int i) {
int n = dados.length;
if (topo < n-1) {
topo++;
dados[topo] = i;
}
else
System.out.println("Erro: Pilha Cheia");
}
// ------------------------------------------------ pop
public int pop() {
if (topo != 0) {
int valor = dados[topo];
topo--;
return(valor);
}
else
return(0);
}
// ------------------------------------------------ exibe
public void exibe() {
System.out.print("Pilha: ");
for (int i = 0;i <= topo;i++) {
System.out.print(dados[i] + " ");
}
System.out.println();
}
}
Resultado do Programa:
Elemento: 50 <enter>
Elemento: 40 <enter>
Elemento: 30 <enter>
Elemento: 20 <enter>
Elemento: 10 <enter>
Elemento: 5 <enter>
Erro: Pilha Cheia
Elemento: 0 <enter>
Pilha: 10 20 30 40 50
16.3 Implementação de uma Fila
146
A seguir é visto uma implementação de uma Fila usando a classe Fila escrita
pelo programador.
Programa exemplo (53): O programa permite inserir números inteiros em uma Fila
usando uma classe Fila implementada pelo programador. Quando o número digitado for
igual à zero (0), todos os números da fila são listados.
// ------------------------------------------------- Fonte: Prog53.java
package prog53;
import java.util.Scanner;
public class Prog53 {
public static void main(String[] args) {
Fila fila = new Fila(5);
Scanner entrada = new Scanner(System.in);
String s, nodos = "";
int nodo;
do {
System.out.print("Elemento: ");
s = entrada.nextLine();
nodo = Integer.parseInt(s);
if (nodo != 0)
fila.insereFila(nodo);
} while (nodo != 0);
nodo = fila.retiraFila();
if (nodo == 0)
System.out.println("Fila: Vazia");
else {
while (nodo != 0) {
nodos = nodos + nodo + " ";
nodo = fila.retiraFila();
}
System.out.println("Fila: " + nodos);
}
}
}
// --------------------------------------------------- Fonte: Pilha.java
// Fila.java
package prog53;
public class Fila {
private int inic, fim, n;
private int [] dados;
// ---------------------------------------- construtor
public Fila(int numElementos) {
inic = -1;
fim = 0;
n = 0;
dados = new int[numElementos];
// construtor
}
// ------------------------------------------------ insereFila
public void insereFila(int i) {
int max = dados.length;
147
if (n < max) {
dados[fim] = i;
fim++;
n++;
}
else
System.out.println("Erro: Fila Cheia");
}
// ------------------------------------------------ retiraFila
public int retiraFila() {
if (n != 0) {
inic++;
n--;
return(dados[inic]);
}
else
return(0);
}
}
Resultado do Programa:
Elemento: 10 <enter>
Elemento: 20 <enter>
Elemento: 30 <enter>
Elemento: 40 <enter>
Elemento: 50 <enter>
Elemento: 60 <enter>
Erro: Fila Cheia
Elemento: 0 <enter>
Fila: 10 20 30 40 50
16.4 Implementação de uma Fila Circular
Um problema que ocorre em estruturas de dados do tipo Fila é que após algumas
operações de inserção e remoção de elementos, pode existir nodos vagos que não podem
ser reaproveitados, pois normalmente uma fila possui três informações que a
controlam: primeiro, último e número de elementos, não permitindo que os nodos
excluídos sejam ocupados novamente.
Uma forma de resolver este problema, é a utilização de uma Fila Circular,
onde todo nodo inserido ou removido tem sua posição calculada por uma equação,
fazendo com que, desta forma, sempre todos os nodos sejam reocupados com uma
informação.
Programa exemplo (54): O programa permite inserir números inteiros em uma Fila
Circular, ou seja, existe reaproveitamento da fila. Quando o número digitado for
igual à zero (0), todos os números da fila são listados.
// ------------------------------------------------------------ Fonte: prog54.java
package prog54;
import java.util.Scanner;
public class Prog54 {
public static void main(String[] args) {
FilaCircular fila = new FilaCircular(5);
Scanner entrada = new Scanner(System.in);
148
String s;
int valor;
char ch;
do {
System.out.printf("[I]ncluir, [E]xcluir ou [F]im? ");
do {
s = entrada.nextLine();
ch = s.charAt(0);
} while (ch != 'I' && ch != 'i' && ch != 'E' && ch != 'e' &&
ch != 'F' && ch != 'f');
switch (ch) {
case 'I':
case 'i': System.out.printf("Valor: ");
s = entrada.nextLine();
valor = Integer.parseInt(s);
fila.insereFilaCircular(valor);
break;
case 'E':
case 'e': valor = fila.excluiFilaCircular();
System.out.println("Elemento Retirado da Fila: " + valor);
break;
}
} while (ch != 'F' && ch != 'f');
fila.exibeFilaCircular();
System.exit(0);
}
}
// --------------------------------------------------- Fonte: FilaCircular.java
package prog54;
public class FilaCircular {
private int primeiro, ultimo, tamanho;
private int [] elem;
public FilaCircular(int numElementos) {
primeiro = 0;
ultimo = -1;
tamanho = 0;
elem = new int[numElementos];
}
// ------------------------------------ insereFilaCircular
public void insereFilaCircular(int dado) {
int n = elem.length;
if (tamanho == n) {
System.out.println("ERRO: Fila Cheia");
}
else {
tamanho++;
ultimo = (ultimo + 1) % n;
elem[ultimo] = dado;
}
}
// ----------------------------------- excluiFilaCircular
public int excluiFilaCircular() {
int n = elem.length;
if (tamanho == 0) {
System.out.println("ERRO: Fila Vazia");
return(-1);
149
}
else {
tamanho--;
int temp = primeiro;
primeiro = (primeiro + 1) % n;
return(elem[temp]);
}
}
// -------------------------------- exibeFilaCircular
public void exibeFilaCircular() {
int n = elem.length;
if (tamanho == 0) {
System.out.println("Fila Circular: Fila Vazia");
}
else {
int temp = primeiro;
System.out.print("Fila Circular: ");
for (int i = 1;i <= tamanho;i++) {
System.out.print(elem[temp] + " ");
temp = (temp + 1) % n;
}
System.out.printf("\n");
}
}
}
Resultado do Programa:
[I]ncluir, [E]xcluir ou [F]im?
Valor: 10 <enter>
[I]ncluir, [E]xcluir ou [F]im?
Valor: 20 <enter>
[I]ncluir, [E]xcluir ou [F]im?
Valor: 30 <enter>
[I]ncluir, [E]xcluir ou [F]im?
Valor: 40 <enter>
ERRO: Fila Cheia
[I]ncluir, [E]xcluir ou [F]im?
Elemento Retirado da Fila: 10
[I]ncluir, [E]xcluir ou [F]im?
Elemento Retirado da Fila: 20
[I]ncluir, [E]xcluir ou [F]im?
Valor: 50 <enter>
[I]ncluir, [E]xcluir ou [F]im?
Valor: 60 <enter>
[I]ncluir, [E]xcluir ou [F]im?
Valor: 70 <enter>
ERRO: Fila Cheia
[I]ncluir, [E]xcluir ou [F]im?
i <enter>
i <enter>
i <enter>
i <enter>
e <enter>
e <enter>
i <enter>
i <enter>
i <enter>
f <enter>
150
17. Tratamento de erros
Na execução de um programa em Java, podem ocorrer erros não previstos que
podem interromper a execução normal do programa. Tais erros podem ser:







Conversão numérica inválida;
Limite de um vetor (acessor a índice inválido);
Problemas com arquivos: abertura, criação ou caminho;
Overflow;
Erro de entrada e saída (input/output);
Divisão por zero;
Validação de dados.
Em Java, o programa tem condições de assumir o controle da execução em caso
que ocorra uma situação de erro não prevista.
Isso é feito através do mecanismo de tratamento de exceções que ao detectar
uma situação de erro, a máquina virtual Java gera uma exceção. Se o programa que
estiver sendo executado possuir um tratamento de exceções, ele assume o controle da
execução. Mas se a exceção não tiver um tratamento associado, o programa é
interrompido e a máquina virtual Java gera uma mensagem de erro.
Uma exceção é um evento que indica uma condição anormal que interrompe a
execução normal de um programa.
O tratamento de erros no Java cria objetos da classe erro, o tratamento
destes erros é feita pela manipulação destes objetos.
O tratamento de erros em Java basea-se em:
try {} catch {} finally {}.
A execução de um bloco de código, protegido por um tratamento de erros, é
feito colocando o bloco no try, e para cada erro que se deseja tratar, deve-se
colocar uma cláusula catch (tipo_de_erro variável_erro) {} e/ou uma cláusula finally
(opcional) que é executada após a execução do bloco try se não houver erro.
Sintaxe:
try {
// código fonte normal
return;
} catch (Exception error) {
// código que trata um tipo de erro ou mostra o erro
} catch (Exception error) {
// código que trata outro tipo de erro ou exibe o erro
} finally { // opcional
// código executado, mesmo tendo excessão
}
151
17.1 Tratamento de exceções
Exceções são instâncias de classes geradas quando houver erro. Estas exceções
podem ser captadas e tratadas para que não ocorra erros em tempo de execução.
Os métodos utilizados por classes de exceções são:

getMessage(): Retorna uma string com o erro.

printStackTrace(): Imprime na tela um histórico do erro e as linhas aonde os
erros ocorreram.

toString(): Converte a exceção numa String.

getCause(): Retorna a causa
desconhecida ou não existir.
da
exceção
ou
“null”
se
a
causa
for
17.2 Tratamento de erros: Entrada de número inteiro via teclado
O programa exemplo abaixo verifica e trata a exceção: formato inválido do
número (NumberFormatException).
// ------------------------------------------------------- Fonte: inteiro.java
package inteiro;
import java.util.Scanner;
public class Inteiro {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s;
int inteiro = -999;
try {
System.out.print("Inteiro: "); // código protegido contra erro
s = entrada.nextLine();
inteiro = Integer.parseInt(s);
return;
} catch (NumberFormatException error) {
// error.printStackTrace();
// mostra as linhas do erro
System.out.println("ERRO: " + error.getMessage());
// exibe o erro
} finally {
// OPCIONAL
System.out.println("INTEIRO: " + inteiro);
// executa depois do catch
}
System.exit(0);
}
}
Resultado do Programa (sem erro): [usuário digitou “120”]
Inteiro: 120
INTEIRO: 120
Resultado do Programa (sem erro): [usuário digitou “abc”]
Inteiro: abc
ERRO: For input string: "abc"
INTEIRO: -999
152
17.3 Tratamento de erros: Divisão por zero
O programa exemplo abaixo verifica e trata os seguintes erros: (a) divisão
por zero; (b) usuário apenas digitou <enter> sem nenhum número e (c) digitou letras
(NumberFormatException e ArithmeticException).
// ------------------------------------------------------ Fonte: Divisao.java
package divisao;
import java.util.Scanner;
public class divisao {
public static void main (String args[]) {
Scanner entrada = new Scanner(System.in);
String s;
float x, y, div = -999;
try {
System.out.print("Dividendo: ");
s = entrada.nextLine();
x = Float.parseFloat(s);
System.out.print("Divisor: ");
s = entrada.nextLine();
y = Float.parseFloat(s);
div = x / y;
System.out.println ("Divisao: " + div);
} catch (NumberFormatException error) {
System.out.println("Status: " + error.getMessage());
} catch (ArithmeticException error) {
// não funcinou
System.out.println ("Divisao: " + div);
}
System.exit(0);
}
}
Resultado do Programa (sem erro): [usuário digitou “3” + “2”]
Dividendo: 3
Divisor: 2
Divisao: 1.5
Resultado do Programa (sem erro): [usuário digitou “3” + “0”]
Dividendo: 3
Divisor: 0
Divisao: Infinity
Resultado do Programa (com erro): [usuário digitou “abc”]
Dividendo: abc
Status: For input string: "abc"
17.4 Tratamento de exceção com Exception
Em java pode-se usar o try ... catch da seguinte forma:
// --------------------------------------------------------- Fonte: Teste.java
package teste;
import java.util.Scanner;
153
public class Main {
public static void main(String[] args) {
testException();
System.exit(0);
}
public static void testException() {
Scanner entrada = new Scanner(System.in);
String s;
int x, y;
float div;
try {
System.out.print("Dividendo: ");
s = entrada.nextLine();
x = Integer.parseInt(s);
System.out.print("Divisor: ");
s = entrada.nextLine();
y = Integer.parseInt(s);
div = (float) x / y;
System.out.println("Divisao: " + div);
} catch (Exception error) {
error.printStackTrace();
System.out.println("Status: Divisao por zero");
}
}
}
Resultado do Programa (sem erro): [usuário digitou “3” + “2”]
Dividendo: 3
Divisor: 2
Divisao: 1.5
Resultado do Programa (sem erro): [usuário digitou “3” + “0”]
Dividendo: 3
Divisor: 0
Divisao: Infinity
17.5 Tratamento de exceção com MyException
Em java pode-se criar uma exceção da seguinte forma:
// ----------------------------------------------------------- Fonte: MyException.java
package myexception;
class MyException extends Exception {
public MyException(String msg) {
super(msg);
}
}
// --------------------------------------------------------- Fonte: Myexception.java
package myexception;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception{
Scanner entrada = new Scanner(System.in);
String s;
154
int x, y;
float div;
System.out.print("Dividendo: ");
s = entrada.nextLine();
x = Integer.parseInt(s);
System.out.print("Divisor: ");
s = entrada.nextLine();
y = Integer.parseInt(s);
div = (float) x / y;
if (y == 0) {
throw new MyException("Erro: Divisao por zero"); // não funcionou
}
System.out.println("Divisao: " + div);
}
}
17.6 Exceção em ArrayList
O
programa
abaixo mostra duas exceções:
IllegalArgumentException usando-se um ArrayList.
NumberFormatExcpetion
// ------------------------------------------------------ Fonte: arraylist.java
package arraylist;
import java.util.ArrayList;
import javax.swing.JOptionPane;
public class arraylist {
public static void main(String[] args) {
ArrayList lista;
int quantidade;
String s, nome;
try {
s = JOptionPane.showInputDialog("Quantidade: ");
quantidade = Integer.parseInt(s);
lista = new ArrayList(quantidade);
for (int i = 0;i < quantidade;i++) {
s = JOptionPane.showInputDialog("Nome: ");
lista.add(s);
nome = (String) lista.get(i);
System.out.println("Nome: " + nome);
}
} catch (NumberFormatException error) {
// para testar digite (abc)
System.out.println("ERRO: Conversao Ilegal");
System.out.println(error.getMessage());
} catch (IllegalArgumentException error) { // para testar digite (-1)
System.out.println("ERRO: ArrayList ilegal");
System.out.println(error.getMessage());
}
}
}
Resultado do Programa (sem erro): [usuário digitou “2” + “Paulo” + “Roberto”]
Nome: Paulo
Nome: Roberto
Resultado do Programa (com erro): [usuário digitou “-1”]
ERRO: ArrayList ilegal
Illegal Capacity: -1
155
e
Resultado do Programa (com erro): [usuário digitou “abc”]
ERRO: Conversao Ilegal
For input string: "abc"
17.7 Exceções criadas pelo programador
O
programas
a
seguir,
possui
duas
exceções
criadas
pelo
ListaCheiaExcepetion e IndiceInvalidoException.
// ------------------------------------------------------------ Fonte: Aluno.java
package listaobjeto;
public class Aluno {
private int codigo;
private String nome;
// ------------------------------------- Construtor
public Aluno(int cod, String s) {
codigo = cod;
nome = s;
}
// ------------------------------------- getNome
public String getNome() {
return(this.nome);
}
// ------------------------------------- getCodigo
public int getCodigo() {
return(this.codigo);
}
}
// -------------------------------------------------------- Fonte: ListObjet.java
package listaobjeto;
public class ListObjet {
private Object [] v;
private int n;
// ------------------------------------- Construtor
public ListObjet(int n) {
v = new Object[n];
n = 0;
}
// ------------------------------------- getTamanho
public int getTamanho() {
return(n);
}
// ------------------------------------- incluiFim
public void incluiFim(Object nodo) {
if (n == v.length) {
throw new ListaCheiaException();
156
programador:
}
else {
v[n] = nodo;
n++;
}
}
// ------------------------------------- consulta
public Object consulta(int indice) {
if (indice < 0 || indice >= n) {
throw new IndiceInvalidoException("Indice: " + indice + "invalido");
}
else {
return(v[indice]);
}
}
// ------------------------------------- ListaCheiaException
public class ListaCheiaException extends RuntimeException {
public ListaCheiaException () {
super("Lista Cheia");
}
public ListaCheiaException (String s) {
super(s);
}
}
// ------------------------------------- IndiceInvalidoException
public class IndiceInvalidoException extends RuntimeException {
public IndiceInvalidoException () {
super("Indice Invalido");
}
public IndiceInvalidoException (String s) {
super(s);
}
}
}
// ------------------------------------------------------ Fonte: ListaObjeto.java
package listaobjeto;
public class ListaObjeto {
public static void main(String[] args) {
ListObjet lista = new ListObjet(3);
lista.incluiFim(new Aluno(10, "Ana"));
lista.incluiFim(new Aluno(20, "Beatriz"));
lista.incluiFim(new Aluno(30, "Carla"));
// lista.incluiFim(new Aluno(40, "Debora"));
// tente rodar com esta linha
int tam = lista.getTamanho();
for (int i = 0;i < tam;i++) {
// tenta rodar com (i <= tam)
Aluno aluno = (Aluno) lista.consulta(i);
System.out.println(aluno.getNome() + "(" + aluno.getCodigo() + ")");
}
}
}
Resultado do Programa (sem erro):
157
Ana(10)
Beatriz(20)
Carla(30)
Resultado do Programa (com erro):
lista.incluiFim(new Aluno(40, "Debora"));
// rodou com esta linha
Exception in thread "main" listaobjeto.ListObjet$ListaCheiaException: Lista Cheia
at listaobjeto.ListObjet.incluiFim(ListObjet.java:26)
at listaobjeto.ListaObjeto.main(ListaObjeto.java:13)
Java Result: 1
Resultado do Programa (com erro):
for (int i = 0;i <= tam;i++) {
// rodou com esta linha
Ana(10)
Beatriz(20)
Carla(30)
Exception in thread "main" listaobjeto.ListObjet$IndiceInvalidoException:
Indice: 3invalido
at listaobjeto.ListObjet.consulta(ListObjet.java:38)
at listaobjeto.ListaObjeto.main(ListaObjeto.java:16)
Java Result: 1
158
18. Herança em Java
18.1 Herança simples
A herança simples permite que uma classe incorpore os atributos e métodos de
outra classe, ou seja, permite a construção de hierarquias de classes.
O primeiro passo envolve a definição de uma classe base (superclasse) que
define as características comuns a todos os objetos derivados desta classe. As
classes oriundas da classe base são chamadas classes derivadas ou extensão da
classe (subclasse)
Uma classe derivada herda todas as características da classe base e pode ter
novas características adicionadas a ela. Uma classe derivada segue a seguinte
diretriz em relação a classe base:
classe_derivada é um(a) classe_base
Exemplo: um cardial é um pássaro // classe base: pássaro
// classe derivada: cardial
Especificadores de acesso:

public (público)




private (privado)



Quem tem acesso à classe tem acesso também a qualquer membro público.
É raro ter atributos públicos, mas é comum ter métodos públicos.
Qualquer método tem acesso.
Um membro privado não é acessível fora da classe, somente pelos membros
da classe.
A intenção é permitir que apenas quem escreve a classe possa usar esse
membro.
protected (protegido)


O membro protegido é acessível à classe e a suas sub-classes (classes
derivadas).
A intenção é dar acesso aos programadores que estenderão sua classe.
18.2 Controle de acesso na definição de uma classe derivada
Quando uma classe derivada é definida, ou seja, na definição de herança
simples, seus membros (atributos e métodos) são declarados internamente e o acesso a
estes pode ser público (public), privativo (private) ou protegido (protected). O
acesso a membros protegidos é igual ao acesso a membros privativos, exceto para o
acesso das classes derivadas da classe.
A forma geral de especificar herança simples é:
159
Especificador_de_acess class nome_classe_derivada extends nomeclasse_base {
// atributos
// métodos
}
Quando uma classe herda as características de outra classe, todos os membros
da classe base tornam-se membros da classe derivada. O tipo de acesso da classe base
dentro da classe derivada é determinado pelo especificador de acesso. Qualquer que
seja o especificador de acesso, membros privativos da classe base continuam sendo
propriedade privada da classe base, e não podem ser acessados por classes derivadas.
Quando o especificador de acesso é public, todos os membros públicos da
classe base tornam-se membros públicos da classe derivada, e os membros protegidos
da classe base tornam-se membros protegidos da classe derivada. Esta é a diferença
que existe entre membros privativos e membros protegidos.
Quando o especificador de acesso é private, todos os membros públicos e
protegidos da classe base tornam-se membros privativos da classe derivada, ou seja,
a classe derivada não pode transferir seus privilégios de acesso a outras classes.
Quando o especificador de acesso é protected, todos os membros públicos e
protegidos da classe base tornam-se membros protegidos da classe derivada.
Programa exemplo (55): O objetivo do programa a seguir é demonstrar a utilização de
herança simples (atributos da classe base são privados).
// ------------------------------------------------------- Fonte: Heranca.java
package heranca;
public class Heranca {
public static void main(String[] args) {
Derivada objeto = new Derivada(3);
int resp;
objeto.Seta(1, 2);
resp = objeto.Soma();
System.out.println("Somador (x + y + z): " + objeto.Somador(resp));
}
}
// -------------------------------------------------------- Fonte: base.java
package heranca;
public class Base {
private int x, y;
// atributos privados
public void Seta(int a, int b) {
x = a;
y = b;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
public int Soma() {
System.out.println("Soma (x + y): " + (x + y));
return(x + y);
160
}
}
// ---------------------------------------------------------- Fonte: Derivada.java
package heranca;
public class Derivada extends Base {
private int z;
public Derivada(int x) {
z = x;
System.out.println("z = " + z);
}
public int Somador(int soma) {
// não é possível acessar x e y pois são privados da classe base
return(soma + z);
}
}
Resultado do Programa:
z = 3
x = 1
y = 2
Soma (x + y): 3
Somador (x + y + z): 6
Responda: Porque o atributo z é mostrado primeiro?
18.3 Tipos de acessos (especificadores de acesso)



public (público): Todos os atributos da classe base são públicos na classe
derivada.
private (privado): Os atributos só podem ser acessados pelos métodos que
fazem parte da classe.
protected (protegido): Os atributos podem ser acessados pelos métodos de
classes derivadas.
Programa exemplo (56): O objetivo do programa é demonstrar a utilização de herança
simples (atributos da classe base são protegidos).
// ---------------------------------------------------------- Fonte: Heranca.java
package heranca;
public class Heranca {
public static void main(String[] args) {
Derivada objeto = new Derivada(3);
int resp;
objeto.Seta(1, 2);
resp = objeto.Soma();
System.out.println("Somador (x + y + z): " + objeto.Somador(resp));
}
}
// ----------------------------------------------------------- Fonte: base.java
package heranca;
161
public class Base {
protected int x, y;
// atributos protegidos
public void Seta(int a, int b) {
x = a;
y = b;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
public int Soma() {
System.out.println("Soma (x + y): " + (x + y));
return(x + y);
}
}
// ------------------------------------------------------------ Fonte: Derivada.java
package heranca;
public class Derivada extends Base {
private int z;
public Derivada(int x) {
z = x;
System.out.println("z = " + z);
}
public int Somador(int soma) {
return(x + y + z); // é possível acessar x e y pois são protegidos na classe base
}
}
Resultado do Programa:
z = 3
x = 1
y = 2
Soma (x + y): 3
Somador (x + y + z): 6
A seguir é visto a utilização do comando super. Super
construtor padrão da classe-pai.
faz uma chamada ao
// ------------------------------------------------------------ Fonte: Derivada.java
package heranca;
public class Derivada extends Base {
private int z;
public Derivada(int x) {
super(10, 20); // chamada formal ao construtor da classe pai
//super();
z = x;
System.out.println("z = " + z);
}
public int Somador(int soma) {
return(x + y + z); // é possível acessar x e y pois são privados a classe base
}
protected void finalize() {
162
System.out.println("Derivada: Final");
}
}
// ------------------------------------------------------------ Fonte: Base.java
//
//
//
//
//
//
//
//
A palavra-chave super permite acesso ao construtor da superclasse (base)
se for utilizada como nome de método, executa o construtor da superclasse
Nota-se que se não houver, no construtor da subclasse, nenhuma chamada
explicita ao construtor da superclasse, o construtor sem argumento é
chamado por "default". Se for incluída uma chamada ao construtor da
superclasse, ela deve ser o primeiro comando executado no construtor
da subclasse.
package heranca;
public class Base {
protected int x, y;
// atributos protegidos
Base() {
// construtor default
this.x = 0;
this.y = 0;
System.out.println("x = " + this.x + " - y = " + this.y);
}
Base(int a, int b) {
this.x = a;
this.y = b;
System.out.println("x = " + this.x + " - y = " + this.y);
}
public void Seta(int a, int b) {
x = a;
y = b;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
protected int Soma() {
System.out.println("Soma (x + y): " + (x + y));
return(x + y);
}
}
// ------------------------------------------------------------ Fonte: Heranca.java
package heranca;
public class Heranca {
public static void main(String[] args) {
Derivada objeto = new Derivada(3);
int resp;
objeto.Seta(1, 2);
resp = objeto.Soma();
System.out.println("Somador (x + y + z): " + objeto.Somador(resp));
}
}
Resultado do Programa:
x = 10 - y = 20
z = 3
163
x = 1
y = 2
Soma (x + y): 3
Somador (x + y + z): 6
18.4 Lista de exercícios sobre Herança
18.4.1 Herança (primeiro)
Dado os seguintes códigos em Java:
// ------------------------------------------------------------------ TestaHeranca.java
package testaheranca;
public class TestaHeranca {
public static void main(String[] args) {
Cliente cliente = new Cliente("Paulo Roberto", "123.456-78", 1234.56);
cliente.imprimePessoa();
cliente.imprimeCliente();
}
}
// ----------------------------------------------------------------------- Pessoa.java
package testaheranca;
public class Pessoa {
protected String nome;
protected String cpf;
Pessoa() {
this.nome = "xxxx";
this.cpf = "xxx.xxx.xxx-xx";
}
Pessoa(String nome, String cpf) {
this.nome = nome;
this.cpf = cpf;
}
public void imprimePessoa() {
System.out.println("Nome: " + nome);
System.out.println("CPF: " + cpf);
}
}
// ----------------------------------------------------------------------- Cliente.java
package testaheranca;
public class Cliente extends Pessoa {
private double conta;
Cliente(String nome, String cpf, double conta) {
this.conta = conta;
}
public void imprimeCliente() {
System.out.println("Conta: " + conta);
164
}
}
Resultado esperado do programa:
Nome: Paulo Roberto
CPF: 123.456-78
Conta: 1234.56
Resultado real do programa:
Nome: xxxx
CPF: xxx.xxx.xxx-xx
Conta: 1234.56
Que modificações devem ser feitas no código fonte para que o resultado do
programa seja o esperado?
18.4.2 Herança (segundo)
Dado a classe base “Pessoa” e o programa principal “TestaHomem”,
construa as classes derivadas “Homem” e “Mulher” que contenha os atributos e
métodos abaixo descritos:
// ------------------------------------------------------------------------ Pessoa.java
package testahomem;
public class Pessoa {
protected double altura;
protected char sexo;
Pessoa() {
this.altura = 0.0;
this.sexo = 'g';
}
Pessoa(double altura, char sexo) {
this.altura = altura;
this.sexo = sexo;
}
public void imprimePessoa() {
System.out.println("Altura: " + altura);
System.out.println("Sexo: " + sexo);
}
}
Pessoa
altura
sexo
imprimePessoa
Homem
pesoIdeal
calculaPesoIdealHomem
imprimePesoIdealHomem
Mulher
pesoIdeal
165
calculaPesoIdealMulher
imprimePesoIdealMulher
// -------------------------------------------------------------------- TestaHomem.java
package testahomem;
public class TestaHomem {
public static void main(String[] args) {
Homem homem = new Homem(1.64, 'm');
Mulher mulher = new Mulher(1.59, 'f');
homem.calculaPesoIdealHomem();
homem.imprimePessoa();
homem.imprimePesoIdealHomem();
mulher.calculaPesoIdealMulher();
mulher.imprimePessoa();
mulher.imprimePesoIdealMulher();
}
}
Resultado do Programa:
Altura: 1.64
Sexo: m
Peso Ideal (Homem): 61,23
Altura: 1.59
Sexo: f
Peso Ideal (Homem): 54,04
18.4.3 Herança (terceiro)
Dados os seguintes códigos em Java:
// ------------------------------------------------------------------ TestaObjetos.java
package testaobjetos;
public class TestaObjetos {
public static void main(String[] args) {
Linha linha = new Linha(1, 2, 3, 4);
Retangulo retangulo = new Retangulo(1, 2, 3, 4);
System.out.println("Linha: ");
linha.imprimeLinha();
System.out.println("Retângulo: ");
retangulo.imprimeRetangulo();
}
}
// ------------------------------------------------------------------------ Objeto.java
package testaobjetos;
public class Objeto {
protected int x;
protected int y;
Objeto() {
x = 0;
y = 0;
}
166
Objeto(int x, int y) {
this.x = x;
this.y = y;
}
public void imprimeObjeto() {
System.out.println("x = " + x + " - y = " + y);
}
}
// ------------------------------------------------------------------------- Linha.java
package testaobjetos;
public class Linha extends Objeto {
private Objeto p1;
private Objeto p2;
Linha (int xi, int yi, int xf, int yf) {
p1 = new Objeto(xi, yi);
p2 = new Objeto(xf, yf);
}
public void imprimeLinha() {
p1.imprimeObjeto();
p2.imprimeObjeto();
}
}
Implemente a classe derivada “Retangulo” para que o programa funcione conforme o “resultado
do programa” abaixo:
Resultado do Programa:
Linha:
x = 1 - y =
x = 3 - y =
Retângulo:
x = 1 - y =
x = 3 - y =
x = 3 - y =
x = 1 - y =
2
4
2
2
4
4
167
168
19. Coletor de Lixo (Garbage Collector)
O Java possui um coletor de lixo automático, mas pode-se
implicitamente através do método: System.gc. Olhe no exemplo abaixo:
// ------------------------------------------------ Fonte: Heranca.java
package heranca;
public class Heranca {
public static void main(String[] args) {
Derivada objeto = new Derivada(3);
int resp;
objeto.Seta(1, 2);
resp = objeto.Soma();
System.out.println("Somador (x + y + z): " + objeto.Somador(resp));
objeto = null; // marca para coletor de lixo
System.gc();
// chamada do coletor de lixo
System.out.println("Somador (x + y + z): " + objeto.Somador(resp));
}
}
// ------------------------------------------------ Fonte: base.java
package heranca;
public class Base {
protected int x, y;
// atributos protegidos
public void Seta(int a, int b) {
x = a;
y = b;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
public int Soma() {
System.out.println("Soma (x + y): " + (x + y));
return(x + y);
}
}
// --------------------------------------------------- Fonte: Derivada.java
package heranca;
public class Derivada extends Base {
private int z;
public Derivada(int x) {
z = x;
System.out.println("z = " + z);
}
public int Somador(int soma) {
return(x + y + z); // é possível acessar x e y pois são privados a classe base
}
}
Resultado do Programa:
z = 3
Observação: O erro se deve ao objeto ter sido
desalocado pelo coletor
de lixo
169
chamá-lo
x = 1
y = 2
Soma (x + y): 3
Somador (x + y + z): 6
Derivada: Final
Exception in thread "main" java.lang.NullPointerException
at testacoletorlixo.TestaColetorLixo.main(TestaColetorLixo.java:14)
Java Result: 1
20. Construtor e finalizador em Java
Em Java, uma classe além de poder ter um construtor, pode ter um finalizador
(método: protected void finalize) que é executado automaticamente no término do
programa. Veja o exemplo a seguir:
// -------------------------------------------------------- Fonte: base.java
package heranca;
public class Base {
protected int x, y;
// atributos protegidos
public void Seta(int a, int b) {
x = a;
y = b;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
public int Soma() {
System.out.println("Soma (x + y): " + (x + y));
return(x + y);
}
}
// ---------------------------------------------------- Fonte: Derivada.java
package heranca;
public class Derivada extends Base {
private int z;
public Derivada(int x) {
z = x;
System.out.println("z = " + z);
}
public int Somador(int soma) {
return(x + y + z); // é possível acessar x e y pois são privados a classe base
}
protected void finalize() {
System.out.println("Finalizador: Final do programa");
}
}
// --------------------------------------------------------- Fonte: Heranca.java
package heranca;
public class Heranca {
public static void main(String[] args) {
Derivada objeto = new Derivada(3);
int resp;
170
objeto.Seta(1, 2);
resp = objeto.Soma();
System.out.println("Somador (x + y + z): " + objeto.Somador(resp));
objeto = null; // marca para coletor de lixo
System.gc();
// chamada do coletor de lixo
}
}
Resultado do Programa:
z = 3
x = 1
y = 2
Soma (x + y): 3
Somador (x + y + z): 6
Finalizador: Final do Programa
171
21. Applets em Java
Applets são pequenos programas (aplicativos) escritos em Java que podem ser
executados pela Java Virtual Machine em navegadores.
São programas Java que podem ser embutidos em documentos HTML ( Hypertext
markup Language). Quando o navegador carrega uma página Web que contém uma applet, o
applet é baixado para o navegador e então é executado.
Exemplo de Applet (PaintApplet):
// ------------------------------------------------ Fonte: PaintApplet.java
import java.awt.Graphics;
import javax.swing.JApplet;
public class PaintApplet extends JApplet {
public void paint(Graphics g) {
super.paint(g);
g.drawString("Paint by Luzzardi", 25, 15);
}
}
Inserção da Applet no documento HTML:
<HTML>
<APPLET code= "PaintApplet.class" width= "800" height="600" > </APPLET>
</HTML>
Para compilar a Applet:
$ javac PaintApplet.java <enter>
$
// é gerado PaintApplet.class
Para testar a Applet:
$ appletviewer PaintApplet.html <enter>
$
Exemplo de Applet (CalcApplet):
// ---------------------------------------------------- Fonte: CalcApplet.java
import java.awt.Graphics;
import javax.swing.JApplet;
public class CalcApplet extends JApplet {
Calculadora calc = new Calculadora();
double resp;
// -------------------------------------------- init
public void init() {
calc.entradaDados();
resp = calc.operaCalculadora();
}
172
// -------------------------------------------- paint
public void paint(Graphics g) {
int erro = calc.retornaErro();
super.paint(g);
g.drawString("Calculadora 1.0 by Luzzardi", 300, 270);
g.drawLine(0, 280, 1279, 280);
if (erro == 0) {
g.drawString("Resposta: " + resp, 340, 300);
}
else {
switch (erro) {
case 1: g.drawString("Erro: Divisao por Zero", 340, 300);
break;
case 2: g.drawString("Erro: Raiz Complexa", 340, 300);
break;
case 3: g.drawString("Erro: Tangente Infinita", 340, 300);
break;
}
}
g.drawLine(0, 310, 1279, 310);
}
}
// ------------------------------------------------- Fonte: Calculadora.java
import java.awt.Graphics;
import javax.swing.*;
public class Calculadora {
private double x, y, resp;
private char op;
private int erro;
public Calculadora () {
erro = 0;
}
// construtor
// -------------------------------- retornaErro
public int retornaErro() {
return(this.erro);
}
// -------------------------------- entradaDados
public void entradaDados() {
String s;
s = JOptionPane.showInputDialog("Digite um Valor: ");
x = Double.parseDouble(s);
do {
s = JOptionPane.showInputDialog("Operador [+ - * / Rr Pp Ss Cc Tt]: ");
op = s.charAt(0);
} while (!strChr("+-*/RrPpSsCcTt", op));
if (!strChr("RrSsCcTt", op)) {
s = JOptionPane.showInputDialog("Digite outro Valor: ");
y = Double.parseDouble(s);
}
}
// ---------------------------- operaCalculadora
public double operaCalculadora() {
final double pi = 3.14158;
173
double rads;
switch (op)
{
case '+':
case '-':
case '*':
case '/':
case 'R':
case 'r':
case 'P':
case 'p':
case 'S':
case 's':
case 'C':
case 'c':
case 'T':
case 't':
resp = soma(x, y);
break;
resp = subtracao(x, y);
break;
resp = multiplicacao(x, y);
break;
if (y == 0)
erro = 1;
// divisão por zero
else
resp = divisao(x, y);
break;
if (x < 0)
erro = 2;
// raiz negativa
else
resp = raizQuadrada(x);
// Raiz Quadrada
break;
resp = power(x, y);
break;
resp = seno(x);
break;
// potência
// seno
resp = cosseno(x);
break;
// cosseno
if (x == 90 || x == 180) {
erro = 3;
}
else {
resp = tangente(x);
// tangente
}
break;
}
return(this.resp);
}
// ---------------------------- strChr
private boolean strChr(String s, char ch) {
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == ch) {
return(true);
}
}
return(false);
}
// ---------------------------- soma
private double soma(double x, double y) {
return(x + y);
}
// ---------------------------- subtracao
private double subtracao(double x, double y) {
return(x - y);
}
// ---------------------------- multiplicacao
174
private double multiplicacao(double x, double y) {
return(x * y);
}
// ---------------------------- divisao
private double divisao(double x, double y) {
if (y == 0) {
erro = 1;
return(-1);
}
return(x / y);
}
// ---------------------------- raizQuadrada
private double raizQuadrada(double x) {
return(Math.sqrt(x));
}
// ---------------------------- power
private double power(double x, double y) {
return(Math.pow(x, y));
}
// ---------------------------- seno
private double seno(double x) {
final double pi = 3.14158;
double rads;
rads = x * pi / 180.0;
return(Math.sin(rads));
}
// ---------------------------- cosseno
private double cosseno(double x) {
final double pi = 3.14158;
double rads;
rads = x * pi / 180.0;
return(Math.cos(rads));
}
// ---------------------------- tangente
private double tangente(double x) {
final double pi = 3.14158;
double rads;
rads = x * pi / 180.0;
return(Math.tan(rads));
}
}
Inserção da Applet em um documento HTML:
<HTML>
<APPLET code= "CalcApplet.class" width= "1280" height="800" > </APPLET>
</HTML>
Para compilar a Applet:
175
$ javac Calculadora.java <enter>
$ javac CalcApplet.java <enter>
$
// é gerado Calculadora.class
// é gerado CalcApplet.class
Para testar a Applet:
$ appletviewer CalcApplet.html <enter>
$
176
22. Threads em Java
Forma de um processo dividir-se em duas ou mais tarefas que podem ser
executadas concorrentementes, ou seja, pode ser visto como um fluxo de controle
seqüencial isolado dentro do programa.
Uma thread tem começo, fim e uma seqüência de comandos. Uma thread em Java
não é um programa, pois não executa sozinha, ela executa dentro de um programa.
Threads permitem que um programa simples possa executar várias tarefas
diferentes ao mesmo tempo, independentemente uma das outras. Programas multithreaded
são programas que contém várias
threads, executando tarefas distintas
simultaneamente.
Uma thread possui um método run. Ele é responsável por executar as tarefas às
quais thread se destina. Pode-se implementar threads de duas formas:
• Cria-se uma subclasse da classe thread e define-se o método run de forma
mais adequada à tarefa da thread;
• Cria-se uma instância da thread que recebe como argumentos um objeto que
implemente a interface Runnable. O objeto fornece o método run para a thread.
Threads são independentes pois possuem sua própria: (a) pilha de execução; (b)
contador de programa (program counter) e (c) variáveis locais. Porém, threads de um
mesmo processo compartilham memória, descritores de arquivos ( file handles) e outros
atributos que são específicos daquele processo.
Um processo pode conter múltiplas threads que parecem executar ao mesmo tempo
e de forma assíncrona em relação as outras threads. Todas as threads de um mesmo
processo compartilham o mesmo espaço de endereçamento de memória, o que significa
que elas tem acesso as mesmas variáveis e objetos, e que eles podem alocar novos
objetos de um mesmo heap. Ao mesmo tempo que isso torna possível que threads
compartilhem informações entre si, é necessário que o desenvolvedor se assegure que
uma thread não atrapalhe a execução de outra.
177
23. Sockets em Java
Socket é um mecanismo para comunicação de programas em dois sentidos que
funcionam em uma rede de computadores.
O pacote “java.net” possui duas classes principais: Socket (cliente) e
ServerSocket (servidor) quando uma conexão entre cliente-servidor é realizada.
O cliente solicita que uma conexão seja estabelida com o servidor através de
um Socket.
Quando o servidor aceita o pedido de conexão, ele cria um novo socket por uma
porta diferente. No cliente, outro socket é criado e então é utilizado para a
comunicação com este servidor.
A seguir
(liente).
são
vistos
dois
fontes:
Server.java
(Servidor)
// --------------------------------------------------------- Fonte: Server.java
import java.io.*;
import java.net.*;
class Server {
public static void main(String argv[]) throws Exception {
int n = 1;
String in; // string recebida do cliente
String out; // string enviada ao cliente
// cria socket de comunicacao com os clientes na porta 6789
ServerSocket welcomeSocket = new ServerSocket(6789);
// espera uma mensagem do cliente
while (true) {
System.out.print("Esperando comunicação: ");
// espera conexao do cliente
Socket connectionSocket = welcomeSocket.accept();
// cria ligação de entrada e saída com o cliente
BufferedReader inFromClient = new BufferedReader(
new InputStreamReader(connectionSocket.getInputStream()));
DataOutputStream outToClient =
new DataOutputStream(connectionSocket.getOutputStream());
// leitura da string do cliente
in = inFromClient.readLine();
// transforma a string em maiúsculas
out = in.toUpperCase() + '\n';
// envia a linha maiúscula ao cliente
outToClient.writeBytes(out);
// exibe o código do cliente
System.out.println(" Cliente [" + n + "]");
// exibe a mensagem recebida e respondida ao cliente
System.out.println("Mensagem Recebida: " + in);
System.out.print("Mensagem Respondida: " + out);
// número do cliente
n++;
}
}
}
// ------------------------------------------------------ Fonte: Client.java
import java.io.*;
import java.net.*;
178
e
Client.java
class Client {
public static void main(String argv[]) throws Exception {
String in; // string digitada
String out; // string recebida
// cria uma ligação com o teclado
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
// cria o socket de acesso ao server hostname ou localhost na porta 6789
//Socket clientSocket = new Socket("200.132.45.130", 6789);
Socket clientSocket = new Socket("localhost", 6789);
// cria ligações de entrada e saida com o servidor
DataOutputStream outToServer =
new DataOutputStream(clientSocket.getOutputStream());
BufferedReader inFromServer = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream()));
while (true) {
// leitura de uma linha do teclado e coloca na String in
System.out.print("Mensagem para Enviar [ou fim]: ");
in = inFromUser.readLine();
if (in.startsWith("fim") == true) {
break;
}
// envia uma string para o servidor
outToServer.writeBytes(in + '\n');
// leitura de uma string do servidor
out = inFromServer.readLine();
// exibe a linha do servidor na tela
System.out.println("Servidor respondeu: " + out);
}
// fecha o cliente
System.out.println("Conexão Fechada");
clientSocket.close();
}
}
Execução dos Programas:
Servidor:
MacBook-Pro-de-Paulo-Luzzardi:Java luzzardi$ javac Server.java
MacBook-Pro-de-Paulo-Luzzardi:Java luzzardi$ java Server
Esperando comunicação: Cliente [1]
Mensagem Recebida: Paulo Roberto Gomes Luzzardi
Mensagem Respondida: PAULO ROBERTO GOMES LUZZARDI
Esperando comunicação: Cliente [2]
Mensagem Recebida: Paola de Freitas Luzzardi
Mensagem Respondida: PAOLA DE FREITAS LUZZARDI
Esperando comunicação: Cliente [3]
Mensagem Recebida: Adriane Maria
Mensagem Respondida: ADRIANE MARIA
Esperando comunicação:
Cliente:
MacBook-Pro-de-Paulo-Luzzardi:Java luzzardi$ javac Client.java
MacBook-Pro-de-Paulo-Luzzardi:Java luzzardi$ java Client
Mensagem para Enviar [ou fim]: Paulo Roberto Gomes Luzzardi
Servidor respondeu: PAULO ROBERTO GOMES LUZZARDI
Mensagem para Enviar [ou fim]: fim
Conexão Fechada
MacBook-Pro-de-Paulo-Luzzardi:Java luzzardi$ java Client
Mensagem para Enviar [ou fim]: Paola de Freitas Luzzardi
Servidor respondeu: PAOLA DE FREITAS LUZZARDI
Mensagem para Enviar [ou fim]: fim
Conexão Fechada
MacBook-Pro-de-Paulo-Luzzardi:Java luzzardi$ java Client
179
Mensagem para Enviar [ou fim]: Adriane Maria
Servidor respondeu: ADRIANE MARIA
Mensagem para Enviar [ou fim]: fim
Conexão Fechada
MacBook-Pro-de-Paulo-Luzzardi:Java luzzardi$
180
24. Data e Hora em Java
Em Java é possível verificar a data e hora da máquina. Abaixo é visto várias
formas de imprimir na tela a data e horário.
// ------------------------------------------ Fonte: Data.java
package data;
import java.text.DateFormat;
import java.util.Date;
public class Data {
public static void main(String[] args) {
Date data = new Date();
System.out.println(data.toString());
System.out.println(DateFormat.getInstance().format(data));
System.out.println(DateFormat.getTimeInstance().format(data));
System.out.println(DateFormat.getDateTimeInstance().format(data));
System.out.println(DateFormat.getTimeInstance(DateFormat.SHORT).format(data));
System.out.println(DateFormat.getTimeInstance(DateFormat.MEDIUM).format(data));
System.out.println(DateFormat.getTimeInstance(DateFormat.LONG).format(data));
System.out.println(DateFormat.getDateTimeInstance(DateFormat.SHORT,
DateFormat.SHORT).format(data));
System.out.println(DateFormat.getDateTimeInstance(DateFormat.MEDIUM,
DateFormat.SHORT).format(data));
System.out.println(DateFormat.getDateTimeInstance(DateFormat.LONG,
DateFormat.LONG).format(data));
}
}
Resultado do Programa:
Mon Apr 26 01:43:16 BRT 2010
26/04/10 01:43
01:43:16
26/04/2010 01:43:16
01:43
01:43:16
1h43min16s BRT
26/04/10 01:43
26/04/2010 01:43
26 de Abril de 2010 1h43min16s BRT
181
25. Glossário em Java
Objetos são entidades lógicas que contém atributos (dados armazenados em
variáveis) e métodos (funções) que manipulam estes dados. Um objeto pode ser
definido através de um tipo de dado chamado classe (class).
f) Atributos: São as variáveis definidas e declaradas para cada objeto.
g) Métodos: São as funções definidas pelo programador que servirão para
manipular os atributos.
h) Mensagens: São as chamadas dos métodos.
i) Classe: É um tipo de dado definido por class. Uma classe não é um objeto, é
sim uma descrição do objeto.
j) Instância: Os objetos são instâncias de uma classe.
Resumidamente, objetos são instâncias de classes que respondem as mensagens
através dos métodos escritos pelo programador.
Outros conceitos importantes em linguagens orientadas à objetos são:
Applet: São programas Java que podem ser embutidos em documentos HTML ( Hypertext
markup Language). Quando o navegador carrega uma página Web que contém uma applet, o
applet é baixado para o navegador e então é executado.
Thread e multithreads: Forma de um processo dividir a si mesmo em duas ou mais
tarefas que podem ser executadas simultaneamente. É um fluxo de controle seqüencial
isolado dentro do programa. Uma thread tem começo, fim e uma seqüência de comandos.
Uma thread em Java não é um programa, pois não executa sozinha, ela executa dentro
de um programa. Threads permitem que um programa simples possa executar várias
tarefas diferentes ao mesmo tempo, independentemente umas das outras. Programas
multithreaded são programas que contém várias threads, executando tarefas distintas
simultaneamente.
Classe Base (superclasse): Define as características comuns a todos os objetos
derivados desta classe, ou seja, define atributos e métodos que serão passados as
classes derivadas.
classe derivada (subclasse): Classe oriunda de uma classe base. Herda todos os
métodos e atributos públicos ou protegidos da classe base.
Uma linguagem de programação orientada à objetos pode suportar até
6propriedades: abstração, encapsulamento, herança, polimorfismo, associação
(agregação e composição) e classes abstratas e concretas.
Abstração: Objetos devem representar dados do mundo real.
Polimorfismo (grego: “muitas formas”): É a capacidade de objetos diferentes
reagirem segundo a sua função a uma ordem padrão. Significa que o nome de um objeto
pode ser utilizado para vários propósitos ligeiramente diferentes, ou seja, “ ...
uma interface, vários métodos ... ”. A característica de polimorfismo é utilizada
na sobrecarga de métodos, sobrecarga de operadores e em classes abstratas e
concretas.
182

Sobrecarga de Operador: Permite sobrecarregar operadores para realizar
vários tipos de operações;

Sobrecarga de Método: Permite que um método retorne diferentes tipos de
informações e aceita argumentos de vários tipos, inclusive com número
diferentes de parâmetros;

Classes abstratas e concretas: Permite representar entidades e conceitos
abstratos, sendo sempre uma superclasse (ou classe Base) e não permite ser
instanciada, a classe abstrata apenas define um modelo (template) para uma
funcionalidade e fornece uma implementação incompleta que é herdada pelas
classes derivadas. Cada classe derivada implementa as funcionalidades da
classe abstrata. Uma classe abstrata pode possuir métodos abstratos, mas os
métodos são escritos nas classes derivadas concretas. Métodos abstratos
definem apenas a forma do método não contendo nenhum tipo de código. Classes
concretas implementam todos os métodos e podem ser instanciadas.
Herança: É o processo pelo qual uma classe de objetos pode adquirir as propriedades
de outra classe de objetos, em outras palavras, um objeto herda as características
de outro (herança simples) ou vários objetos (herança múltipla – Java não possui
herança múltipla).
Encapsulamento (encapsulação): Os objetos possuem internamente atribu-tos e métodos
agrupados no mesmo local, onde os métodos manipulam os atributos.
UML (Unified Modeling Language)
A linguagem UML especifica 9 tipos de diagramas para modelagem de sistemas
orientados à objetos. Cada diagrama UML permite modelar uma distinta característica
ou da estrutura ou do comportamento do sistema em especial. Os 4 primeiros, referemse a estrutura e os outros 5 ao comportamento do sistema.







Diagrama de Classes: Exibe o nome da classe, atributos e métodos que manipulam
os atributos.
Diagrama de Objetos: Exibe o conjunto de objetos e seus relaciona-mentos em
determinado ponto no tempo (comportamento estático).
Diagrama de Componentes: Exibe as dependências entre componentes do sistema. São
utilizados para: (a) modelar a organização do código fonte; (b) modelar a
chamada de programas externos; (c) modelar o banco de dados; (d) modelar
sistemas adaptativos e (e) Engenharia de produção e Engenharia reversa.
Diagrama de Instalação: Exibe a configuração dos nodos de processamento em tempo
de execução e os componentes existentes.
Diagrama de Atividades: São utilizados para detalhar classes, a implementação de
operações e casos de uso.
Diagrama de Mapa de Estados: Exibe o ciclo de vida de um objeto em níveis de
detalhe simples ou complexos. Mostra a seqüência de estados que um objeto ou a
interação percorrida durante sua vida em resposta a estímulos recebidos e as
próprias ações e respostas (comportamento dinâmico).
Diagrama de Colaborações: Modela as interações entre objetos. É focado na
seqüência cronológica de uma situação que está sendo modelado, focalizando no
relacionamento entre os objetos e na compreensão dos efeitos sobre um objeto
durante uma situação.
183


Diagrama de Sequência: Modela a interação entre objetos em um sistema. Apresenta
os objetos e as mensagens (métodos) que são passadas entre estes objetos dentro
do caso de uso.
Diagrama de Casos de Uso: Exibe os usuários e a relação entre os usuários e os
casos de uso.
Diagrama de Classe: Pilha e Fila
Figura 5: Exemplos de Diagrama de Classes
184
26. Curiosidades do Java
A seguir são vistas algumas curiosidades da linguagem Java:
Percorrendo um Vetor:
// -------------------------------------------------------- Fonte: Vetor.java
package vetor;
public class Vetor {
public static void main(String args[]) {
final int max = 9;
int [] vetor = new int[max];
for (int i = 0; i < max; i++) {
vetor[i] = i + 1;
}
for (int i : vetor) {
System.out.println(i);
}
}
}
ou
// --------------------------------------------- Fonte: Vetor.java
package vetor;
public class Vetor {
public static void main(String args[]) {
final int max = 9;
int [] vetor = new int[max];
for (int i = 0; i < max; i++) {
vetor[i] = i + 1;
}
exibeVetor(vetor);
}
// ---------------------------------------- exibeVetor
static void exibeVetor(int [] vetor) {
for (int i : vetor) {
System.out.println(“i = ” + i);
}
}
}
Operadores Lógicos:
Java possui os seguintes operadores lógicos para and e ou: (&&) (||) (&) (|).
Os operadores (&&) e (||) são conhecidos como Short Circuit Operator (operadores de
curto circuito), ou seja, são operadores mais rápidos que & e |, pois quando não
houver mais necessidade de testar as outras condições, o controle do programa passa
adiante.
185
186
27. Classe Object
Em Java, todas as classes, sem nenhuma exceção, herdam direta ou
indiretamente todos os métodos da classe Object, pois ela é a superclasse de
qualquer outra classe.
Pacote: java.lang.Object (não é necessário fazer a chamada implícita deste pacote)
// --------------------------------------------------------- Fonte: Objeto.java
package objeto;
public class Objeto {
public static void main(String[] args) throws Exception {
Object objeto = new Object();
objeto = "Paulo Roberto";
System.out.println("Objeto: " + objeto);
objeto = 48;
System.out.println("Objeto: " + objeto);
}
}
Resultado do Programa:
Objeto: Paulo Roberto
Objeto: 48
// ------------------------------------------------------- Fonte: Objeto.java
package objeto;
import java.util.Stack;
public class Objeto {
public static void main(String[] args) throws Exception {
Object objeto = new Object();
objeto = "Paulo Roberto";
System.out.println("Objeto String: " + objeto);
objeto = 48;
System.out.println("Objeto Inteiro: " + objeto);
Stack pilha = new Stack();
pilha.push(123);
objeto = pilha.pop();
System.out.println("Objeto Pilha: " + objeto);
Integer x = objeto.hashCode();
System.out.println("Valor: " + x);
}
}
Resultado do Programa:
Objeto
Objeto
Objeto
Valor:
String: Paulo Roberto
Inteiro: 48
Pilha: 123
123
// ----------------------------------------------------- Fonte: Objeto.java
package objeto;
import java.util.Scanner;
187
public class Objeto {
public static void main(String[] args) throws Exception {
Scanner entrada = new Scanner(System.in);
String s;
int n;
System.out.print("Numero de Objetos: ");
s = entrada.nextLine();
n = Integer.parseInt(s);
Object [] objeto = new Object[n];
// vetor de objetos
for (int i = 0;i < n;i++) {
System.out.print("Nome: ");
s = entrada.nextLine();
objeto[i] = s;
}
for (int i = n-1;i >= 0;i--) {
System.out.println("String: " + objeto[i]);
}
}
}
Resultado do Programa:
Número de Objetos: 4
Nome: paulo
Nome: roberto
Nome: gomes
Nome: luzzardi
String: luzzardi
String: gomes
String: roberto
String: paulo
A seguir são descritos os métodos da classe Object.
Sintaxe: protected Object clone();
Cria e retorna uma cópia deste objeto.
Sintaxe: boolean equals(Object obj);
Indica se um objeto é igual a outro.
Sintaxe: protected void finalize();
Chama o coletor de lixo do objeto quando a coletor de lixo determina que não há mais
referências ao objeto.
Sintaxe: Class getClass();
Retorna a classe “runtime” do objeto.
Sintaxe: int hashCode();
Retorna o valor do código “hash” de um objeto.
Sintaxe: void notify();
Aguarda uma thread que está esperando o monitor do objeto.
Sintaxe: void notifyAll();
Aguarda todas as threads que estão esperando o monitor do objeto.
Sintaxe: String toString();
188
Retorna uma String do objeto.
Sintaxe: void wait();
Faz a corrente thread esperar até que outra thread invoque os métodos notify() ou
notifyAll() deste objeto.
Sintaxe: void wait(long timeout);
Faz a corrente thread esperar até que outra thread invoque os métodos notify() ou
notifyAll() deste objeto ou um período especificado de tempo tiver decorrido.
Sintaxe: void wait(long timeout, int nanos);
Faz a corrente thread esperar até que outra thread invoque os métodos notify() ou
notifyAll() deste objeto, ou outra thread interrompa a corrente thread, ou um
período especificado de tempo tiver decorrido.
28. Classe ArrayDeque
Java possui classes pré-definidas para trabalhar com Deque: ArrayDeque,
LinkedBlockingDeque e LinkedList.
Construtores:
ArrayDeque()
Construi um deque em um array vazio com 16 elements.
ArrayDeque(int numElements);
Construi um deque em um array vazio com numElements elementos.
A seguir são descritos os métodos da classe ArrayDeque.
Sintaxe: boolean add(E e);
Insere um elemento especificado no fim do deque.
Sintaxe:
void addFirst(E e);
Insere um elemento especificado na frente do deque.
Sintaxe:
void addLast(E e);
Insere um elemento especificado no fim do deque.
Sintaxe:
void clear();
Remove todos os elementos deste deque.
Sintaxe:
ArrayDeque<E> clone();
Returna uma cópia deste deque.
Sintaxe:
boolean contains(Object o);
Returna true se este deque contém o elemento especificado.
Sintaxe:
Iterator<E> descendingIterator();
Returna um iterator sobre os elementos neste deque em ordem sequencial
reversa.
Sintaxe:
E element();
189
Recupera, mas não remove, o cabeça da fila representada por este deque.
Sintaxe:
E getFirst();
Recupera, mas não remove, o primeiro elemento deste deque.
Sintaxe:
E getLast();
Recupera, ams não remove, o último elemento deste deque.
Sintaxe:
boolean isEmpty();
Returna true se este deque não contém elementos.
Sintaxe:
Iterator <E> iterator();
Returna um iterator sobre os elementos deste deque.
Sintaxe:
boolean offer(E e);
Insere um elemento especificado no fim deste deque.
Sintaxe:
boolean offerFirst(E e);
Insere um elemento especificado na frente deste deque.
Sintaxe:
boolean offerLast(E e);
Insere um elemento especificado no fim deste deque.
Sintaxe:
E peek();
Recupera, mas não remove, o cabeça da fila representada por este deque ou
returna null se este deque está vazio.
Sintaxe:
E peekFirst();
Recupera, mas não remove, o primeiro elemento deste deque, ou retorna null
se este deque está vazio.
Sintaxe:
E peekLast();
Recupera, mas não remove, o último elemento deste deque ou returna null se
este deque está vazio.
Sintaxe:
E poll();
Recupera e remove o cabeça desta fila representada por este deque (em
outras palavras, o primeiro elemento deste deque) ou returna null se este deque está
vazio.
Sintaxe:
E pollFirst();
Recupera e remove o primeiro elemento deste deque ou returna null se este
deque está vazio.
Sintaxe:
E pollLast();
Recupera e remove o último elemento deste deque ou returna null se este
deque está vazio.
Sintaxe:
E pop();
Retira um elemento na pilha representada por este deque.
Sintaxe:
void push(E e);
Insere um elemento na pilha representada por este deque.
190
Sintaxe:
E remove();
Recupera e remove o cabeça da fila representada por este deque.
Sintaxe:
boolean remove(Object o);
Remove um instância simples de um elemento específico deste deque.
Sintaxe:
E removeFirst();
Recupera e remove o primeiro elemento deste deque.
Sintaxe:
boolean removeFirstOccurrence(Object o);
Remove a primeira ocorrência do elemento especificado deste deque (quando
percorre o deque da cabeça ao último).
Sintaxe:
E removeLast();
Recupera e remove o último elemento deste deque.
Sintaxe:
boolean removeLastOccurrence(Object o);
Remove a última ocorrência do elemento especificado neste deque (quando
percorre o deque da cabeça ao último).
Sintaxe:
int size();
Returna o número de elementos deste deque.
Sintaxe:
Object[] toArray();
Returna um array contendo todos os elementos deste deque em ordem
crescente (do primeiro até o último elemento).
Sintaxe: <T> T[] toArray(T[] a);
Returna um array contendo todos os elementos deste deque em ordem
crescente (do primeiro até o último elemento); o tipo do array retornado é aquela
especificado pelo array.
A seguir é demonstrado a utilização de um ArrayDeque.
Pacote: import java.util.ArrayDeque;
// -------------------------------------------------- Fonte: Array_Deque.java
package array_deque;
import java.util.ArrayDeque;
import java.util.Scanner;
public class Array_Deque {
public static void main(String[] args) {
ArrayDeque deque = new ArrayDeque();
Scanner entrada = new Scanner(System.in);
String s;
char tecla = 'f', op = 'f';
int nodo, n = 0;
Object temp;
// 16 elementos
do {
System.out.println("Deque: " + deque);
System.out.print("[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: ");
do {
s = entrada.nextLine();
if (!s.equals("")) {
191
tecla = s.charAt(0);
}
} while (!strChr("IiCcEeFf", tecla));
if (!strChr("Ff", tecla)) {
System.out.print("[E]squerda ou [D]ireita: ");
do {
s = entrada.nextLine();
if (!s.equals("")) {
op = s.charAt(0);
}
} while (!strChr("EeDd", op));
switch (tecla) {
case 'I':
case 'i': System.out.print("Nodo: ");
s = entrada.nextLine();
nodo = Integer.parseInt(s);
if (strChr("Ee", op)) {
deque.addFirst(nodo);
}
else {
deque.addLast(nodo);
}
n++;
if (n > 16) {
System.out.println("ERRO: Deque Cheio");
System.exit(1);
}
break;
case 'C':
case 'c': if (!deque.isEmpty()) {
if (strChr("Ee", op)) {
temp = deque.peekFirst();
}
else {
temp = deque.peekLast();
}
nodo = temp.hashCode();
System.out.println("Consultado: " + nodo);
}
else {
System.out.println("ERRO: Deque Vazio");
}
break;
case 'E':
case 'e': if (!deque.isEmpty()) {
if (strChr("Ee", op)) {
temp = deque.pollFirst();
}
else {
temp = deque.pollLast();
}
nodo = temp.hashCode();
System.out.println("Excluiu: " + nodo);
n--;
}
else {
System.out.println("ERRO: Deque Vazio");
}
break;
}
}
} while (!strChr("Ff", tecla));
}
// ----------------------------------------------- strChr
static boolean strChr(String s, char tecla) {
192
int n = s.length();
for (int i = 0;i < n;i++) {
if (s.charAt(i) == tecla) {
return(true);
}
}
return(false);
}
}
Resultado do Programa:
Deque: []
[I]ncluir, [C]onsultar, [E]xcluir
[E]squerda ou [D]ireita: e
Nodo: 10
Deque: [10]
[I]ncluir, [C]onsultar, [E]xcluir
[E]squerda ou [D]ireita: d
Nodo: 20
Deque: [10, 20]
[I]ncluir, [C]onsultar, [E]xcluir
[E]squerda ou [D]ireita: d
Nodo: 30
Deque: [10, 20, 30]
[I]ncluir, [C]onsultar, [E]xcluir
ou [F]inalizar: i
ou [F]inalizar: i
ou [F]inalizar: i
ou [F]inalizar: f
193
29. Formatar um double, float ou int
Pode-se utilizar o pacote java.text, classe DecimalFormat para imprimir um
double, float ou int de forma formatada. Veja o exemplo abaixo:
// ------------------------------------------------------- Format.java
package format;
import javax.swing.JOptionPane;
import java.text.DecimalFormat;
public class Format {
public static void main(String[] args) {
DecimalFormat decimalDouble = new DecimalFormat("0.00");
double d = 1.2345;
DecimalFormat decimalInteiro = new DecimalFormat("000");
int i = 12;
JOptionPane.showMessageDialog(null, "Decimal Double: " +
decimalDouble.format(d));
JOptionPane.showMessageDialog(null, "Decimal Inteiro: " +
decimalInteiro.format(i));
System.exit(0);
}
}
Resultado do Programa:
Decimal Double: 1,23
Decimal Inteiro: 012
194
30. Leitura e gravação de objetos (registro) em Arquivos
Em Java é possível ler e gravar dados organizados em registros. Um registro é um conjuntos de
campos, onde campos são qualquer tipo em Java.
public class Registro {
Object nome;
Object idade;
Object sexo;
}
nome
idade
sexo
30.1 Gravação de objetos em um arquivo binário de objetos
O programa abaixo permite gravar em um arquivo binário de objetos as seguintes informações:
nome, idade e sexo.
file.addFile("Paulo Roberto", 50, 'm');
file.addFile("Adriane Maria", 42, 'f');
file.addFile("Paola", 13, 'f');
// -------------------------------------------------------- Registro.java
package writefile;
public class Registro {
Object nome;
Object idade;
Object sexo;
Registro(String nome, int idade, char sexo) {
this.nome = nome;
this.idade = idade;
this.sexo = sexo;
}
}
// -------------------------------------------------------- FileObjeto.java
package writefile;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class FileObjeto {
// ------------------------------ atributos
String nomeFile;
private ObjectOutputStream fileOut;
FileObjeto(String nomeArquivo) {
nomeFile = nomeArquivo;
try {
fileOut = new ObjectOutputStream(new FileOutputStream(nomeFile));
System.out.println("Ok, Arquivo criado: " + nomeFile);
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Problema na criação do Arquivo: " + nomeFile);
}
}
195
// ------------------------------- addFile
public void addFile(String nome, int idade, char sexo)
throws IOException, ClassNotFoundException {
Registro registro = new Registro(nome, idade, sexo);
fileOut.writeObject(registro.nome);
fileOut.writeObject(registro.idade);
fileOut.writeObject(registro.sexo);
}
// ------------------------------- closeFile
public void closeFile() {
try {
if (fileOut != null) {
fileOut.close();
System.out.println("Ok, Arquivo fechado: " + nomeFile);
}
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile);
System.exit(1);
}
}
}
// -------------------------------------------------------- WriteFile.java
package writefile;
import java.io.IOException;
import java.util.Scanner;
public class WriteFile {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Scanner input = new Scanner(System.in);
System.out.print("Nome do Arquivo Binário: ");
String nomeArquivo = input.nextLine();
FileObjeto file = new FileObjeto(nomeArquivo);
file.addFile("Paulo Roberto", 50, 'm');
file.addFile("Adriane Maria", 42, 'f');
file.addFile("Paola", 13, 'f');
file.closeFile();
}
}
Resultado do Programa:
Nome do Arquivo Binário: /Users/pluzzardi/Objeto.dat
Ok, Arquivo criado: /Users/pluzzardi/Objeto.dat
Ok, Arquivo fechado: /Users/pluzzardi/Objeto.dat
Observação: Por questões didáticas, simplificação, não foi testado se o arquivo binário existe, ou
seja, se ele existir, será sobre-escrito.
Solução 2: Nesta solução o usuário digita os nomes, idades e sexo das pessoas.
// -------------------------------------------------------- Registro.java
package writefile2;
public class Registro {
Object nome;
Object idade;
196
Object sexo;
Registro(String nome, int idade, char sexo) {
this.nome = nome;
this.idade = idade;
this.sexo = sexo;
}
}
// -------------------------------------------------------- FileObjeto.java
package writefile2;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class FileObjeto {
// ------------------------------ atributos
String nomeFile;
private ObjectOutputStream fileOut;
FileObjeto(String nomeArquivo) {
nomeFile = nomeArquivo;
try {
fileOut = new ObjectOutputStream(new FileOutputStream(nomeFile));
System.out.println("Ok, Arquivo criado: " + nomeFile);
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Problema na criação do Arquivo: " + nomeFile);
}
}
// ------------------------------- addFile
public void addFile(Registro registro) throws IOException, ClassNotFoundException {
fileOut.writeObject(registro.nome);
fileOut.writeObject(registro.idade);
fileOut.writeObject(registro.sexo);
}
// ------------------------------- closeFile
public void closeFile() {
try {
if (fileOut != null) {
fileOut.close();
System.out.println("Ok, Arquivo fechado: " + nomeFile);
}
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile);
System.exit(1);
}
}
}
// -------------------------------------------------------- WriteFile2.java
package writefile2;
import java.io.IOException;
import java.util.Scanner;
public class WriteFile2 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
197
Scanner input = new Scanner(System.in);
char ch;
System.out.print("Nome do Arquivo: ");
String nomeArquivo = input.nextLine();
FileObjeto file = new FileObjeto(nomeArquivo);
do {
System.out.print("Nome: ");
String nome = input.nextLine();
System.out.print("Idade: ");
String s = input.nextLine();
int idade = Integer.parseInt(s);
System.out.print("sexo [M]asculino ou [F]eminino: ");
s = input.nextLine();
char sexo = s.charAt(0);
Registro registro = new Registro(nome, idade, sexo);
file.addFile(registro);
System.out.print("Continua [S/N]? ");
do {
s = input.nextLine();
ch = s.charAt(0);
} while (!strChr("SsNn", ch));
} while (strChr("Ss", ch));
file.closeFile();
}
// ------------------------------- strChr
static boolean strChr(String s, char ch) {
int n = s.length();
for (int i = 0;i < n;i++) {
if (s.charAt(i) == ch) {
return(true);
}
}
return(false);
}
}
Resultado do Programa:
Nome do Arquivo: /Users/pluzzardi/luz.dat
Ok, Arquivo criado: /Users/pluzzardi/luz.dat
Nome: Paulo Roberto
Idade: 51
sexo [M]asculino ou [F]eminino: m
Continua [S/N]? s
Nome: Renato Luis
Idade: 49
sexo [M]asculino ou [F]eminino: m
Continua [S/N]? s
Nome: Francisco Carlos
Idade: 53
sexo [M]asculino ou [F]eminino: m
Continua [S/N]? n
Ok, Arquivo fechado: /Users/pluzzardi/luz.dat
30.2 Leitura objetos em um arquivo binário de objetos
O programa abaixo permite carregar (ler) de um arquivo binário de objetos com as seguintes
informações: nome, idade e sexo.
// ------------------------------------- Registro.java
package readfile;
198
public class Registro {
Object nome;
Object idade;
Object sexo;
}
// ------------------------------------------------------- FileObjeto.java
package readfile;
import
import
import
import
java.io.FileInputStream;
java.io.IOException;
java.io.ObjectInputStream;
java.io.EOFException;
public class FileObjeto {
// ------------------------------ atributos
String nomeFile;
private ObjectInputStream fileIn;
// ------------------------------ construtor
FileObjeto(String nomeArquivo) {
nomeFile = nomeArquivo;
try {
fileIn = new ObjectInputStream(new FileInputStream(nomeFile));
System.out.println("Ok, Arquivo Aberto: " + nomeFile);
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Problema na Abertura do Arquivo: " + nomeFile);
System.exit(1);
}
}
// ------------------------------- getFile
public void getFile() throws IOException, ClassNotFoundException {
Registro registro = new Registro();
System.out.println("Nome
Idade Sexo");
try {
while (true) {
registro.nome = fileIn.readObject();
registro.idade = fileIn.readObject();
registro.sexo = fileIn.readObject();
System.out.printf("%-20s %2d
%c\n", registro.nome,
registro.idade, registro.sexo);
}
} catch (EOFException endOfFileException) {
}
}
// ------------------------------- closeFile
public void closeFile() {
try {
if (fileIn != null) {
fileIn.close();
System.out.println("Ok, Arquivo fechado: " + nomeFile);
}
} catch (IOException ioException) {
System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile);
System.exit(1);
}
}
}
199
// ------------------------------------------------------ ReadFile.java
package readfile;
import java.io.IOException;
import java.util.Scanner;
public class ReadFile {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Scanner input = new Scanner(System.in);
System.out.print("Nome do Arquivo Binário: ");
String nomeArquivo = input.nextLine();
FileObjeto file = new FileObjeto(nomeArquivo);
file.getFile();
file.closeFile();
}
}
Resultado do Programa:
Nome do Arquivo Binário: /Users/pluzzardi/Objeto.dat
Ok, Arquivo Aberto: /Users/pluzzardi/Objeto.dat
Nome
Idade Sexo
Paulo Roberto
50
m
Adriane Maria
42
f
Paola
13
f
Ok, Arquivo fechado: /Users/pluzzardi/Objeto.dat
ou
Nome do Arquivo: /Users/pluzzardi/luz.dat
Ok, Arquivo Aberto: /Users/pluzzardi/luz.dat
Nome
Idade Sexo
Paulo Roberto
51
m
Renato Luis
49
m
Francisco Carlos
53
m
Ok, Arquivo fechado: /Users/pluzzardi/luz.dat
200
31. Eliminar problemas de conversão na entrada de Dados
Como em qualquer outra linguagem de programação, um grave problema que ocorre em Java na
entrada de dados, via teclado, é quando o usuário digita letras (caracteres) numa entrada de números
(inteiros ou reais), pois mesmo que os dados lidos e armazenados no buffer de entrada sejam armazenados
em uma String, no momento da conversão para inteiro ou real, os métodos utilizados não permitem a
conversão e retornam erro em tempo de execução. Já foi visto anteriormente, que este problema pode ser
resolvido com tratamento de excessão, mas ainda pode-se resolver este problema com o método replaceALL,
ou seja, eliminar, antes da conversão, todos os caracteres que não são números de 0 à 9 e o sinal de
menos ‘-‘. Confira no programa abaixo esta forma de resolver o problema:
// EliminaErroEntrada.java // Marcos André Gerard Alves & Augusto Roschildt da Silva
package eliminaerroentrada;
import javax.swing.JOptionPane;
public class EliminaErroEntrada {
public static void main(String[] args) {
// entrada do usuário lida e armazenada em uma String
String s = JOptionPane.showInputDialog("Digite um Número:");
// método replaceAll elimina todos os caracteres que não são números ou “-“
s = s.replaceAll("[^0-9\\-.]", "");
// eliminação de caracteres
if (s.isEmpty()) {
System.out.println("ERRO: Problema na Conversão para Inteiro");
} else {
// conversão pode ser feita sem problemas, pois a String s não possui letras
int numero = Integer.parseInt(s);
JOptionPane.showMessageDialog(null, "Número: " + numero);
}
}
}
Observação: Note que o método replaceALL elimina todos os caracteres que não são números de dentro da
String s, deixando de fora apenas o sinal menos ‘-‘ e o ponto ‘.’.
Funcionamento: Todos os caracteres que não são números “[ˆ0-9\\-.]” são trocados por “”, ou seja,
são eliminados da String, exceto o sinal de menos ‘-‘ e o ponto ‘.’.
Outro problema que pode acontecer é que o usuário pode digitar o sinal de menos em qualquer
parte, ou seja, depois dos números, isto pode ser eliminado com o seguinte código, usando uma variável
boleana (sinal).
// EliminaErroEntrada3.java
package eliminaerroentrada3;
import javax.swing.JOptionPane;
public class EliminaErroEntrada3 {
public static void main(String[] args) {
boolean sinal = false;
String s = JOptionPane.showInputDialog("Digite um Número:");
if (s.contains("-")) {
// verifica se existe o sinal negativo
sinal = true;
}
s = s.replaceAll("[^0-9]", ""); // eliminar letras, inclusive o sinal de menos
if (s.isEmpty()) {
System.out.println("ERRO: Problema na Conversão para Inteiro");
} else {
int numero = Integer.parseInt(s);
if (sinal) {
numero = -numero; // converte o número para negativo
201
}
JOptionPane.showMessageDialog(null, "Número: " + numero);
}
}
}
O exemplo abaixo permite que o usuário digite ‘,’ (vírgula) no lugar do ponto, o método
verificaVirgula procura e troca a vírgula por ‘.’ (ponto).
package entradavirgula;
import javax.swing.JOptionPane;
public class EntradaVirgula {
public static void main(String[] args) {
String s;
do {
s = JOptionPane.showInputDialog("Digite um Número:");
s = s.replaceAll("[^0-9\\-.,]", ""); // eliminar letras, menos “-.,”
s = verificaVirgula(s);
} while (s.isEmpty());
double numero = Double.parseDouble(s);
JOptionPane.showMessageDialog(null, "Número: " + numero);
}
static String verificaVirgula(String s) {
char []r = s.toCharArray();
// converte string para um vetor de caracteres
int n = s.length();
for (int i = 0;i < n;i++) {
if (r[i] == ',') {
// procura por uma vírgula
r[i] = '.';
// troca vírgula por ponto
break;
}
}
s = "";
for (int i = 0;i < n;i++) { // reconverte o vetor de caracteres para String
s = s + r[i]; // concatena caracter em uma String
}
return(s);
}
}
202
32. Classe para Entrada de Inteiros e Reais em Java sem Erro na
Digitação
A seguir, são vistos dois programas em Java, cada um com as classes:
“EntradaDadosScanner” e “EntradaDadosSwing”, respectivamente, e que permitem a
entrada de dados via teclado de números inteiros (leInteiro) e reais (LeReal) sem
erro de conversão (Integer.parseInt e Double.parseDouble) por descuido na digitação
pelo usuário, ou seja, o usuário pode digitar qualquer coisa (em tese, por enquanto)
que os métodos da classe eliminam os erros de digitação.
Imagine a seguinte entrada de um inteiro e de um real em um programa Java com
este tipo de digitação (em vermelho):
Teste do Programa:
Digite um Inteiro: -123 de oliveira 4,.56—78 <enter>
Inteiro Digitado: 12345678
Digite um Real: -123,.,.45--,.56 <enter>
Real Digitado: 123.4556
Analise a resposta em letras azuis. O programa eliminou todos os caracteres
inválidos para um inteiro ou para um real, inclusive pontos (.) e vírgulas (,)
repetidas e o sinal negativo (-) no local indevido.
// ----------------------------------- Programa Principal: ProgEntradaDadosScanner.java
package progentradadadosscanner;
public class ProgEntradaDadosScanner {
public static void main(String[] args) {
EntradaDadosScanner entrada = new EntradaDadosScanner();
int inteiro = entrada.leInteiro("Digite um Inteiro: ");
System.out.println("Inteiro Digitado: " + inteiro);
Double real = entrada.leReal("Digite um Real: ");
System.out.println("Real Digitado: " + real);
}
}
// --------------------------------------------------- Classe: EntradaDadosScanner.java
package progentradaDados;
import java.util.Scanner;
public class EntradaDadosScanner {
// ------------------------------------------------------ métodos públicos da classe
// -------------------------------------------------- leInteiro
public int leInteiro(String mensagem) {
Scanner input = new Scanner(System.in);
String s;
int limite, n;
203
do {
System.out.print(mensagem);
s = input.nextLine();
s = s.replaceAll("[^0-9\\-]", ""); // eliminar letras e caracteres não numéricos
n = s.length();
if (n == 1 && s.charAt(0) == '-') {
s = "";
} else {
if (n > 0) {
s = retiraNegativosForaLugar(s);
if (s.charAt(0) == '-') {
limite = 11;
} else {
limite = 10;
}
if (n >= limite) {
s = verificaLimites(s);
}
}
}
} while (s.isEmpty());
int inteiro = Integer.parseInt(s); // conversão segura sem erros
return (inteiro);
}
// -------------------------------------------------- leReal
public double leReal(String mensagem) {
Scanner input = new Scanner(System.in);
String s;
do {
System.out.print(mensagem);
s = input.nextLine();
s = s.replaceAll("[^0-9\\-.,]", ""); // eliminar letras
s = verificaVirgulaPonto(s);
s = retiraNegativosForaLugar(s);
int n = s.length();
if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) {
s = "";
}
} while (s.isEmpty());
double real = Double.parseDouble(s);
// conversão segura sem erros
return (real);
}
// ----------------------------------------------------- métodos privados da classe
// -------------------------------------------------- verificaVirgulaPonto
private String verificaVirgulaPonto(String s) {
int pontos = 0;
char[] r = s.toCharArray();
int n = s.length();
for (int i = 0; i < n; i++) {
if (r[i] == ',' || r[i] == '.') {
r[i] = '.';
pontos++;
}
}
if (pontos > 1) {
r = retiraPontosRepetidos(r);
}
s = "";
for (int i = 0; i < r.length; i++) {
s = s + r[i];
}
return (s);
}
204
// -------------------------------------------------- retiraPontosRepetidos
private static char[] retiraPontosRepetidos(char[] s) {
int n = s.length;
String r = "";
boolean copiou = false;
int j = 0;
for (int i = 0; i < n; i++) {
if (s[i] != '.') {
r = r + s[i];
j++;
} else {
if (!copiou) {
r = r + '.';
copiou = true;
}
}
}
return (r.toCharArray());
}
// -------------------------------------------------- retiraNegativosForaLugar
private static String retiraNegativosForaLugar(String s) {
String r = "";
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) != '-' || i == 0) {
r = r + s.charAt(i);
}
}
return (r);
}
// -------------------------------------------------- verificaLimites
private static String verificaLimites(String s) {
String limiteInferior = "-2147483648";
String limiteSuperior = "2147483647";
if (s.compareTo(limiteInferior) > 0 || s.compareTo(limiteSuperior) > 0) {
System.out.println("ERRO: Excedeu o Limite dos Números Inteiros");
return ("");
}
return (s);
}
}
A seguir a outra versão utilizando o pacote swing.
// --------------------------------- Programa Principal: ProgEntradaDadosSwing.java
package progentradadadosswing;
import javax.swing.JOptionPane;
public class ProgEntradaDadosSwing {
public static void main(String[] args) {
EntradaDadosSwing entrada = new EntradaDadosSwing();
int inteiro = entrada.leInteiro("Digite um Inteiro: ");
JOptionPane.showMessageDialog(null, "Inteiro Digitado: " + inteiro);
Double real = entrada.leReal("Digite um Real: ");
JOptionPane.showMessageDialog(null, "Real Digitado: " + real);
}
}
// --------------------------------------------------- Classe: EntradaDadosSwing.java
205
package progentradadadosswing;
import javax.swing.JOptionPane;
public class EntradaDadosSwing {
// ----------------------------------------------------- métodos públicos da classe
// -------------------------------------------------- leInteiro
public int leInteiro(String mensagem) {
String s;
int n, limite;
do {
s = JOptionPane.showInputDialog(mensagem);
s = s.replaceAll("[^0-9\\-]", ""); // eliminar letras e caracteres não numéricos
n = s.length();
if (!(n == 1 && s.charAt(0) == '-')) {
if (n > 0) {
s = retiraNegativosForaLugar(s);
if (s.charAt(0) == '-') {
limite = 11;
} else {
limite = 10;
}
if (n >= limite) {
s = verificaLimites(s);
}
}
} else {
s = "";
}
} while (s.isEmpty());
int inteiro = Integer.parseInt(s);
return (inteiro);
}
// -------------------------------------------------- leReal
public double leReal(String mensagem) {
String s;
do {
s = JOptionPane.showInputDialog(mensagem);
s = s.replaceAll("[^0-9\\-.,]", ""); // eliminar letras
s = verificaVirgulaPonto(s);
s = retiraNegativosForaLugar(s);
int n = s.length();
if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) {
s = "";
}
} while (s.isEmpty());
double real = Double.parseDouble(s);
return (real);
}
// ----------------------------------------------------- métodos privados da classe
// -------------------------------------------------- verificaVirgulaPonto
private String verificaVirgulaPonto(String s) {
int pontos = 0;
char[] r = s.toCharArray();
int n = s.length();
for (int i = 0; i < n; i++) {
if (r[i] == ',' || r[i] == '.') {
r[i] = '.';
pontos++;
}
}
if (pontos > 1) {
206
r = retiraPontosRepetidos(r);
}
s = "";
for (int i = 0; i < r.length; i++) {
s = s + r[i];
}
return (s);
}
// -------------------------------------------------- retiraPontosRepetidos
private static char[] retiraPontosRepetidos(char[] s) {
int n = s.length;
String r = "";
boolean copiou = false;
int j = 0;
for (int i = 0; i < n; i++) {
if (s[i] != '.') {
r = r + s[i];
j++;
} else {
if (!copiou) {
r = r + '.';
copiou = true;
}
}
}
return (r.toCharArray());
}
// -------------------------------------------------- retiraNegativosForaLugar
private static String retiraNegativosForaLugar(String s) {
String r = "";
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) != '-' || i == 0) {
r = r + s.charAt(i);
}
}
return (r);
}
// -------------------------------------------------- verificaLimites
private static String verificaLimites(String s) {
String limiteInferior = "-2147483648";
String limiteSuperior = "2147483647";
if (s.compareTo(limiteInferior) > 0 || s.compareTo(limiteSuperior) > 0) {
JOptionPane.showMessageDialog(null, "ERRO: Excedeu o Limite dos Números Inteiros");
return ("");
}
return (s);
}
}
207
Download
Random flashcards
modelos atômicos

4 Cartões gabyagdasilva

Anamnese

2 Cartões oauth2_google_3d715a2d-c2e6-4bfb-b64e-c9a45261b2b4

paulo

2 Cartões oauth2_google_ddd7feab-6dd5-47da-9583-cdda567b48b3

Matemática

2 Cartões Elma gomes

Criar flashcards