Java: A Linguagem de Programação

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).
Pelotas, sexta-feira, 26 de maio de 2017 (17:58 pm)
1
Sumário
1. Arquitetura de um programa em Java ..................................................................................... 5
1.1 Elementos básicos de um programa em Java ......................................................... 5
1.2 Elementos básicos de um método estático ........................................................... 5
1.3 Como compilar um programa em Java via Terminal .......................................... 5
1.4 Como executar um programa em Java via Terminal .......................................... 5
1.5 Como executar um .jar em Java via Terminal .................................................... 5
1.6 Pasta contendo os projetos/arquivos em Java .................................................. 5
2. Estrutura de um programa em Java ......................................................................................... 6
2.1 Identificadores ..................................................................................................................... 6
2.2 Comentários do programador .......................................................................................... 6
2.3 Regras gerais para escrever um programa em Java ........................................ 7
2.4 Palavras reservadas do Java ........................................................................................ 8
2.5 Declaração de variáveis .................................................................................................. 8
2.5.1 Onde as variáveis podem ser declaradas ..................................................... 8
2.5.2 Inicialização de variáveis ................................................................................ 10
2.6 Constantes ............................................................................................................................... 10
2.6.1 Constantes hexadecimais e octais ................................................................. 10
2.6.2 Constantes Strings ................................................................................................... 11
2.6.3 Constantes especiais .............................................................................................. 12
2.7 Comandos do pré-processador do Java ................................................................... 12
2.7.1 O comando import ........................................................................................................ 12
3. Tipos de dados ................................................................................................................................... 13
3.1 Tipos básicos ........................................................................................................................ 13
3.2 Escrevendo uma classe em Java ................................................................................. 13
3.2.1 Conceitos básicos ......................................................................................................... 13
3.2.2 Referência this .............................................................................................................. 17
3.2.3 Lista de exercícios sobre Classes ................................................................... 17
3.3 Sobrecarga de métodos em Java ................................................................................. 30
4. Métodos de entrada e saída de dados ................................................................................ 31
4.1 Entrada de dados via teclado .................................................................................... 31
4.2 Saída de dados via tela ................................................................................................ 32
5. Operadores ............................................................................................................................................ 34
5.1 Operadores aritméticos .................................................................................................. 34
5.2 Operadores relacionais .................................................................................................. 34
5.3 Operadores lógicos ............................................................................................................ 34
5.4 Incremento e decremento ................................................................................................ 35
5.5 Operador de atribuição .................................................................................................. 35
5.6 Casts ........................................................................................................................................... 36
5.7 Expressões ............................................................................................................................... 37
6. Métodos para funções matemáticas padrões .................................................................... 38
6.1 Math.abs .................................................................................................................................... 38
6.2 Math.asin ................................................................................................................................. 38
6.3 Math.acos ................................................................................................................................. 38
6.4 Math.atan ................................................................................................................................. 38
6.5 Math.sin .................................................................................................................................... 38
6.6 Math.cos .................................................................................................................................... 38
6.7 Math.tan .................................................................................................................................... 39
6.8 Math.exp .................................................................................................................................... 39
6.9 Math.pow .................................................................................................................................... 39
6.10 Math.sqrt ............................................................................................................................... 39
6.11 Math.log ................................................................................................................................. 39
6.12 Double.parseDouble ......................................................................................................... 39
6.13 Integer.parseInt .............................................................................................................. 39
6.14 Long.parseLong ................................................................................................................... 39
2
6.15 Math.log10 ............................................................................................................................ 39
6.16 Math.random .......................................................................................................................... 40
6.17 Math.PI .................................................................................................................................... 40
6.18 Conversão de graus para radianos ........................................................................ 40
7. Comandos ................................................................................................................................................. 41
7.1 Tipos de comandos .............................................................................................................. 41
7.1.1 Sequência ........................................................................................................................ 41
7.1.2 Seleção ............................................................................................................................. 41
7.1.3 Repetição ........................................................................................................................ 42
7.2 Comando if ............................................................................................................................... 43
7.2.1 if encadeados ............................................................................................................... 44
7.3 O comando switch ................................................................................................................ 44
7.4 Comando while ........................................................................................................................ 47
7.5 O comando for ........................................................................................................................ 49
7.6 O loop do { } while ......................................................................................................... 50
7.7 Interrupção de loops ....................................................................................................... 51
7.7.1 O comando break .......................................................................................................... 51
7.7.2 O comando continue ................................................................................................... 52
7.8 O método System.exit () ................................................................................................ 53
8. Saída formatada (System.out.printf) ................................................................................ 53
9. Lista de exercícios (comandos) ............................................................................................ 55
10. Vetores, Matrizes e Strings ................................................................................................. 59
10.1 Vetores .................................................................................................................................... 59
10.2 Strings .................................................................................................................................... 60
10.3 Matrizes (Multidimensional) .................................................................................... 60
10.4 Vetor de Strings .............................................................................................................. 62
10.5 Inicialização de matrizes e vetores ................................................................ 62
10.6 Inicialização de um vetor de caracteres ....................................................... 62
10.7 Inicialização de matrizes multidimensionais ............................................. 62
10.8 Inicialização de vetores e matrizes sem tamanho .................................... 62
10.9 Classificação de dados ou ordenação (sort) ................................................ 64
10.10 Lista de exercícios (vetores) ............................................................................ 66
11. Manipulação de Strings ............................................................................................................. 69
11.1 Métodos para manipular Strings ............................................................................ 69
11.2 Lista de exercícios (Strings) ............................................................................... 73
12. Métodos estáticos definidos pelo programador ........................................................ 76
12.1 Valores de retorno ......................................................................................................... 78
12.2 Passagem de parâmetros por valor ........................................................................ 80
12.3 Passagem de parâmetros por referência ............................................................ 81
12.4 Métodos que devolvem valores não-inteiros .................................................. 81
12.5 Argumentos do main (String [] args) ................................................................ 82
12.6 Recursividade ..................................................................................................................... 84
12.7 Lista de Exercícios (métodos) ............................................................................... 85
13. Classes (Interface ou Coleção) existentes em Java (Container) ............... 89
14. Entrada e saída em disco (Arquivos) ............................................................................ 105
14.1 Métodos para manipular arquivos em Java ..................................................... 105
14.2 Abertura de um arquivo texto ............................................................................... 107
14.3 Listar um diretório ..................................................................................................... 108
14.4 Manipulação de um arquivo de palavras .......................................................... 109
14.5 Arquivo Texto ................................................................................................................... 112
14.6 Lista de exercícios (arquivos) .......................................................................... 117
14.7 Acesso randômico em arquivos texto ................................................................. 120
14.8 Arquivo binário de objetos em Java ................................................................. 121
15. Conceitos diversos em Java ................................................................................................. 123
15.1 Operadores bit a bit .................................................................................................. 123
15.2 Formas abreviadas de Java ...................................................................................... 124
3
16. Listas Lineares: Pilha, Fila e Fila Circular ...................................................... 125
16.1 Implementação de um lista em vetor ................................................................. 125
16.2 Implementação de uma Pilha .................................................................................... 128
16.3 Implementação de uma Fila ...................................................................................... 130
16.4 Implementação de uma Fila Circular ................................................................. 131
17. Tratamento de erros .................................................................................................................. 134
17.1 Tratamento de exceções .............................................................................................. 134
17.2 Tratamento de erros: Entrada de número inteiro via teclado ....... 135
17.3 Tratamento de erros: Divisão por zero .......................................................... 135
17.4 Tratamento de exceção com Exception .............................................................. 136
17.5 Tratamento de exceção com MyException .......................................................... 137
17.6 Exceção em ArrayList .................................................................................................. 137
17.7 Exceções criadas pelo programador ................................................................... 138
18. Herança em Java ............................................................................................................................ 141
18.1 Herança simples .............................................................................................................. 141
18.2 Controle de acesso na definição de uma classe derivada ................. 141
18.3 Tipos de acessos (especificadores de acesso) ......................................... 143
18.4 Lista de exercícios sobre Herança ................................................................... 145
18.4.1 Herança (primeiro) .................................................................................................. 145
18.4.2 Herança (segundo) ..................................................................................................... 146
18.4.3 Herança (terceiro) .................................................................................................. 147
19. Coletor de Lixo (Garbage Collector) ............................................................................ 150
20. Construtor e finalizador em Java ................................................................................... 151
21. Applets em Java ............................................................................................................................ 152
22. Threads em Java ............................................................................................................................ 156
23. Sockets em Java ............................................................................................................................ 157
24. Data e Hora em Java .................................................................................................................. 159
25. Glossário em Java ....................................................................................................................... 160
26. Curiosidades do Java ................................................................................................................ 163
27. Classe Object ................................................................................................................................. 164
28. Classe ArrayDeque ....................................................................................................................... 166
29. Formatar um double, float ou int ................................................................................... 170
30. Leitura e gravação de objetos (registro) em Arquivos ................................... 171
30.1 Gravação de objetos em um arquivo binário de objetos ...................... 171
30.2 Leitura objetos em um arquivo binário de objetos ............................... 174
31. Eliminar problemas de conversão na entrada de Dados ..................................... 176
32. Classe para Entrada de Inteiros e Reais em Java sem Erro na
Digitação .................................................................................................................................................... 178
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
Itálico: Código em Java
Negrito: Texto em destaque
Sublinado: Observações
4
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
// Windows
/home/pluzzardi/NetBeansProjects
// Linux – Ubuntu
5
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 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
6
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
dd/mm/aaaa].
(1):
Imprimir
a
data
no
seguinte
// -------------------------------------------- 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;
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);
}
7
formato:
[Data:
Resultado do Programa:
Data: 2/6/2013
// não formata a data
2.4 Palavras reservadas do Java
abstract
catch
do
final
implements
long
private
static
throw
void
const
boolean
break
char
class
double
else
finaly
float
import
instanceof
native
new
protected
public
super
switch
throws
transient
volatile
while
goto (não usadas)
byte
continue
extends
for
int
null
return
synchronized
true
case
default
false
if
interface
package
short
this
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)
ü
ü
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
8
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;
public class Prog2 {
// importar classe Scanner
// 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:
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
9
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'
1
123
123.23
"Java"
'9'
2100 -234
4.34e-3
(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;
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);
10
}
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’
4
‘c’
Figura 1: String
Vetor de Strings:
String [] s = {“Paulo”, “Roberto”, “Gomes”, “Luzzardi”};
Vetor de caracteres:
char [] s = {'U', 'C', 'P', 'e', 'l'};
11
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);
12
// 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.
ou
Uma linguagem de programação orientada à objetos pode suportar
implementar
seis
propriedades:
abstração,
encapsulamento,
13
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
}
}
Resultado do Programa:
Vetor: [10 20 30 40 50 ]
Erro: Vetor excedeu Limite
Vetor: [10 20 30 40 50 ]
14
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
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 instanciada, a classe abstrata apenas
define um modelo (template) para uma funcionalidade e fornece
uma implementação incompleta que é herdada pelas classes
15
operadores
para
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.
16
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
3.2.3.1 Dado o seguinte
Circulo e seus métodos:
programa
principal,
implemente
// ------------------------------------------ TestaCirculo.java
package testacirculo;
public class TestaCirculo {
public static void main(String[] args) {
17
a
classe
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
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);
18
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
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();
}
}
19
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
1
Segunda
Terça
2
3
Quarta
Quinta
4
5
6
Sexta
Sábado
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
20
Data
int dia, mes, ano
setaData
extenso
Diagrama de classe
3.2.3.6
Implemente os métodos “sortForcaBruta”
classe Vetor vista no item 3.2.
e
“bubleSort”
na
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');
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];
21
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)
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:
de Pessoas
Beatriz
Debora
Fátima
Geni
Carla
Eva
Idade:
Idade:
Idade:
Idade:
Idade:
Idade:
11
13
15
16
12
14
22
Nome:
Lista
Nome:
Nome:
Nome:
Nome:
Nome:
Nome:
Nome:
Ana
de Pessoas
Ana
Beatriz
Carla
Debora
Eva
Fátima
Geni
Idade: 10
Idade:
Idade:
Idade:
Idade:
Idade:
Idade:
Idade:
10
11
12
13
14
15
16
Pessoa
String [] nome
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;
23
public class TestVetor {
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) {
n--;
} else {
System.out.println("ERRO: Vetor Vazio");
}
}
// ------------------ removeElemento
24
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] + "]");
}
// ----------------- 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);
}
}
25
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);
}
}
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
26
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':
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;
// divisao 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;
// 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);
}
27
}
// ................................................ 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
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
28
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) {
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.
29
•
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.
// ------------------------------------------ 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
30
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).
Programa exemplo (10): Entrada de dados via teclado em terminal
textual usando as bibliotecas “BufferedReader” e “InputStreamReader“ .
31
// ----------------------------------------------- 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 o método
“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);
}
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
32
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
33
5. Operadores
São símbolos especiais que obrigam
determinadas
operações.
Estas
operações
comparativas ou lógicas.
o compilador a executar
podem
ser
aritméticas,
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,
utilizados principalmemte em comandos que possuem condições.
são
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
condição.
Exemplo:
operadores
utilizados
em
comandos
que
if (condição1 && condição2 || condição3)
Tabela 7: Operadores lógicos
Operador lógica
&& ou &
|| ou |
!
Ação
AND (e)
OR (ou)
NOT (não)
34
tem
mais
de
uma
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 que permitem realizar operações de
soma e subtração de forma simplificada.
ü
ü
++ 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 será 11
x = 10;
x = x + 1;
y = x;
x = 10;
y = x++;
//
//
y será 10
x será 11
x = 10;
y = x;
x = x + 1;
5.5 Operador de atribuição
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
35
=
=
=
=
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 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);
36
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 operadores
(aritméticos, relacionais, lógicos), constantes, variáveis e métodos.
Exemplo:
c = Math.sqrt (a) + b / 3.4;
37
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.
Sintaxe: double Math.cos (double x);
Faixa: -1 à 1
38
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
quadrada.
Math.sqrt
(square
root)
retorna
o
valor
da
raiz
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);
6.15 Math.log10
O método Math.log10 retorna o logarítmo na base 10.
Sintaxe: double Math.log10 (double x);
39
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;
40
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);
}
}
Resultado do Programa:
Digite um valor: 12 <enter>
Raiz Quadrada: 3,46
41
Operador Ternário (?):
Funcionamento: Se a condição for verdadeira, executa comando1 senão
executa comando2.
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.
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) {
42
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)
{
comando 1;
comando 2;
}
else
{
comando 3;
comando 4;
}
if (condição)
{
comando 1;
comando 2;
comando 3;
}
// 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
43
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",
"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.
44
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
constantes inteiras ou caracteres (int, char ou
encontrar uma coincidência, o programa executa o
comandos que estejam associados àquela constante.
executado se não houver nenhuma coincidência.
contra uma lista de
String). Depois de
comando ou bloco de
O comando default é
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;
case 6: JOptionPane.showMessageDialog(null, "Seis",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
case 7: JOptionPane.showMessageDialog(null, "Sete",
"Digito", JOptionPane.PLAIN_MESSAGE);
break;
45
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",
"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;
46
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 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, constantes, 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
47
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-e-ví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);
}
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:
A
B
C
D
E
48
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
Letra:
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:
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 {
49
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:
// --------------------------- Fonte: Prog24.java
i
i
i
i
=
=
=
=
1
2
3
4
–
–
j
j
j
j
=
=
=
=
9
8
7
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
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.
50
ü
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
i
i
i
i
i
i
i
i
i
=
=
=
=
=
=
=
=
=
=
1
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
51
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>
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) {
// 0 é par, 1 é impar
continue;
}
// imprime somente números pares
System.out.printf("Par: %d\n", i);
}
}
}
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.
52
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):
ü
ü
ü
(-)
não
com
(+)
(#)
Alinha o resultado à esquerda. Preenche o restante do campo com brancos. Se
é colocado, alinha o resultado à direita e preenche o restante à esquerda
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
53
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
54
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>
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
55
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>
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>
56
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>
Tipo de combustível [A]lcool, [G]asolina ou [D]iesel ? G <enter>
Tipo de pagamento [P]razo ou a [V]ista ? V <enter>
Total à prazo (R$) : 109.50
Desconto (R$): 5.48
Total à vista (R$): 104.02
Continua [S/N]? N <enter>
Álcool - 1,23
Gasolina - 2,19
Diesel - 1,46
Desconto à vista: 5%
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
Média
9,0 à 10,0
7,0 à 8,9
6,0 à 6,9
0,0 à 5,9
Nota1 + Nota2
Média = ----------------2
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:
Fórmula:
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>
Temperatura em Celsius: 30
Continua [S/N]? n <enter>
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 +
57
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]?
58
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)
59
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
String para um vetor de caracteres.
todos
os
caracteres
de
uma
// ----------------------------------------- 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
package prog28a;
import javax.swing.*;
public class Prog28a {
public static void main(String[] args) {
int n = entradaDados();
int [][] sena = new int [n][6];
60
}
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;
}
}
}
}
}
// --------------------------- 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);
}
}
}
61
"
+
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
compatíveis em tipo com o tipo base da matriz.
Exemplo:
int [] i = {0,1,2,3,4,5,6,7,8,9};
por
vírgulas
que
são
// 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
Exemplo:
= {lista_de_caracteres};
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.
62
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]);
}
}
}
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 {
63
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]);
}
}
}
}
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);
64
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]);
}
}
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;
65
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]);
}
}
}
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:
Letra:
Letra:
Letra:
Letra:
LIMA
AMIL
L
I
M
A
f
<enter>
<enter>
<enter>
<enter>
<enter>
10.10.2 Escreva um programa em Java que recebe via teclado: número de
idades e as respectivas idades. Armazene todas as idades em um vetor
(idade). Logo após a entrada de todas as idades, o programa deve
receber via teclado: idade para consulta. O programa deve imprimir na
tela, o número de idades antes da idade de consulta e o número de
idades depois da idade de consulta.
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):
66
Exemplo:
Número: 50 <enter>
Número: 30 <enter>
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”
30) nomes e idades. A entrada dos dados termina quando o
digitar 'N' ou 'n' na pergunta "Continua [S/N]?". Logo após a
de todos os dados o programa deve imprimir na tela todos os
idades desde o mais velho até o mais novo.
Exemplo:
Nome: Ana <enter>
Idade: 12 <enter>
Continua [S/N]? s <enter>
Nome: Beatriz <enter>
Idade: 13 <enter>
67
(máximo
usuário
entrada
nomes e
Continua [S/N]? s <enter>
Nome: Carla <enter>
Idade: 14 <enter>
Continua [S/N]? N <enter>
Carla
14
Beatriz
13
Ana
12
68
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
manipular objetos do tipo String.
principais
métodos
que
permitem
Sintaxe: char charAt(int index);
Retorna o caracter do índice especifiado.
Modo de usar:
String s = “Pelotas”;
ch = s.charAt(0);
// ch = ‘P’;
Onde: char ch;
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
maíusculas e minísculas.
diferenças
entre
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
sequência de caracteres do que a “StringBuffer” especificada.
a
mesma
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
minúsculas.
e
Sintaxe: byte[] getBytes();
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);
69
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 da
caracter especificado ou -1 se não encontrar.
ocorrência
do
Sintaxe: int indexOf(int ch, int fromIndex);
Retorna o índice dentro desta String da primeira ocorrência
caracter especificado, iniciando a busca no índice espeficidado.
do
Sintaxe: int indexOf(String str);
Retorna o índice dentro desta
substring especificada.
ocorrência
da
Sintaxe: int indexOf(String str, int fromIndex);
Retorna o índice dentro desta String da primeira ocorrência
substring especificada, iniciando a busca no índice espeficidado.
da
String
da
primeira
primeira
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.
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);
70
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 começando no
índice especificado.
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();
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 [[]”.
71
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;
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
for (int i = n-1;i >= 0;i--) {
System.out.print(s.charAt(i));
//
}
System.out.println();
do {
System.out.print("Continua [S/N]? ");
s = input.nextLine();
op = s.charAt(0);
} while ("SsNn".indexOf(op) == -1);
//
} while ("Ss".indexOf(op) != -1);
// } while
}
72
de caracteres da String s
acesso a cada caracter de s
verifica se op é “SsNn”
("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)
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
pergunta: Continua [S]im ou [N]ão?.
quando
o
usuário
digitar
“N”
ou
“n”
na
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>
73
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>
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>
74
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]?.
75
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
0.6698515942322978
Valor: 6
0.23904184275698248
Valor: 2
0.8321167764574124
Valor: 8
0.7770564673470854
Valor: 7
76
0.1130461920867929
Valor: 1
0.29725902364100654
Valor: 2
Chamada do método: n = random(10);
Programa exemplo (33):
calcula o inverso 1/x.
O
// retorna um número aleatório entre 0 e 9
programa
possui
um
método
// ---------------------------------------------- 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
77
estático
que
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 xy 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
simplesmente indica o sucesso ou o fracasso da manipulação.
valor
que
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.
// ------------------------------------------ Fonte: Prog35.java
package prog35;
import java.util.Scanner;
public class Prog35 {
78
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
procedimentos.
não
retornam
nenhum
valor,
ou
seja,
são
puramente
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
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);
79
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);
}
// ------------------------ 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
80
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};
// 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);
81
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 );
}
}
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
Operacional (uma palavra qualquer) e imprime a palavra em
inverso. O programa deve ser executado via terminal do
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) {
82
Sistema
sentido
Sistema
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$
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:
83
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.
// ------------------------------------------ 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
recursivamente.
(43):
O
programa
calcula
a
soma
// ------------------------------------------- Fonte: Prog43.java
84
de
um
número
package prog43;
import java.util.Scanner;
public class Prog43 {
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: ");
nome = entrada.nextLine();
n = numeroPalavras(nome);
System.out.printf("Seu nome tem %d palavra(s)\n", n);
85
}
// ---------------------------- 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
|
1
________________________
|
3
|
4
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;
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
}
86
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);
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:
87
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
88
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ção. Uma coleção é
composta de Interfaces e Implementações.
Interfaces
Figura 3: Arquitetura das Interfaces
Implementações
Sets(Conjuntos): HashSet, LinkedHashSet, TreeSet, EnumSet
Lists (Listas): Vector, Stack, LinkedSet, ArrayList
89
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
tamanho em um.
fim
do
Vetor,
aumentando
se
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
específica.
elementos
Sintaxe: void copyInto(Object[] anArray);
Copia os componentes do Vetor para o Array especificado.
Sintaxe: Object elementAt(int index);
Retorna o componente especificado pelo “index”.
Sintaxe: Enumeration elements();
Retorna uma enumeração dos componentes do Vetor.
Sintaxe: void ensureCapacity(int minCapacity);
90
da
coleção
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
Vetor.
do
objeto
especificado
no
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.
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.
91
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
especificada.
que
Sintaxe: Object set(int index, Object element);
Troca o elemento da posição especificada do
especificado.
contém
Vetor
com
a
coleção
o
elemento
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
correta.
os
elementos
no
Vetor
na
ordem
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,
elemento.
contendo
uma
representação
de
cada
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 {
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();
92
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 ",
"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();
}
}
93
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 {
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();
}
94
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);
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;
95
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.
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
especificado, ou -1 se a Lista não contém este elemento.
do
elemento
Sintaxe: int lastIndexOf (Object o);
Retorna o índice da lista da última ocorrência
especificado, ou -1 se a lista não contém este elemento.
do
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.
96
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.
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 (5): Exemplo de uma fila usando a classe “Queue” +
“LinkedList”.
// -------------------------------------- Fonte: Prog5.java
package Prog5;
import java.util.LinkedList;
import java.util.Queue;
import javax.swing.*;
public class Prog5 {
97
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);
}
}
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
usando algoritmo binário de busca.
Sintaxe: static int binarySearch(char[] a, char key);
Procura em um vetor de “char” especificado por um valor específico
usando algoritmo binário de busca.
Sintaxe: static int binarySearch(double[] a, double key);
98
Procura em um vetor de “double” especificado por um valor específico
usando algoritmo binário de busca.
Sintaxe: static int binarySearch(float[] a, float key);
Procura em um vetor de “float” especificado por um valor específico
usando algoritmo binário de busca.
Sintaxe: static int binarySearch(int[] a, int key);
Procura em um vetor de “int” especificado por um valor específico
usando algoritmo binário de busca.
Sintaxe: static int binarySearch(long[] a, long key);
Procura em um vetor de “long” especificado por um valor específico
usando algoritmo binário de busca.
Sintaxe: static int binarySearch(Object[] a, Object key);
Procura em um vetor de “Object” especificado por um valor específico
usando algoritmo binário de busca.
Sintaxe: static int binarySearch(short[] a, short key);
Procura em um vetor de “short” especificado por um valor específico
usando algoritmo binário de busca.
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”
iguais.
são
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
iguais.
“long
[]”
são
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.
99
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);
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 cada elemento da matriz de
“doubles”.
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);
100
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 cada elemento da matriz de
”Objects”.
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.
101
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);
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.
102
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.
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
package Prog7;
103
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
104
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
arquivos em Java:
descritos
os
principais
métodos
para
manipular
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”.
Sintaxe: File getCanonicalFile();
Retorna a forma canônica do “pathname”.
Sintaxe: String getCanonicalPath();
105
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
diretório.
por
este
caminho
(pathname)
é
um
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
modificado pela última vez.
indicado
por
este
caminho
foi
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.
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);
106
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 “pathname”, incluindo os diretórios
pai necessários, mas inexistentes.
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 {
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:
107
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
/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;
108
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
/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 um arquivo de palavras
(palavras.dat) permitindo a gravação destas palavras.
// --------------------------------------------- Fonte: Prog47.java
package prog47;
109
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 {
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();
110
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:
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) {
111
System.out.println("ERRO: Posição Inválida");
}
}
}
} while (pos != 0);
}
else {
System.out.println("ERRO: Arquivo não existe");
}
}
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
contendo:
é
mostrado
um
programa
que
lê
um
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);
112
arquivo
texto
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) {
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");
}
113
}
}
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:
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)
114
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:
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 {
115
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>
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]);
116
}
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)
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>
117
(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.
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>
118
Nome:
Nome:
Nome:
Nome:
Nome:
Debora <enter>
Carla <enter>
Fatima <enter>
Ana <enter>
<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:
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
119
Idade: 41
Sexo: MASCULINO
Nome: Renato Luis
Idade: 38
Sexo: MASCULINO
Nome: Ana Maria
Idade: 44
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");
}
}
120
}
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
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();
} catch (Exception e) {
System.out.println(e.toString());
}
}
}
Resultado do Programa:
Nome do Arquivo Binário: /Users/pluzzardi/pessoa.dat <enter>
121
ObjectOutputStream(new
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]
122
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).
123
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;
// a = 128 à binário -> 10000000
b = a >> 1;
// b = 64 à binário -> 0100000
c = b << 1;
// c = 128 àbinário -> 1000000
System.out.printf("a = %d\n",a);
System.out.printf("b = %d\n",b);
System.out.printf("c = %d\n",c);
}
}
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 ...
Esta forma abreviada
aritméticos de Java.
funcionará
com
x += 10;
todos
os
Forma normal:
variável = variável operador constante;
x = x + 7;
Forma abreviada:
variável operador= constante;
x += 7;
124
operadores
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
package prog50;
import javax.swing.*;
125
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
{
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.
126
// --------------------------------------------------------- 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;
}
}
} 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
127
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);
}
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
128
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
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
129
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
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;
130
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;
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;
131
import java.util.Scanner;
public class Prog54 {
public static void main(String[] args) {
FilaCircular fila = new FilaCircular(5);
Scanner entrada = new Scanner(System.in);
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);
}
else {
132
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
Valor: 10 <enter>
[I]ncluir, [E]xcluir
Valor: 20 <enter>
[I]ncluir, [E]xcluir
Valor: 30 <enter>
[I]ncluir, [E]xcluir
Valor: 40 <enter>
ERRO: Fila Cheia
[I]ncluir, [E]xcluir
Elemento Retirado da
[I]ncluir, [E]xcluir
Elemento Retirado da
[I]ncluir, [E]xcluir
Valor: 50 <enter>
[I]ncluir, [E]xcluir
Valor: 60 <enter>
[I]ncluir, [E]xcluir
Valor: 70 <enter>
ERRO: Fila Cheia
[I]ncluir, [E]xcluir
ou [F]im? i <enter>
ou [F]im? i <enter>
ou [F]im? i <enter>
ou [F]im? i <enter>
ou [F]im? e <enter>
Fila: 10
ou [F]im? e <enter>
Fila: 20
ou [F]im? i <enter>
ou [F]im? i <enter>
ou [F]im? i <enter>
ou [F]im? f <enter>
133
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
execução em caso que ocorra uma situação de erro não prevista.
da
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
interrompe a execução normal de um programa.
condição
anormal
que
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
}
17.1 Tratamento de exceções
134
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 da exceção ou “null” se a causa for
desconhecida ou não existir.
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
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
135
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;
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;
136
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;
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");
}
System.out.println("Divisao: " + div);
// não funcionou
}
}
17.6 Exceção em ArrayList
O programa abaixo mostra duas exceções: NumberFormatExcpetion e
IllegalArgumentException usando-se um ArrayList.
// ------------------------------------------------------ Fonte: arraylist.java
package arraylist;
import java.util.ArrayList;
import javax.swing.JOptionPane;
public class arraylist {
137
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
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
programador: 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);
}
}
138
pelo
// -------------------------------------------------------- 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();
}
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);
139
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):
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
140
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 é:
141
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);
}
}
142
// ---------------------------------------------------------- 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):
utilização
de
herança
protegidos).
O objetivo do programa é demonstrar a
simples
(atributos
da
classe
base
são
// ---------------------------------------------------------- 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 {
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);
}
143
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
chamada ao construtor padrão da classe-pai.
faz uma
// ------------------------------------------------------------ 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);
}
base
public int Somador(int soma) {
return(x + y + z);
// é possível acessar x e y pois são privados a classe
}
protected void finalize() {
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 {
144
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
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();
}
}
145
// ----------------------------------------------------------------------- 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);
}
}
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;
146
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
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);
147
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;
}
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
148
149
19. Coletor de Lixo (Garbage Collector)
O Java possui um coletor de lixo automático, mas pode-se chamálo 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 = null; // marca para coletor de
System.gc();
// chamada do coletor de
System.out.println("Somador (x + y + z):
" + objeto.Somador(resp));
lixo
lixo
" + 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:
Observação: O erro se deve ao objeto ter sido
desalocado pelo coletor
de lixo
z = 3
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
150
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;
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
151
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();
}
// -------------------------------------------- paint
public void paint(Graphics g) {
int erro = calc.retornaErro();
super.paint(g);
g.drawString("Calculadora 1.0 by Luzzardi", 300, 270);
152
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;
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;
// divisão por zero
else
resp = divisao(x, y);
break;
if (x < 0)
erro = 2;
// raiz negativa
153
else
case 'P':
case 'p':
case 'S':
case 's':
case 'C':
case 'c':
case 'T':
case 't':
resp = raizQuadrada(x);
break;
resp = power(x, y);
break;
resp = seno(x);
break;
// Raiz Quadrada
// 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
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
154
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:
$ javac Calculadora.java <enter>
$ javac CalcApplet.java <enter>
$
// é gerado Calculadora.class
// é gerado CalcApplet.class
Para testar a Applet:
$ appletviewer CalcApplet.html <enter>
$
155
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.
156
23. Sockets em Java
Socket é um mecanismo para comunicação de programas
sentidos que funcionam em uma rede de computadores.
em
dois
O pacote “java.net” possui duas classes principais: Socket
(cliente) e ServerSocket (servidor) quando uma conexão entre clienteservidor é 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 são vistos
Client.java (liente).
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.*;
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
157
e
}
//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
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$
158
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
159
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.
•
Sobrecarga de Operador: Permite sobrecarregar
realizar vários tipos de operações;
160
operadores
para
•
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 atributos 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, referem-se 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 relacionamentos 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.
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.
161
Diagrama de Classe: Pilha e Fila
Figura 5: Exemplos de Diagrama de Classes
162
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.
163
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;
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();
164
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();
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.
165
28. Classe ArrayDeque
Java possui classes pré-definidas para
ArrayDeque, LinkedBlockingDeque e LinkedList.
trabalhar
com
Deque:
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();
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.
166
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.
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).
167
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;
do {
// 16 elementos
System.out.println("Deque: " + deque);
System.out.print("[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: ");
do {
s = entrada.nextLine();
if (!s.equals("")) {
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;
168
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) {
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
169
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
170
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);
}
// ------------------------------- 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);
}
171
// ------------------------------- 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;
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
172
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 {
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) {
173
+
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;
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 {
174
}
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);
}
}
}
// ------------------------------------------------------ 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
175
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
}
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).
176
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);
}
}
177
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;
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 = "";
178
}
} 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);
}
// -------------------------------------------------- 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());
179
}
// -------------------------------------------------- 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
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);
}
180
}
} 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) {
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);
}
}
181
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);
}
}
182