1

Java: A Linguagem de Programação

por

Prof. Dr. Paulo Roberto Gomes Luzzardi

facebook: Paulo Roberto Gomes Luzzardi WhatsApp: 991648037

e-mail: pluzzardi@gmail.com e pluzzardi@yahoo.com.br

e-mail (Senac): prgomesluzzardi@senacrs.edu.br

DropBox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m

Hostinger: http://pluzzardi.w.pw e http://pluzzardi.zz.mu (Home Page)

Versão 1.73 10-11-2018

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, sábado, 10 de setembro de 2018 (7:31 am)

2

Sumário

1. ARQUITETURA DE UM PROGRAMA EM JAVA 6 1.1 ELEMENTOS BÁSICOS DE UM PROGRAMA EM JAVA 6 1.2 ELEMENTOS BÁSICOS DE UM MÉTODO ESTÁTICO 6 1.3 COMO COMPILAR UM PROGRAMA EM JAVA VIA TERMINAL 6 1.4 COMO EXECUTAR UM PROGRAMA EM JAVA VIA TERMINAL 6 1.5 COMO EXECUTAR UM .JAR EM JAVA VIA TERMINAL 6 1.6 PASTA CONTENDO OS PROJETOS/ARQUIVOS EM JAVA 6

2. ESTRUTURA DE UM PROGRAMA EM JAVA 7 2.1 IDENTIFICADORES 7 2.2 COMENTÁRIOS DO PROGRAMADOR 7 2.3 REGRAS GERAIS PARA ESCREVER UM PROGRAMA EM JAVA 8 2.4 PALAVRAS RESERVADAS DO JAVA 9 2.5 DECLARAÇÃO DE VARIÁVEIS 9

2.5.1 Onde as variáveis podem ser declaradas 9 2.5.2 Inicialização de variáveis 11

2.6 CONSTANTES 11 2.6.1 Constantes hexadecimais e octais 11 2.6.2 Constantes Strings 12 2.6.3 Constantes especiais 13

2.7 COMANDOS DO PRÉ-PROCESSADOR DO JAVA 13 2.7.1 O comando import 13

3. TIPOS DE DADOS 14 3.1 TIPOS BÁSICOS 14 3.2 ESCREVENDO UMA CLASSE EM JAVA 14 3.2.1 CONCEITOS BÁSICOS 14 3.2.2 REFERÊNCIA THIS 17 3.2.3 LISTA DE EXERCÍCIOS SOBRE CLASSES 18 3.3 SOBRECARGA DE MÉTODOS EM JAVA 31

4. MÉTODOS DE ENTRADA E SAÍDA DE DADOS 32 4.1 ENTRADA DE DADOS VIA TECLADO 32 4.2 SAÍDA DE DADOS VIA TELA 33

5. OPERADORES 35 5.1 OPERADORES ARITMÉTICOS 35 5.2 OPERADORES RELACIONAIS 35 5.3 OPERADORES LÓGICOS 35 5.4 INCREMENTO E DECREMENTO 36 5.5 OPERADOR DE ATRIBUIÇÃO 36 5.6 CASTS 37 5.7 EXPRESSÕES 38

6. MÉTODOS PARA FUNÇÕES MATEMÁTICAS PADRÕES 39 6.1 MATH.ABS 39 6.2 MATH.ASIN 39 6.3 MATH.ACOS 39 6.4 MATH.ATAN 39 6.5 MATH.SIN 39 6.6 MATH.COS 39 6.7 MATH.TAN 39 6.8 MATH.EXP 40 6.9 MATH.POW 40

3

6.10 MATH.SQRT 40 6.11 MATH.LOG 40 6.12 DOUBLE.PARSEDOUBLE 40 6.13 INTEGER.PARSEINT 40 6.14 LONG.PARSELONG 40 6.15 MATH.LOG10 40 6.16 MATH.RANDOM 40 6.17 MATH.PI 41 6.18 CONVERSÃO DE GRAUS PARA RADIANOS 41

7. COMANDOS 42 7.1 TIPOS DE COMANDOS 42

7.1.1 Sequência 42 7.1.2 Seleção 42 7.1.3 Repetição 44

7.2 COMANDO IF 45 7.2.1 if encadeados 46

7.3 O COMANDO SWITCH 46 7.4 COMANDO WHILE 50 7.5 O COMANDO FOR 52 7.6 O LOOP DO { } WHILE 53 7.7 INTERRUPÇÃO DE LOOPS 54

7.7.1 O comando break 54 7.7.2 O comando continue 55

7.8 O MÉTODO SYSTEM.EXIT () 57 8. SAÍDA FORMATADA (SYSTEM.OUT.PRINTF) 57

9. LISTA DE EXERCÍCIOS (COMANDOS) 59

10. VETORES, MATRIZES E STRINGS 63 10.1 VETORES 63 10.2 STRINGS 64 10.3 MATRIZES (MULTIDIMENSIONAL) 64 10.4 VETOR DE STRINGS 66 10.5 INICIALIZAÇÃO DE MATRIZES E VETORES 66 10.6 INICIALIZAÇÃO DE UM VETOR DE CARACTERES 66 10.7 INICIALIZAÇÃO DE MATRIZES MULTIDIMENSIONAIS 66 10.8 INICIALIZAÇÃO DE VETORES E MATRIZES SEM TAMANHO 67 10.9 CLASSIFICAÇÃO DE DADOS OU ORDENAÇÃO (SORT) 68 10.10 LISTA DE EXERCÍCIOS (VETORES) 70

11. MANIPULAÇÃO DE STRINGS 73 11.1 MÉTODOS PARA MANIPULAR STRINGS 73 11.2 LISTA DE EXERCÍCIOS (STRINGS) 77

12. MÉTODOS ESTÁTICOS DEFINIDOS PELO PROGRAMADOR 80 12.1 VALORES DE RETORNO 82 12.2 PASSAGEM DE PARÂMETROS POR VALOR 84 12.3 PASSAGEM DE PARÂMETROS POR REFERÊNCIA 85 12.4 MÉTODOS QUE DEVOLVEM VALORES NÃO-INTEIROS 85 12.5 ARGUMENTOS DO MAIN (STRING [] ARGS) 86 12.6 RECURSIVIDADE 88 12.7 LISTA DE EXERCÍCIOS (MÉTODOS) 89

13. CLASSES (INTERFACE OU COLEÇÃO) EXISTENTES EM JAVA (CONTAINER) 93

4

14. ENTRADA E SAÍDA EM DISCO (ARQUIVOS) 109 14.1 MÉTODOS PARA MANIPULAR ARQUIVOS EM JAVA 109 14.2 ABERTURA DE UM ARQUIVO TEXTO 111 14.3 LISTAR UM DIRETÓRIO 111 14.4 MANIPULAÇÃO DE UM ARQUIVO DE PALAVRAS 113 14.5 ARQUIVO TEXTO 116 14.6 LISTA DE EXERCÍCIOS (ARQUIVOS) 121 14.7 ACESSO RANDÔMICO EM ARQUIVOS TEXTO 124 14.8 ARQUIVO BINÁRIO DE OBJETOS EM JAVA 125

15. CONCEITOS DIVERSOS EM JAVA 128 15.1 OPERADORES BIT A BIT 128 15.2 FORMAS ABREVIADAS DE JAVA 129

16. LISTAS LINEARES: PILHA, FILA E FILA CIRCULAR 130 16.1 IMPLEMENTAÇÃO DE UM LISTA EM VETOR 130 16.2 IMPLEMENTAÇÃO DE UMA PILHA 134 16.3 IMPLEMENTAÇÃO DE UMA FILA 135 16.4 IMPLEMENTAÇÃO DE UMA FILA CIRCULAR 136

17. TRATAMENTO DE ERROS 140 17.1 TRATAMENTO DE EXCEÇÕES 140 17.2 TRATAMENTO DE ERROS: ENTRADA DE NÚMERO INTEIRO VIA TECLADO 141 17.3 TRATAMENTO DE ERROS: DIVISÃO POR ZERO 141 17.4 TRATAMENTO DE EXCEÇÃO COM EXCEPTION 142 17.5 TRATAMENTO DE EXCEÇÃO COM MYEXCEPTION 143 17.6 EXCEÇÃO EM ARRAYLIST 143 17.7 EXCEÇÕES CRIADAS PELO PROGRAMADOR 144

18. HERANÇA EM JAVA 147 18.1 HERANÇA SIMPLES 147 18.2 CONTROLE DE ACESSO NA DEFINIÇÃO DE UMA CLASSE DERIVADA 147 18.3 TIPOS DE ACESSOS (ESPECIFICADORES DE ACESSO) 149 18.4 LISTA DE EXERCÍCIOS SOBRE HERANÇA 151 18.4.1 HERANÇA (PRIMEIRO) 151 18.4.2 HERANÇA (SEGUNDO) 152 18.4.3 HERANÇA (TERCEIRO) 153

19. COLETOR DE LIXO (GARBAGE COLLECTOR) 156

20. CONSTRUTOR E FINALIZADOR EM JAVA 157

21. APPLETS EM JAVA 159

22. THREADS EM JAVA 163

23. SOCKETS EM JAVA 164

24. DATA E HORA EM JAVA 166

25. GLOSSÁRIO EM JAVA 167

26. CURIOSIDADES DO JAVA 170

27. CLASSE OBJECT 171

28. CLASSE ARRAYDEQUE 173

5

29. FORMATAR UM DOUBLE, FLOAT OU INT 177

30. LEITURA E GRAVAÇÃO DE OBJETOS (REGISTRO) EM ARQUIVOS 178 30.1 GRAVAÇÃO DE OBJETOS EM UM ARQUIVO BINÁRIO DE OBJETOS 178 30.2 LEITURA OBJETOS EM UM ARQUIVO BINÁRIO DE OBJETOS 181

31. ELIMINAR PROBLEMAS DE CONVERSÃO NA ENTRADA DE DADOS 184

32. CLASSE PARA ENTRADA DE INTEIROS E REAIS EM JAVA SEM ERRO NA DIGITAÇÃO 186

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

6

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) { // método principal corpo_do_programa; System.exit(0); // 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

7

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

8

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(), ou seja, o método principal. As principais regras são:

ü Letras maiúsculas e minúsculas são tratadas como caracteres diferentes; ü O formato do texto é livre; ü O método main(){} especifica onde o programa começa e termina de ser executado; ü Todos os comandos são terminados por ponto e vírgula; ü Todas as variáveis devem ser declaradas; ü { método começa a ser executado; ü } método termina de ser executado.

Programa exemplo (1): Imprimir a data no seguinte formato: [Data: dd/mm/aaaa]. // -------------------------------------------- Fonte: Prog1.java package prog1; public class Prog1 { public static void main(String[] args) { int dia, mes, ano; dia = 31; mes = 8; ano = 2018; System.out.printf("Data: %02d/%02d/%04d\n", dia, mes, ano); } } Resultado do Programa: Data: 31/08/2018 // formata os campos da data ou // -------------------------------------------- Fonte: Prog1.java package prog1; public class Prog1 { public static void main(String[] args) { int dia = 31; int mes = 8; int ano = 2018; System.out.println("Data: " + dia + "/" + mes + "/" + ano); } } Resultado do Programa: Data: 31/8/2018 // não formata a data

9

2.4 Palavras reservadas do Java abstract boolean break byte case catch char class continue default do double else extends false final finaly float for if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient true try void volatile while const goto (não usadas) 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 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;

10

import java.util.Scanner; // importar classe Scanner public class Prog2 { // definição da classe Prog2 static double resultado; // variável global public static void main(String[] args) { // definição das variáveis locais Scanner entrada = new Scanner (System.in); String s; double base, expoente; // método que permite imprimir na tela em modo texto System.out.print("Base: "); // método que permite entrada de dados via teclado em terminal texto s = entrada.nextLine(); // método que converte String em double base = Double.parseDouble(s); System.out.print("Expoente: "); s = entrada.nextLine(); expoente = Double.parseDouble(s); // chamada do método POT resultado = POT(base, expoente); // método que imprime na tela com formatação do número System.out.printf("Resposta = %7.2f\n", resultado); } // ---------------------------------- método estático POT static double POT (double x, double y) { // corpo do método POT definido pelo programador // os argumentos x e y são variáveis locais // definição de uma variável local double resp; resp = Math.exp(Math.log(x) * y); return(resp); // retorno do método } } Resultado do Programa: 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 $ Executar por linha de comandos (via terminal): $ java Prog2 <enter> // executa o arquivo Prog2.class

11

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 'a' 'n' '9' int 1 123 2100 -234 float 123.23 4.34e-3 String "Java" (classe String)

2.6.1 Constantes hexadecimais e octais A linguagem de programação Java permite especificar constantes inteiras em octal. Uma constante octal começa com um 0 (zero) antes dos demais números. Exemplos: int hexadecimal = 0xf; // 15 em decimal int octal = 011; // 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); System.out.println("Hexadecimal: " + hexaDecimal); // int hexaToDecimal = Integer.parseInt(hexaDecimal, 16);

12

// System.out.println("Hexadecimal para Decimal: " + hexaToDecimal); } } } Resultado do Programa: Decimal: 0 Hexadecimal: 0 Decimal: 1 Hexadecimal: 1 Decimal: 2 Hexadecimal: 2 Decimal: 3 Hexadecimal: 3 Decimal: 4 Hexadecimal: 4 Decimal: 5 Hexadecimal: 5 Decimal: 6 Hexadecimal: 6 Decimal: 7 Hexadecimal: 7 Decimal: 8 Hexadecimal: 8 Decimal: 9 Hexadecimal: 9 Decimal: 10 Hexadecimal: a Decimal: 11 Hexadecimal: b Decimal: 12 Hexadecimal: c Decimal: 13 Hexadecimal: d Decimal: 14 Hexadecimal: e Decimal: 15 Hexadecimal: f Decimal: 16 Hexadecimal: 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 1 2 3 4 ‘S’ ‘e’ ‘n’ ‘a’ ‘c’

Figura 1: String Vetor de Strings:

String [] s = {“Paulo”, “Roberto”, “Gomes”, “Luzzardi”}; Vetor de caracteres:

char [] ch = {'S', 'e', 'n', 'a', 'c'};

13

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

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 encontra-se 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); // chamada de métodos estáticos

Constante Significado ‘\b’ Retrocesso ‘\f’ Alimentação de formulário ‘\n’ Nova linha ‘\r’ Retorno de carro <CR> ‘\t’ Tab horizontal ‘\”’ Aspas duplas ‘\’’ Aspas simples ‘\\’ Barra invertida ‘\o’ Constante octal ‘\x’ Constante hexadecimal

14

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

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. Uma linguagem de programação orientada à objetos pode suportar ou implementar seis propriedades: abstração, encapsulamento, polimorfismo, herança, associação (agregação e composição) e classes abstratas e concretas.

Tipo Bytes Bits Faixa de valores boolean 1 8 true ou false

char 2 16 0 à 65.535 byte 1 8 -128 à 127 short 2 16 -32.768 à 32.767

int 4 32 -2.147.483.648 à 2.147.483.647 long 8 64 -2E63 à 2E63 float 4 32 1.40239846e-46 à 3.40282347e+38

double 8 64 4.94065645841246544e-324 à 1.7976931348623157e+308

15

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); // testar o limite do vetor de 5 elementos v.exibe(); } } Resultado do Programa: Vetor: [10 20 30 40 50 ] Erro: Vetor excedeu Limite Vetor: [10 20 30 40 50 ]

Tente implementar os seguintes métodos para a classe Vetor:

16

v.remove(); v.exibe(); System.out.println("Total de Elementos: " + v.length()); int pri = v.primeiro(); System.out.println("Primeiro: " + pri); int ult = v.ultimo(); System.out.println("Último: " + ult); boolean flag = v.existe(20); if (flag) { System.out.println("Existe elemento 20"); } else { System.out.println("Não Existe elemento 20"); }

v.removeElemento(elemento); v.exibe(); v.removePosicao(1); v.exibe(); Uma linguagem de programação orientada à objetos pode suportar e/ou implementar seis (6) propriedades: abstração, encapsulamento, polimorfismo, herança, associação (agregação e composição) e classes abstratas e concretas. Abstração Objetos devem representar dados do mundo real. Encapsulamento (“encapsulação”) Os objetos possuem internamente atributos e métodos agrupados no mesmo local, onde os métodos manipulam os atributos. Esta característica protege os dados (atributos) de alterações indevidas, somente os membros da classe podem acessar os atributos, desde que eles sejam privados (private) ou protegidos (protected) (caso das classes derivadas, que herdam o direito de acesso aos atributos). Polimorfismo (grego: “muitas formas”)

É a capacidade de objetos diferentes reagirem segundo a sua função a uma ordem padrão. Significa que o nome de um objeto pode ser utilizado para vários propósitos ligeiramente diferentes, ou seja, “ ... uma interface, vários métodos ... ”. A característica de polimorfismo é utilizada principalmente na sobrecarga de métodos, sobrecarga de operadores e nas classes abstratas, onde os métodos são declarados mas não definidos. Como tipos de polimorfismo tem-se: (a) Universal (inclusão [como em Java, por exemplo, List lista = new LinkedList();] e paramétrico [templates como em C++]) e (b) ad-hoc (sobrecarga de métodos e operadores). Java não possui sobrecarga de operadores.

• Sobrecarga de Operador: Permite sobrecarregar operadores para realizar diferentes tipos de operações;

• Sobrecarga de Método: Permite que um método retorne diferentes tipos de informações e

aceite argumentos de vários tipos, inclusive com quantidade diferentes de argumentos;

• Classes abstratas e concretas: Permite representar entidades e conceitos abstratos, sendo sempre uma superclasse (ou classe Base) e não permite ser 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.

17

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.

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;

18

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 programa principal, implemente a classe Circulo e seus métodos: // ------------------------------------------ TestaCirculo.java package testacirculo; public class TestaCirculo { public static void main(String[] args) { Circulo circ = new Circulo(); circ.setaRaio(3); circ.calculaArea(); double area = circ.getArea(); System.out.printf("Área: %.2f\n", area); } } Observação: area = pi . raio2 onde pi é 3.1416

Circulo private double area, raio

setRaio(raio) void calculaArea() double getArea()

Diagrama de classe

19

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); 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

20

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 2 3 4 5 6 7 8 9 0 x x x x x x x x x x 11 10 9 8 7 6 5 4 3 2 -- -- -- -- -- -- -- -- -- -- 11 + 20 + 27 + 32 + 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(); } } 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.

21

A fórmula (válida para datas entre 1901 e 2099) é a seguinte: Dia_do_Seculo = (ano - 1901) * 365 + (ano - 1901) DIV 4 + dia + (mês - 1) *31 - [(mês * 4 + 23) DIV 10] * [(mês + 12) DIV 15] + [(4 - ano MOD 4) DIV 4) * [(mês + 12) DIV 15] Entrada: Dia [1..31]: 18 Mês [1..12]: 12 Ano [1901..2099]: 2007 Dia_do_Seculo = 39.068 (para a data acima) Verificação do Dia da Semana: Para saber o Dia_da_Semana basta dividir por 7 e entrar com o resto na tabela abaixo: 0 Segunda

1 Terça

2 Quarta

3 Quinta

4 Sexta

5 Sábado

6 Domingo Resultado do Programa: 18/12/2007 é uma Terça-Feira Observação: DIV é divisão inteira de dois números e MOD é o resto inteiro da divisão de dois números 3.2.3.5 Dado o seguinte programa principal, implemente a classe Data e seus métodos: // ------------------------------------------------- TestData.java package testdata; public class TestData { public static void main(String[] args) { Data data = new Data(); data.setaData(4, 9, 2011); data.extenso(); } } Resultado do Programa: Data: 4 de setembro de 2011

Data

int dia, mes, ano setaData extenso

Diagrama de classe 3.2.3.6 Implemente os métodos “sortForcaBruta” e “bubleSort” na classe Vetor vista no item 3.2. v.sortForcaBruta(); v.exibe(); v.bubbleSort(); v.exibe();

3.2.3.7 Dado o seguinte programa principal, implemente a classe Pessoa e seus métodos. // --------------------------------------------------- TestaPessoa.java package testapessoa;

22

public class TestaPessoa { public static void main(String[] args) { Pessoa p1 = new Pessoa(); Pessoa p2 = new Pessoa(); Pessoa p3 = 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]; 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:

23

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 de Pessoas Nome: Beatriz Idade: 11 Nome: Debora Idade: 13 Nome: Fátima Idade: 15 Nome: Geni Idade: 16 Nome: Carla Idade: 12 Nome: Eva Idade: 14 Nome: Ana Idade: 10 Lista de Pessoas Nome: Ana Idade: 10 Nome: Beatriz Idade: 11 Nome: Carla Idade: 12 Nome: Debora Idade: 13 Nome: Eva Idade: 14 Nome: Fátima Idade: 15 Nome: Geni Idade: 16

Pessoa String [] nome

int [] idade int n

insereDados exibeDados

24

sort Diagrama de classe 3.2.3.10 Dado o seguinte programa principal, implemente a classe Agenda e seus métodos. // ------------------------------------------------------- TestAgenda.java package testagenda; public class TestAgenda { public static void main(String[] args) { Agenda agenda = new Agenda(5); agenda.insereTelefone("Ana", "99811234"); agenda.insereTelefone("Beatriz", "99812345"); agenda.insereTelefone("Carla", "99813456"); agenda.insereTelefone("Debora", "99814567"); agenda.insereTelefone("Eva", "99815678"); agenda.insereTelefone("Fátima", "99816789"); String fone = "99815678"; String nome = agenda.consultaNome(fone); if (nome.compareTo("") != 0) { System.out.println("Nome: " + nome + " - Telefone: " + fone); } else { System.out.println("ERRO: Usuário não Encontrado"); } fone = "99810123"; nome = agenda.consultaNome(fone); if (nome.compareTo("") != 0) { System.out.println("Nome: " + nome + " - Telefone: " + fone); } else { System.out.println("ERRO: Usuário não Encontrado"); } } } Resultado do Programa: ERRO: Excedeu limite do Vetor Nome: Eva - Telefone: 99815678 ERRO: Usuário não Encontrado

Agenda

String [] nome String [] fone

int n int max

insereTelefone consultaNome

Diagrama de classe A seguir o programa teste (TestVetor) proposto anteriormente: // ------------------------------------------------- TestVetor.java package testvetor; public class TestVetor { 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);

25

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 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--;

26

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); } } Resultado do Programa: Vetor: [10 20 30 40]

27

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) { // construtor da classe dia = dd; mes = mm; ano = aa; } // ------------------------------- 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 () { // construtor erro = 0; } // ---------------------------- entradaDados

28

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 '+': resp = soma(x, y); break; case '-': resp = subtracao(x, y); break; case '*': resp = multiplicacao(x, y); break; case '/': if (y == 0) erro = 1; // divisao por zero else resp = divisao(x, y); break; case 'R': case 'r': if (x < 0) erro = 2; // raiz negativa else resp = raizQuadrada(x); // Raiz Quadrada break; case 'P': case 'p': resp = power(x, y); // potencia break; case 'S': case 's': resp = seno(x); // seno break; case 'C': case 'c': resp = cosseno(x); // cosseno break; case 'T': case 't': 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",

29

"Calculadora", JOptionPane.PLAIN_MESSAGE); break; default: JOptionPane.showMessageDialog(null, "Resposta: " + resp,

"Calculadora", JOptionPane.PLAIN_MESSAGE); } } // ................................................ métodos privados da classe // ---------------------------- strChr private boolean strChr(String s, char ch) { for (int i = 0; i < s.length(); i++) { if (s.charAt(i) == ch) { return(true); } } return(false); } // ---------------------------- soma private double soma(double x, double y) { return(x + y); } // ---------------------------- subtracao private double subtracao(double x, double y) { return(x - y); } // ---------------------------- multiplicacao 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

30

private double cosseno(double x) { final double pi = 3.14158; double rads; rads = x * pi / 180.0; return(Math.cos(rads)); } // ---------------------------- tangente private double tangente(double x) { final double pi = 3.14158; double rads; rads = x * pi / 180.0; return(Math.tan(rads)); } } Programa exemplo que utiliza a classe “Calculadora”: // ---------------------------------------------- Fonte: Calc.java package calc; public class Calc { public static void main(String[] args) { 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>

31

Modificadores de Acesso:

• public: Os atributos e métodos tornam-se públicos, ou seja, qualquer outro método pode chamar ou utilizar estes atributos e/ou métodos.

• private: Somente os métodos da classe (membros) da classe podem chamar ou utilizar

atributos ou métodos privados.

• protected: Utilizado em herança simples de classe (construção de subclasses), ou seja, uma subclasse herda todos os atributos e métodos da classe base (superclasse). Deixa acessível os atributos e/ou métodos para todas as outras classes (classe base) e subclasses (classe derivada).

3.3 Sobrecarga de métodos em Java

Java permite que métodos estáticos sejam sobrecarregados, desta forma, o retorno, número de argumentos ou mesmo o tipo de dados dos argumentos possam ser diferentes.

// ------------------------------------------ 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

32

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(); // ou x = input.nextInt(); int x = Integer.parseInt(s); System.out.println("Valor: " + x); } } 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("Digite um número Inteiro: "); 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“ .

33

// ----------------------------------------------- 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”.

34

// ------------------------------------------ Fonte: Prog12.java package Prog12; import javax.swing.*; // carrega toda a biblioteca swing public class Prog12 { public static void main(String[] args) { String s; s = JOptionPane.showInputDialog("String: "); int x = Integer.parseInt(s); JOptionPane.showMessageDialog(null, "Inteiro: " + x, "Resultado", JOptionPane.PLAIN_MESSAGE); } } Sintaxe: JOptionPane.showMessageDialog(null, “x = ” + x, “Título”, JOptionPane.PLAIN_MESSAGE); null significa que a mensagem será centralizada “x = “ + x significa que sairá na caixa de dialogo x = 5 (por exemplo) “Título” significa o título da caixa de diálogo JOptionPane.PLAIN_MESSAGE significa caixa sem ícone

Tabela 3: Tipos de Ícones

Tipo de Ícone Tipo de Mensagem Ícone de erro JOptionPane.ERROR_MESSAGE Ícone de informação “i” JOptionPane.INFORMATION_MESSAGE Ícone de advertência “!” JOptionPane.WARNING_MESSAGE Ícone de pergunta “?” JOptionPane.QUESTION_MESSAGE Sem ícone JOptionPane.PLAIN_MESSAGE

35

5. Operadores São símbolos especiais que obrigam o compilador a executar determinadas operações. Estas operações podem ser aritméticas, comparativas ou lógicas.

5.1 Operadores aritméticos São operadores que realizam uma operação matemática.

Tabela 4: Operadores aritméticos

Operador aritmético Ação - Subtração + Adição * Multiplicação / Divisão % Resto inteiro da divisão

-- ++ Decremento/incremento Precedência dos operadores aritméticos (Hierarquia nas Operações)

Tabela 5: Precedência dos operadores aritméticos

Hierarquia Operação 1 Parênteses 2 Métodos 3 ++ -- 4 - (menos unário) 5 * / % 6 + -

Observação: Quando houver duas ou mais operações de mesma hierarquia, o compilador executa-as da esquerda para a direita.

5.2 Operadores relacionais São operadores que permitem comparar valores, ou seja, são utilizados principalmemte em comandos que possuem condições.

Tabela 6: Operadores relacionais

Operador Ação > Maior que

>= Maior ou igual a < Menor que

<= Menor ou igual == Igual a != Diferente de

5.3 Operadores lógicos São operadores utilizados em comandos que tem mais de uma condição. Exemplo: if (condição1 && condição2 || condição3)

36

Tabela 7: Operadores lógicos Operador lógica Ação

&& ou & AND (e) || ou | OR (ou)

! NOT (não) Observação: && e || são chamados Short Circuit Operator, ou seja, quando o resultado das condições não puder mais ser alterado, há um truncamento nas próximas condições. Precedência (Hierarquia dos operadores)

Tabela 8: Precedência dos operadores relacionais e lógicos

Hierarquia Operação 1 ! 2 > >= < <= 3 == != 4 && 5 ||

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 será 11 x = 10; y = ++x; // x será 11 x = x + 1; y = x; x = 10; // y será 10 x = 10; y = x++; // x será 11 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:

37

variável = constante; x = 3; variável = variável; x = y; variável = expressão; x = a + b; variável = método(x); x = 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

38

package Prog14; import java.util.Scanner; public class Prog14 { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); String s; int x, y; float resp; System.out.print("x = "); s = entrada.nextLine(); x = Integer.parseInt(s); System.out.print("y = "); s = entrada.nextLine(); y = Integer.parseInt(s); // é necessário um cast (float) pois a divisão de dois resp = (float) x / y; // inteiros resulta em um inteiro System.out.printf("Divisao = %.2f\n", resp); } } Resultado do Programa: x = 3 <enter> y = 4 <enter> Divisao = 0,75 Observação: Em Java, o tipo resultante de um inteiro dividido por outro inteiro é um inteiro, logo, deve-se utilizar um cast (float) para que o tipo resultante atribuído a variável resp seja float.

5.7 Expressões Uma expressão em Java é qualquer combinação válida de operadores (aritméticos, relacionais, lógicos), constantes, variáveis e métodos. Exemplo: c = Math.sqrt (a) + b / 3.4;

39

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

6.7 Math.tan O método Math.tan retorna o valor da tangente. A variável x deve estar em radianos.

40

Sintaxe: double Math.tan (double x);

6.8 Math.exp

O método Math.exp retorna o valor do expoente (ex). Sintaxe: double Math.exp (double x);

6.9 Math.pow

O método Math.pow (power) retorna o valor da potência (xy). Sintaxe: double Math.pow (double x, double y);

6.10 Math.sqrt O método Math.sqrt (square root) retorna o valor da raiz quadrada. Sintaxe: double Math.sqrt (double x);

6.11 Math.log O método Math.log retorna o valor do logaritmo natural. Sintaxe: double Math.log (double x);

6.12 Double.parseDouble O método Double.parseDouble converte string em ponto flutuante. Sintaxe: double Double.parseDouble (String s);

6.13 Integer.parseInt O método aInteger.parseInt converte uma string em inteiro. Sintaxe: int Integer.parseInt (String s);

6.14 Long.parseLong O método Long.parseLong converte uma string em inteiro longo. Sintaxe: long Long.parseLong (String s);

6.15 Math.log10 O método Math.log10 retorna o logarítmo na base 10. Sintaxe: double Math.log10 (double x);

6.16 Math.random

41

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) { // gera um número de 1 até n int num = 1 + (int)(Math.random() * n); return(num); }

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;

42

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

43

44

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 um Valor: 45 <enter> Digite outro Valor: 34 <enter> menor: 34 maior: 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;

45

public class Prog16 { public static void main(String[] args) { final int n = 10; int i = 0; do { System.out.println("n = " + i); i++; } while (i < n); } } Resultado do Programa: n = 0 n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 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) { if (condição) { comando 1; comando; } ou } else { comando 2; }

Observação: O else é opcional. Se a condição for avaliada como verdadeira (qualquer valor diferente de 0), o comando 1 será executado, caso contrário (condição falsa, valor igual a zero) o comando 2 será executado. Comando 1, comando 2 ou comando podem ser simples ou compostos (quando há mais de um comando ligado a outro, deve-se utilizar chaves ({ }). Veja exemplos abaixo if (condição) if (condição) { { comando 1; comando 1; comando 2; comando 2; } comando 3; else } { comando 3; comando 4; // todos os comando são compostos

}

46

Programa exemplo (17): O usuário digita um número e o programa diz se este é par ou ímpar. // ------------------------------------------- Fonte: Prog17.java package prog17; import javax.swing.*; public class Prog17 { public static void main(String[] args) { String s; int numero; s = JOptionPane.showInputDialog("Digite um número: "); numero = Integer.parseInt(s); if ((numero % 2) == 0) { JOptionPane.showMessageDialog(null, "Número é PAR", "Números", JOptionPane.PLAIN_MESSAGE); } else { JOptionPane.showMessageDialog(null, "Número é IMPAR", "Números", JOptionPane.PLAIN_MESSAGE); } } } 7.2.1 if encadeados Um if aninhado (ou encadeado) é um comando if dentro de outro comando if ou if ... else. Programa exemplo (18): O usuário digita um número e o programa diz se este é zero, positivo ou negativo. // -------------------------------------------- Fonte: Prog18.java package prog18; import javax.swing.*; public class Prog18 { public static void main(String[] args) { String s; int num; s = JOptionPane.showInputDialog("Digite um número: "); num = Integer.parseInt(s); if (num == 0) { JOptionPane.showMessageDialog(null, "Número é Zero", "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

47

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.

48

Sintaxe: switch (variável) { case constante_1 : seqüência de comandos; break; case constante_2 : seqüência de comandos; break; . . . default: seqüência de comandos; } O programa testa uma variável sucessivamente contra uma lista de constantes inteiras ou caracteres (int, char ou String). Depois de encontrar uma coincidência, o programa executa o comando ou bloco de comandos que estejam associados àquela constante. O comando default é executado se não houver nenhuma coincidência. O comando break é utilizado para obrigar a saída do comando switch. A opção default é opcional. Observação: A variável não pode ser real (float ou double). Programa exemplo (19): O programa recebe um dígito de 0 à 9 e imprime na tela, este dígito, por extenso. Neste exemplo a variável dígito é inteira. // ---------------------------------------------- Fonte: Prog19.java package prog19; import javax.swing.*; public class Prog19 { public static void main(String[] args) { String s; int digito; s = JOptionPane.showInputDialog("Digito: "); digito = Integer.parseInt(s); switch (digito) { case 0: JOptionPane.showMessageDialog(null, "Zero", "Digito", JOptionPane.PLAIN_MESSAGE); break; case 1: JOptionPane.showMessageDialog(null, "Um", "Digito", JOptionPane.PLAIN_MESSAGE); break; case 2: JOptionPane.showMessageDialog(null, "Dois", "Digito", JOptionPane.PLAIN_MESSAGE); break; case 3: JOptionPane.showMessageDialog(null, "Três", "Digito", JOptionPane.PLAIN_MESSAGE); break; case 4: JOptionPane.showMessageDialog(null, "Quatro", "Digito", JOptionPane.PLAIN_MESSAGE); break; case 5: JOptionPane.showMessageDialog(null, "Cinco", "Digito", JOptionPane.PLAIN_MESSAGE); break; case 6: JOptionPane.showMessageDialog(null, "Seis", "Digito", JOptionPane.PLAIN_MESSAGE); break; case 7: JOptionPane.showMessageDialog(null, "Sete", "Digito", JOptionPane.PLAIN_MESSAGE);

49

break; case 8: JOptionPane.showMessageDialog(null, "Oito", "Digito", JOptionPane.PLAIN_MESSAGE); break; case 9: JOptionPane.showMessageDialog(null, "Nove", "Digito", JOptionPane.PLAIN_MESSAGE); break; default: JOptionPane.showMessageDialog(null, "ERRO: Não é um Dígito", "Digito", JOptionPane.PLAIN_MESSAGE); } } } Programa exemplo (20): O programa recebe um dígito de 0 à 9 e imprime na tela, este dígito, por extenso. Neste exemplo a variável dígito é caracter, por causa disto as constantes estão entre apostrofes. // ----------------------------------------- Fonte: prog20.java package prog20; import javax.swing.*; public class Prog20 { public static void main(String[] args) { String s; char digito; s = JOptionPane.showInputDialog("Digito: "); digito = s.charAt(0); switch (digito) { case '0': JOptionPane.showMessageDialog(null, "Zero", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '1': JOptionPane.showMessageDialog(null, "Um", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '2': JOptionPane.showMessageDialog(null, "Dois", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '3': JOptionPane.showMessageDialog(null, "Três", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '4': JOptionPane.showMessageDialog(null, "Quatro", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '5': JOptionPane.showMessageDialog(null, "Cinco", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '6': JOptionPane.showMessageDialog(null, "Seis", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '7': JOptionPane.showMessageDialog(null, "Sete", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '8': JOptionPane.showMessageDialog(null, "Oito", "Digito", JOptionPane.PLAIN_MESSAGE); break; case '9': JOptionPane.showMessageDialog(null, "Nove", "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.

50

// ------------------------------------------ Fonte: prog21.java package prog21; import java.util.Scanner; public class Prog21 { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); String s; char opcao; System.out.println("[I]nclusão"); System.out.println("[A]lteração"); System.out.println("[T]érmino"); System.out.print("Qual a opção: "); s = entrada.nextLine(); opcao = s.charAt(0); switch (opcao) { case 'i': case 'I': inclusao(); break; case 'a': case 'A': alteracao(); break; case 't': case 'T': termino(); break; default: System.out.println("ERRO: Opção Inválida"); } } static void inclusao() { System.out.println("Opção Escolhida: Inclusão"); } static void alteracao() { System.out.println("Opção Escolhida: Alteração"); } static void termino() { System.out.println("Opção Escolhida: Término"); } }

7.4 Comando while O comando while é um comando de repetição que permite executar um comando (simples) ou vários comandos (composto) diversas vezes. Isto é feito através da avaliação de uma condição. Enquanto a condição for verdadeira os comandos são repetidos. Quando a condição se tornar falsa o comando while é finalizado. O teste 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) { ou while (condição) comando; { } comando 1; comando 2; }

51

Condição: Qualquer expressão válida em Java com resultado 0 (false) ou !0 (true). Na condição podem ser utilizados ainda variáveis, constan-tes, métodos, operadores (aritméticos, relacionais e lógicos). Funcionamento do comando: O loop (laço) é repetido enquanto a condição for verdadeira. Quando a condição se tornar falsa o controle do programa passa para a próxima instrução. O laço while verifica a condição no início do laço, por causa disto, normalmente, a variável de controle do laço deve ser inicializado. Exemplo: int i = 0; // inicialização da variável de controle while (i <= 10) { // condição i <= 10 System.out.printf(“i = %d\n”, i); i = i + 1; // incremento } Comando: Pode ser um comando vazio, simples ou composto que serão repetidos. Comando vazio: while (1); // comando while não repete nenhum comando for (int i = 0; i <= 1000; i++); // comando for não repete nenhum comando

Verifique: Note que no final dos dois comandos (while e for) existe apenas um ponto-e-vírgula, isto é o sinal de comando vazio, ou seja, os comandos while e for que teriam outros comandos não os tem, caracterizando comandos vazios. Problema freqüente de digitação: Muitas vezes o programador insere um ponto-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: A Letra: B

52

Letra: C Letra: D Letra: E Letra: F Letra: G Letra: H Letra: I Letra: J Letra: K Letra: L Letra: M Letra: N Letra: O Letra: P Letra: Q Letra: R Letra: S Letra: T Letra: U Letra: V Letra: W Letra: X Letra: 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.

53

// --------------------------------------------- Fonte: prog23.java package prog23; public class Prog23 { public static void main(String[] args) { for (int i = 1; i <= 10; i++) { // inicialização: i = 1 System.out.printf("%d\n",i); // condição: i <= 10 } // incremento: i++ } } Programa exemplo (24): O programa imprime na tela: i = 1 - j = 9 i = 2 - j = 8 // --------------------------- Fonte: Prog24.java i = 3 – j = 7 i = 4 – j = 6 package prog24; public class Prog24 { public static void main(String[] args) { for (int i = 1,int j = 9; i != j; i++,j--) { System.out.printf("i = %d - j = %d\n", i ,j); } } } Resultado do Programa: i = 1 - j = 9 i = 2 - j = 8 i = 3 - j = 7 i = 4 - j = 6 O laço for é equivalente ao seguinte comando: inicialização; while (condição) { comando; incremento; // ou decremento

} ou inicialização; do { comando; incremento; // ou decremento } while (condição);

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:

54

do { comando; } while (condição); ü Repete o laço enquanto a condição for verdadeira. ü Testa a condição no final, fazendo com que o laço seja executado pelo menos uma vez. Programa exemplo (25): Imprime na tela de 1 até 10. // ----------------------------------------------- Fonte: Prog25.java package prog25; public class Prog25 { public static void main(String[] args) { int i = 1; do { System.out.printf("i = %d\n",i); i++; } while (i <= 10); } } Resultado do Programa: i = 1 i = 2 i = 3 i = 4 i = 5 i = 6 i = 7 i = 8 i = 9 i = 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);

55

} while (true); // laço eterno } } Resultado do Programa: Tecla ou [F]im: a <enter> Tecla: a - Codigo: 97 Tecla ou [F]im: Tecla: <enter> - Codigo: 10 // enter que o usuário digitou Tecla ou [F]im: b <enter> Tecla: b - Codigo: 98 Tecla ou [F]im: Tecla: <enter> - Codigo: 10 Tecla ou [F]im: A <enter> Tecla: A - Codigo: 65 Tecla ou [F]im: Tecla: <enter> - Codigo: 10 Tecla ou [F]im: B <enter> Tecla: B - Codigo: 66 Tecla ou [F]im: Tecla: <enter> - Codigo: 10 Tecla ou [F]im: f <enter> 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: 0 Par: 2 Par: 4 Par: 6 Par: 8 Par: 10 Par: 12 Par: 14 Par: 16 Par: 18 Par: 20 Par: 22 Par: 24 Par: 26 Par: 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.

56

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.

57

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 Tipo Formato

%s String String (vetor de caracteres) %d int Inteiro decimal com sinal %i int Inteiro decimal com sinal %o int Inteiro octal sem sinal %u int Inteiro decimal sem sinal %x int Inteiro hexadecimal sem sinal (com a, b, c, d, e, f) %X int Inteiro hexadecimal sem sinal (com A, B, C, D, E, F) %f float Valor com sinal da forma [-]dddd.dddd %e float Valor com sinal da forma [-]d.dddd e [+/-]ddd %g float Valor com sinal na forma e ou f baseado na precisão do valor dado %E float Mesmo que e, mas com E para expoente %G float Mesmo que g, mas com E para expoente %c char Um caracter %% nada O caracter % é impresso

Flags (Bandeiras):

ü (-) Alinha o resultado à esquerda. Preenche o restante do campo com brancos. Se não é colocado, alinha o resultado à direita e preenche o restante à esquerda com zeros ou brancos.

ü (+) O resultado sempre começa com o sinal + ou - ü (#) Especifica que o argumento será impresso usando uma das formas alternativas

Formas alternativas:

ü 0 É colocado zeros (0) antes do argumento ü x ou X É colocado 0x (ou 0X) antes do argumento

58

Especificadores de largura do campo a ser impresso (exemplos):

Tabela 10: Especificadores de largura do campo Prefixo 6d 6o 8x 10.2e 10.2f %-+#0 +00555 01053 0x0022b +5.50e+000 +000005.50 %-+# +555 01053 0x22b +5.50e+000 +5.50 %-+0 +00555 01053 000022b +5.50e+000 +000005.50 %-+ +555 1053 22b +5.50e+000 +5.50 %-#0 000555 001053 0x00022b 05.50e+000 0000005.50 %-# 555 01053 0x22b 5.50e+000 5.50 %-0 000555 01053 0000022b 05.50e+000 0000005.50 %- 555 1053 22b 5.50e+000 5.50 %+#0 +00555 01053 0x0022b +5.50e+000 +000005.50 %+# +555 01053 0x22b +5.50e+000 +5.50 %+0 +00555 01053 000022b +5.50e+000 +000005.50 %+ +555 1053 22b +5.50e+000 +5.50 %#0 000555 001053 0x00022b 05.50e+000 0000005.50 %# 555 01053 0x22b 5.50e+000 5.50 %0 000555 001053 0000022b 05.50e+000 0000005.50 % 555 1053 22b 5.50e+000 5.50

59

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). Calcule e imprima 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.0

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 Conceito

9,0 ou acima de 9,0 A entre 7,5 (inclusive) e 9,0 B entre 6,0 (inclusive) e 7,5 C abaixo de 6,0 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 Sair [S/N]? n <enter> Peso: 1.5 <enter> Preço por Kg (R$): 9.00 <enter> Total a pagar: 13.5

60

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> Quarenta e cinco Número [0..99]: 0 <enter>

61

9.9 Escreva um programa em Java que recebe via teclado: quantidade de litros vendidos, tipo de combustível ([A]lcool, [G]asolina ou [D]iesel) e o tipo de pagamento ([P]razo ou [V]ista). O programa deve calcular e imprimir na tela: total à prazo, desconto e o total à vista. O programa termina quando o usuário digitar 'N' ou 'n' na pergunta "Continua [S/N]?".

Tela de execução: Valores:

Quantidade de litros? 50 <enter> Álcool - 1,23 Tipo de combustível [A]lcool, [G]asolina ou [D]iesel ? G <enter> Gasolina - 2,19 Tipo de pagamento [P]razo ou a [V]ista ? V <enter> Diesel - 1,46 Total à prazo (R$) : 109.50 Desconto (R$): 5.48 Desconto à vista: 5% Total à vista (R$): 104.02 Continua [S/N]? N <enter>

9.10 Escreva um programa em Java que recebe via teclado duas notas: nota1 e nota2. O programa deve imprimir na tela a média, o conceito do aluno (dado pela tabela abaixo) e a situação (aprovado, exame ou reprovado):

Conceito Média Situação A 9,0 à 10,0 Aprovado B 7,0 à 8,9 Aprovado C 6,0 à 6,9 Exame D 0,0 à 5,9 Reprovado

Nota1 + Nota2 Exemplo:

Média = ----------------- 2 Nota1: 7 <enter>

Nota2: 8 <enter> Média: 7.5 Conceito: B Situação: Aprovado

Sair [S/N]? s <enter>

Observação: Programa termina se o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?

9.11 Escreva um programa em Java que recebe via teclado uma temperatura e o tipo de conversão (converter para: [C]elsius ou [F]ahrenheit). Calcule e imprima na tela a temperatura correspondente a solicitação do usuário, conforme exemplos abaixo:

Exemplo: Temperatura: 30 <enter> Tipo de conversão (converte para: [C]elsius ou [F]ahrenheit): F <enter> Temperatura em Fahrenheit: 86 Continua [S/N]? S <enter>

Temperatura: 86 <enter> Tipo de conversão (converte para: [C]elsius ou [F]ahrenheit): C <enter> Temperatura em Celsius: 30 Continua [S/N]? n <enter> Fórmula: C

9 . --- = F - 32 5 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: minutos segundos

ângulos em graus = graus + ---------- + ---------- 60 3600 Exemplo:

62

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> PIM = 72,7 x altura – 58 Peso Ideal: 62.0 PIF = 62,1 x altura – 44,7 Diferença de Peso: 30.0

Situação: GORDO Sair [S/N]? s <enter>

MAGRO IDEAL GORDO -------------------|-------------------|--------------------- -5% pi 5% Observação: Programa termina se o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?

63

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)

64

10.2 Strings Um objeto do tipo String (cadeia de caracteres) pode ser copiado para um vetor de caracteres. Veja o exemplo a seguir: ASCII: Americam Standard Code for Information Interchange. url: http://www.asciitable.com Programa Exemplo (28): Programa cópia todos os caracteres de uma String para um vetor de caracteres. // ----------------------------------------- Fonte: Prog28.java package prog28; import java.util.Scanner; public class Prog28 { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); String s; System.out.print("String: "); s = entrada.nextLine(); int n = s.length(); char [] vetorCaracter = new char[n]; for (int i = 0;i < s.length();i++) { vetorCaracter[i] = s.charAt(i); } System.out.print("Vetor: "); for (int i = n - 1;i >= 0;i--) { System.out.print(vetorCaracter[i]); } System.out.println(); } } Resultado do Programa: String: pelotas <enter> Vetor: satolep

10.3 Matrizes (Multidimensional)

tipo_dado [][] nome_matriz = new tipo_dado [tamanho][tamanho]; Exemplo: float [][] y = new float [5][5]; // matriz 2D Para acessar o elemento 3, 4 da matriz y, deve-se escrever y[3][4]. Note que o primeiro elemento é y[0][0] e o último elemento é y[4][4]. O total de elementos é 25. Programa Exemplo (28a): O programa possui uma matriz bidimensional para gerar e exibir na tela “n” palpites para a Mega Sena. // ------------------------------------------- Fonte: Prog28a.java package prog28a; import javax.swing.*; public class Prog28a {

65

public static void main(String[] args) { int n = entradaDados(); int [][] sena = new int [n][6]; geraPalpites(n, sena); sort(n, sena); exibePalpites(n, sena); } // --------------------------- entradaDados static int entradaDados() { String s; s = JOptionPane.showInputDialog("Numero de Palpites: "); int n = Integer.parseInt(s); return(n); } // --------------------------- geraPalpites static void geraPalpites(int n, int [][] sena) { int num; boolean repetido; for (int i = 0;i < n;i++) { for (int j = 0;j < 6;j++) { do { num = (int) (1 + (Math.random() * 60)); System.out.println(num); repetido = testaRepetido(num, sena[i]); if (!repetido) { sena[i][j] = num; } } while (repetido); } } } // --------------------------- testaRepetido static boolean testaRepetido(int num, int [] sena) { for (int i = 0;i < 6;i++) { if (num == sena[i]) { return(true); } } return(false); } // --------------------------- sort static void sort(int n, int [][] sena) { for (int k = 0;k < n;k++) { for (int i = 0;i < 5;i++) { for (int j = i+1;j < 6;j++) { if (sena[k][i] > sena[k][j]) { int temp = sena[k][i]; sena[k][i] = sena[k][j]; sena[k][j] = temp; } } } } } // --------------------------- exibePalpites static void exibePalpites(int n, int [][] sena) { for (int i = 0;i < n;i++) { String extenso = ""; for (int j = 0;j < 6;j++) {

66

extenso = extenso + sena[i][j] + " "; } JOptionPane.showMessageDialog(null, "Palpite: " + extenso, "Mega Sena", JOptionPane.PLAIN_MESSAGE); } } }

10.4 Vetor de Strings Para criar um vetor de Strings deve-se declarar assim: String [] nome = new String[3]; nome[0] = “Senac”; nome[1] = “Furg”; nome[2] = “UFPel”; String [] s = {“Pelotas”, “Rio Grande“, “Bagé}”;

Tabela 12: Exemplo de um vetor de strings 0 1 2 3 4

0 ‘S’ ‘e’ ‘n’ ‘a’ ‘c’ 1 ‘F’ ‘u’ ‘r’ ‘g’ 2 ‘U’ ‘F’ ‘P’ ‘e’ ‘l’

Cria um vetor com três Strings. Para acessar uma String em particular deve-se especificar o índice entre colchetes, ou seja, nome[0], nome[1] ou nome[2].

10.5 Inicialização de matrizes e vetores

tipo_dado [][] nome_matriz = {lista_valores}; lista_valores: lista de constantes separadas por vírgulas que são compatíveis em tipo com o tipo base da matriz. Exemplo: int [] i = {0,1,2,3,4,5,6,7,8,9}; // 10 elementos

Observação: Quando um vetor é declarado e inicializado (ao mesmo tempo) o número de elementos (neste caso 10) pode ser suprimido, ou seja, neste caso é opcional (veja exemplo anterior).

10.6 Inicialização de um vetor de caracteres

char [] nome_vetor = {lista_de_caracteres}; Exemplo: char [] str = {‘s’, ‘i’, ‘m’};

0 1 2 ‘s’ ‘i’ ‘m’

10.7 Inicialização de matrizes multidimensionais int [][] y = { {1,1}, {2,4}, {3,9}, {4,16} }; y[0][0] = 1 y[2][0] = 3 y[0][1] = 1 y[2][1] = 9 y[1][0] = 2 y[3][0] = 4

67

y[1][1] = 4 y[3][1] = 16

10.8 Inicialização de vetores e matrizes sem tamanho Na inicialização de uma matriz (ou vetor), se não for especificado seu tamanho, então o compilador Java cria uma matriz (ou vetor) grande o suficiente para conter todos os inicializadores presentes. Exemplo: char [] s = {’p’,’a’,’u’,’l’,’o’}; // s ocupa 5 bytes

Programa exemplo (29): O programa permite armazenar n nomes e idades em dois vetores. // ---------------------------------------------- Fonte: prog29.java package prog29; import java.util.Scanner; public class Prog29 { public static void main(String[] args) throws Exception{ Scanner entrada = new Scanner(System.in); String s; String [] nome; int [] idade; int numElementos; char ch; System.out.print("Número de Elementos: "); s = entrada.nextLine(); numElementos = Integer.parseInt(s); nome = new String[numElementos]; idade = new int[numElementos]; for (int i = 0;i < numElementos;i++) { System.out.print("Nome: "); nome[i] = entrada.nextLine(); System.out.print("Idade: "); s = entrada.nextLine(); idade[i] = Integer.parseInt(s); } for (int i = 0; i < numElementos; i++) { System.out.printf("| %-41s | %d | \n", nome[i], idade[i]); } } } 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 | 51 | | Renato Luis | 49 | | Francisco Carlos | 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;

68

public class Prog30 { public static void main(String[] args) { final int MAX = 10; Scanner entrada = new Scanner(System.in); String s; int [][] a = new int [MAX][MAX]; int [][] b = new int [MAX][MAX]; int [][] c = new int [MAX][MAX]; int col, lin, j, m, n; System.out.print("Informe a ORDEM da MATRIZ: (mxn)\n"); do { System.out.printf("Número de linhas (m): "); s = entrada.nextLine(); m = Integer.parseInt(s); } while (m < 1 || m > MAX); // m de 1 à 10 do { System.out.print("Número de colunas (n): "); s = entrada.nextLine(); n = Integer.parseInt(s); } while (n < 1 || n > MAX); // n de 1 à 10 for (lin = 1;lin <= m;lin++) { for (col = 1;col <= n;col++) { System.out.printf("A[%d,%d] = ",lin,col); s = entrada.nextLine(); a[lin][col] = Integer.parseInt(s); System.out.printf("B[%d,%d] = ",lin,col); s = entrada.nextLine(); b[lin][col] = Integer.parseInt(s); } } System.out.println(); for (lin = 1;lin <= m;lin++) { for (col = 1;col <= n;col++) { c[lin][col] = a[lin][col] + b[lin][col]; System.out.printf("C[%d,%d] = %d\n",lin,col,c[lin][col]); } } } } 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] = 3 C[1,2] = 7 C[2,1] = 11 C[2,2] = 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

69

package prog31; import java.util.Scanner; public class Prog31 { public static void main(String[] args) { String [] nome; int numElementos; Scanner entrada = new Scanner(System.in); String s; System.out.print("Número de Elementos: "); s = entrada.nextLine(); numElementos = Integer.parseInt(s); nome = new String[numElementos]; for (int i = 0;i < numElementos;i++) { System.out.print("Nome: "); nome[i] = entrada.nextLine(); } for (int i = 0; i < numElementos - 1; i++) { for (int j = i+1; j < numElementos; j++) { if (nome[i].compareTo(nome[j]) > 0) { String temp = nome[i]; nome[i] = nome[j]; nome[j] = temp; } } } System.out.printf("\nNomes ORDENADOS\n"); for (int i = 0; i < numElementos; i++) { System.out.printf("Nome: %s\n", nome[i]); } } } 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 ORDENADOS Nome: Ana Nome: Beatriz Nome: Carla Nome: Debora Nome: 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);

70

String s; boolean sort; System.out.print("Numero de Elementos: "); s = entrada.nextLine(); numElementos = Integer.parseInt(s); nome = new String[numElementos]; for (int i = 0;i < numElementos;i++) { System.out.print("Nome: "); nome[i] = entrada.nextLine(); } int k = numElementos - 1; do { sort = false; for (int i = 0; i < k; i++) { if (nome[i].compareTo(nome[i+1]) > 0) { String temp = nome[i]; nome[i] = nome[i+1]; nome[i+1] = temp; sort = true; } } k--; } while (sort); System.out.printf("\nNomes ORDENADOS\n"); for (int i = 0; i < numElementos; i++) { System.out.printf("Nome: %s\n", nome[i]); } } } 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 ORDENADOS Nome: Ana Nome: Beatriz Nome: Carla Nome: Debora Nome: Eva

10.10 Lista de exercícios (vetores) 10.10.1 Escreva um programa em Java que recebe via teclado um conjunto de letras (máximo 20). Armazene todas as letras em um vetor (letras) até que o usuário digite um F ou f. Logo após copie todas as letras (em ordem inversa) para outro vetor (inverso). Ao final imprima os dois vetores. Exemplo: Letra: L <enter>

Letra: I <enter> Letra: M <enter> Letra: A <enter> Letra: f <enter> LIMA AMIL

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.

71

Exemplo: Número de idades: 6 <enter> Idade: 30 <enter> Idade: 60 <enter>

Idade: 10 <enter> Idade: 50 <enter>

Idade: 20 <enter> Idade: 40 <enter>

Idade para consulta: 50 <enter> Antes: 3 Depois: 2 Continua [S/N]? n <enter>

10.10.3 Escreva um programa em Java que recebe via teclado um conjunto de números inteiros (máximo 50). Armazene todos os números inteiros em um vetor até que o usuário digite 0 (zero). Logo após permita ao usuário consultar um número informando o seu valor. O programa deve imprimir na tela a posição do número no vetor ou ERRO: Número não encontrado (veja exemplos abaixo):

Exemplo: Número: 50 <enter> Número: 30 <enter>

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

72

Letra: T <enter> Letra: <enter>

10.10.6 Escreva um programa em Java que recebe via teclado “n” (máximo 30) nomes e idades. A entrada dos dados termina quando o usuário digitar 'N' ou 'n' na pergunta "Continua [S/N]?". Logo após a entrada de todos os dados o programa deve imprimir na tela todos os nomes e idades desde o mais velho até o mais novo.

Exemplo: Nome: Ana <enter> Idade: 12 <enter> Continua [S/N]? s <enter>

Nome: Beatriz <enter> Idade: 13 <enter> Continua [S/N]? s <enter>

Nome: Carla <enter> Idade: 14 <enter> Continua [S/N]? N <enter>

Carla 14 Beatriz 13 Ana 12

73

11. Manipulação de Strings A linguagem Java possui uma classe especifica para manipular strings, ou seja, cadeia de caracteres.

11.1 Métodos para manipular Strings Considere que: String s = “Pelotas”; A seguir são descritos os principais métodos que permitem manipular objetos do tipo String. Sintaxe: char charAt(int index); Retorna o caracter do índice especifiado. Modo de usar: String s = “Pelotas”;

ch = s.charAt(0); // 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 diferenças entre maíusculas e minísculas. Sintaxe: String concat(String str); Concatena a String especificada no fim desta String. Sintaxe: boolean contentEquals(StringBuffer sb); Retorna “true” se e somente se esta String representa a mesma sequência de caracteres do que a “StringBuffer” especificada. Sintaxe: static String copyValueOf(char[] data); Retorna uma String que representa a sequência de caracteres do vetor especificado. Sintaxe: static String copyValueOf(char[] data, int offset, int count); Retorna uma String que representa uma sequência de caracteres do vetor especificado. Sintaxe: boolean endsWith(String suffix); Testa se esta String termina com o sufixo especificado. Sintaxe: boolean equals(Object anObject); Compara esta String com o objeto especificado. Sintaxe: boolean equalsIgnoreCase(String anotherString); Compara esta String com outra String, ignorando maiúsculas e minúsculas. Sintaxe: byte[] getBytes(); Codifica esta String em uma sequência de bytes usando o conjunto de caracteres, armazenando o resultaod em um novo vetor de bytes. Sintaxe: byte[] getBytes(String charsetName); Codifica esta String em uma sequência de bytes usando o conjunto de caracteres do nome, armazenando o resultado dentro do novo vetor.

74

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 primeira ocorrência do caracter especificado ou -1 se não encontrar. Sintaxe: int indexOf(int ch, int fromIndex); Retorna o índice dentro desta String da primeira ocorrência do caracter especificado, iniciando a busca no índice espeficidado. Sintaxe: int indexOf(String str); Retorna o índice dentro desta String da primeira ocorrência da substring especificada. Sintaxe: int indexOf(String str, int fromIndex); Retorna o índice dentro desta String da primeira ocorrência da substring especificada, iniciando a busca no índice espeficidado. 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); 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);

75

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 [[]”. Sintaxe: static String valueOf(double d); Retorna uma representação String do argumento “double”.

76

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 de caracteres da String s for (int i = n-1;i >= 0;i--) { System.out.print(s.charAt(i)); // acesso a cada caracter de s } System.out.println(); do { System.out.print("Continua [S/N]? "); s = input.nextLine(); op = s.charAt(0); } while ("SsNn".indexOf(op) == -1); // verifica se op é “SsNn” } while ("Ss".indexOf(op) != -1); // } while ("S".equalsIgnoreCase(s));

77

} } 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 quando o usuário digitar “N” ou “n” na pergunta: Continua [S]im ou [N]ão?. 11.2.3 Escreva um programa em Java que recebe via teclado uma palavra e uma posição. O programa deve imprimir na tela, a letra antecessora, a letra (da referida posição) e a letra sucessora, conforme exemplo abaixo:

78

Exemplo: Palavra: Universidade <enter>

Posição: 7 <enter> Antecessora: s Letra: i Sucessora: d

Observação: O programa deve imprimir na tela as seguintes mensagens de erro, se for o caso: Letra antecessora não existe, Letra sucessora não existe ou Posição inválida. 11.2.4 Escreva um programa em Java que recebe via teclado um nome. O programa deve imprimir, na tela, as palavras do nome em ordem inversa, uma por linha, conforme exemplo abaixo:

Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter>

Luzzardi Gomes Roberto Paulo

11.2.5 Escreva um programa em Java que recebe via teclado um nome. Logo após a entrada do nome o programa deve imprimir (EM LETRA MAIÚSCULA) o sobrenome da pessoa, conforme exemplos abaixo:

Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter> Sobrenome: LUZZARDI

Sair [S/N]? N <enter> Nome: Renato Souza <enter>

Sobrenome: SOUZA Sair [S/N]? s <enter>

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>

79

Início: 7 <enter> Fim: 11 <enter> String resultante: idade Continua [S/N]? s <enter> Palavra: eletricidade <enter> Início: 7 <enter> Fim: 15 <enter> ERRO: Fim Inválido Continua [S/N]? N <enter>

Observação: O programa termina quando o usuário digitar ‘N’ ou ‘n’ na pergunta: Continua [S/N]?.

80

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

81

0.7770564673470854 Valor: 7 0.1130461920867929 Valor: 1 0.29725902364100654 Valor: 2

Chamada do método: n = random(10); // retorna um número aleatório entre 0 e 9

Programa exemplo (33): O programa possui um método estático que calcula o inverso 1/x. // ---------------------------------------------- Fonte: Prog33.java package prog33; import java.util.Scanner; public class Prog33 { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); String s; double inv, x; System.out.print("x = "); s = entrada.nextLine(); x = Double.parseDouble(s); inv = inverso (x); // chamada do método inverso System.out.printf("Inverso = %.2f\n", inv); } // ----------------------------- Método definido pelo programador static double inverso (double x) { double i; i = (double) 1 / x; return(i); } } Resultado do Programa: x = 4 <enter> Inverso = 0,25

82

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 valor que simplesmente indica o sucesso ou o fracasso da manipulação. Programa exemplo (35): O programa calcula e verifica o determinante de uma equação de segundo grau através de um método estático chamado: verificaDeterminante. // ------------------------------------------ Fonte: Prog35.java package prog35; import java.util.Scanner; public class Prog35 {

83

public static void main(String[] args) { Scanner entrada = new Scanner(System.in); String s; float a, b, c; int retorno; System.out.print("a = "); s = entrada.nextLine(); a = Float.parseFloat(s); System.out.print("b = "); s = entrada.nextLine(); b = Float.parseFloat(s); System.out.print("c = "); s = entrada.nextLine(); c = Float.parseFloat(s); retorno = verificaDeterminante(a, b, c); if (retorno == 0) { System.out.println("Determinante ZERO"); } else { if (retorno > 0) { System.out.println("Determinante POSITIVO"); } else { System.out.println("Determinante NEGATIVO"); } } } // ---------------------------- metodo definido pelo programador static int verificaDeterminante(float a, float b, float c) { float det; det = b * b - 4 * a * c; if (det == 0) { return (0); } else { if (det > 0) { return (1); } else { return (-1); } } } } Resultado do Programa: a = 1 <enter> b = 2 <enter> c = 3 <enter> Determinante NEGATIVO c) Métodos que não retornam nenhum valor, ou seja, são puramente procedimentos. Programa exemplo (36): O programa possui um método estático imprime um número (int ou float) através do método chamado: imprimeNumero. // -------------------------------------- Fonte: Prog36.java 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;

84

System.out.print("Digite um Numero: "); s = entrada.nextLine(); x = Integer.parseInt(s); imprimeNumero(x); System.out.print("Digite outro Numero: "); s = entrada.nextLine(); y = Float.parseFloat(s); imprimeNumero(y); } // ----------------------------- ImprimeNumero static void imprimeNumero(int n) { System.out.println("Numero digitado foi " + n); } // ----------------------------- ImprimeNumero static void imprimeNumero(float n) { System.out.println("Numero digitado foi " + n); } } Resultado do Programa: Digite um número: 3 <enter> Número digitado foi 3 Digite outro número: 4 <enter> Número 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(); }

85

} } Onde: ci -> coluna inicial li -> linha inicial cf -> coluna final lf -> linha final Atenção: Os argumentos do método recebem, respectivamente: ci=1, li=1, cf=20 e lf=10. Resultado do Programa: 123456789 1:######### 2:######### 3:######### 4:######### 5:######### 6:######### 7:######### 8:######### 9:#########

12.3 Passagem de parâmetros por referência A passagem de parâmetros ou argumentos por referência em Java acontece somente com qualquer tipo de dado do tipo vetor ou matriz, ou seja, não é possível fazer passagem de argumento por referência com variáveis do tipo: char, byte, int, short, long, float ou double. Programa exemplo (38): O programa tem um método que troca o valor de duas variáveis. // ------------------------------------------------- Fonte: Prog38.java package prog38; public class Prog38 { public static void main(String[] args) { int [] x = {3, 4}; // 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

86

Todas os métodos que devolvem valores não-inteiros devem ter seu tipo de retorno declarado. tipo_do_retorno nome_do_metodo (tipo_dado_base parâmetros); Programa exemplo (39): O programa calcula e imprime na tela a divisão de dois valores usando um método estático chamado divisão. // ------------------------------------------ Fonte: prog39.java package prog39; import java.util.Scanner; public class Prog39 { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); String s; int x, y; float resposta; System.out.printf("x = "); s = entrada.nextLine(); x = Integer.parseInt(s); System.out.printf("y = "); s = entrada.nextLine(); y = Integer.parseInt(s); resposta = divisao( x, y); System.out.printf("Divisão = %7.2f\n",resposta); } // ----------------------------- método definido pelo programador static float divisao (int x, int y) { return( (float) x / y ); } } Resultado do Programa: Vetor: 3 - 4 - 5 Vetor: 4 - 5 - 3

12.5 Argumentos do main (String [] args) O método estático main possui um argumento args intrínsecos utilizados para receber parâmetros da linha de comando do Sistema Operacional. args – Vetor de Strings Programa exemplo (40): O programa recebe parâmetros do Sistema Operacional (uma palavra qualquer) e imprime a palavra em sentido inverso. O programa deve ser executado via terminal do Sistema Operacional da seguinte forma: Execução pela linha de comandos (terminal): $ java Prog40 pelotas <enter> Resultado na tela: satolep Programa recebe:

87

argv[0] = “pelotas” // --------------------------------------- Fonte: Prog40.java package prog40; public class Prog40 { public static void main(String[] args) { int n, argc = args.length; if (argc != 1) { System.out.printf("Sintaxe: Prog40 <palavra>\n"); } else { System.out.print("Palavra: "); n = args[0].length(); for (int i = n-1; i >= 0; i--) { System.out.printf("%c", args[0].charAt(i)); } System.out.println(); } } } Resultado do Programa: MacBook-Air-de-Paulo:prog40 pluzzardi$ java Prog40 pelotas <enter> Palavra: satolep MacBook-Air-de-Paulo:prog40 pluzzardi$ 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];

88

ch[j] = temp; } } } for (int i = 0;i < numCar;i++) { System.out.printf("%c", ch[i]); } System.out.printf("\n"); } } } Resultado do Programa: MacBook-Air-de-Paulo:prog41 pluzzardi$ java Prog41 dbeacgf <enter> abcdefg MacBook-Air-de-Paulo:prog41 pluzzardi$

12.6 Recursividade Um método é recursivo se este fizer uma chamada a si própria. Programa exemplo (42): O programa calcula o fatorial de um número recursivamente. // ------------------------------------------ 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>

89

Fatorial: 355687428096000 n = 18 <enter> Fatorial: 6402373705728000 n = 19 <enter> Fatorial: 121645100408832000 n = 20 <enter> n = 0 <enter> Fatorial: 1 Programa exemplo (43): O programa calcula a soma de um número recursivamente. // ------------------------------------------- Fonte: Prog43.java package prog43; import java.util.Scanner; public class Prog43 { 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); // recursividade return(s); } } Resultado do Programa: n = 1 <enter> Soma: 1 n = 2 <enter> Soma: 3 n = 3 <enter> Soma: 6 n = 4 <enter> Soma: 10 n = 0 <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):

90

// ------------------------------------------------------ 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); } // ---------------------------- 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: | 2 | 1 x: 1 <enter> ________________________ y: 2 <enter> | Quadrante: 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

91

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 } 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;

92

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: 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

93

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 Array expansível DList Lista Duplamente Encadeada SList Lista Encadeada Simples HashMap fast associative container OrderedMap associative container HashSet fast set or multiset OrderedSet set or multiset PriorityQueue array-based heap Queue Fila (Interface) Stack Pilha Deque 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 Queue (Filas): PriorityQueue

94

Maps: HashTable, HashMap, LinkedHashMap, WeakHashMap, IdentityHashMap, TreeMap A seguir são descritos alguns destes elementos: Vector (Vetor) import java.util.Vector; A classe Vector é utilizada em uma estrutura de dados armazenada em um vetor, ou seja, uma lista de elementos. A seguir são descritos os principais métodos da classe Vector. Sintaxe: void add(int index, Object element); Insere um elemento especificado na posição especificada no Vetor. Sintaxe: boolean add(Object o); Anexa o elemento especificado no fim do Vetor. Sintaxe: boolean addAll(Collection c); Anexa todos os elementos da coleção especificada no final do Vetor, na ordem que eles são retornados pelo iterador da coleção especificada. Sintaxe: boolean addAll(int index, Collection c); Insere todos os elementos na coleção especificada no Vetor na posição especificada. Sintaxe: void addElement(Object obj); Adiciona o componente especificado no fim do Vetor, aumentando se tamanho em um. Sintaxe: int capacity(); Retorna a corrente capacidade do Vetor. Sintaxe: void clear(); Remove todos os elementos do Vetor. Sintaxe: Object clone(); Retorna um clone do Vetor. Sintaxe: boolean contains(Object elem); Testa se um objeto específico é um componente do Vetor. Sintaxe: boolean containsAll(Collection c); Retorna true se o Vetor contém todos os elementos da coleção específica. Sintaxe: void copyInto(Object[] anArray); Copia os componentes do Vetor para o Array especificado. Sintaxe: Object elementAt(int index); Retorna o componente especificado pelo “index”. Sintaxe: Enumeration elements(); Retorna uma enumeração dos componentes do Vetor. Sintaxe: void ensureCapacity(int minCapacity); Aumenta a capacidade do Vetor, se necessário, estando certo que de poder armazenar o número de componentes especificados pelo argumento “mincapacity.

95

Sintaxe: boolean equals(Object o); Compara o objeto especificado com o Vetor pela igualdade. Sintaxe: Object firstElement(); Retorna o primeiro componente (o item de “index” 0) do Vetor. Sintaxe: Object get(int index); Retorna o elemento da posição especificada do Vetor. Sintaxe: int hashCode(); Retorna o valor do código “hash” do Vetor. Sintaxe: int indexOf(Object elem); Procura a primeira ocorrência de um dado argumento, testando a igualdade pelo método “equals. “ Sintaxe: int indexOf(Object elem, int index); Procura pela primeira ocorrência de um dado argumento, começando a busca pelo “index”, e testando pela igualdade usando o métod “equals. “ Sintaxe: void insertElementAt(Object obj, int index); Insere o objeto especificado como um componente no Vetor no “index” especificado. Sintaxe: boolean isEmpty(); Testa se o Vetor não tem componentes. Sintaxe: Object lastElement(); Retorna o último componente do Vetor. Sintaxe: int lastIndexOf(Object elem); Retorna o “index” da última ocorrência do objeto especificado no Vetor. Sintaxe: int lastIndexOf(Object elem, int index); Procura para trás por um objeto especificado, começando no “index” especificado e retorna um “index” para ele. Sintaxe: Object remove(int index); Remove o elemento da posição especificada no Vetor. Sintaxe: boolean remove(Object o); Remove a primeira ocorrência do elemento especificado no Vetor, se o Vetor não contém o elemento, ele não é alterado. Sintaxe: boolean removeAll(Collection c); Remove do Vetor todos os elementos que contém a coleção especificada. Sintaxe: void removeAllElements(); Remove todos os componentes do Vetor e seta o tamanho em zero. Sintaxe: boolean removeElement(Object obj); Remove a primeira (menor indexado) ocorrência do argumento do Vetor. Sintaxe: void removeElementAt(int index); Deleta o componente com “index” especificado. Sintaxe:protected void removeRange(int fromIndex, int toIndex); Remove da lista todos os elementos escolhidos entre o “fromIndex” (inclusive) e “toIndex” (exclusive).

96

Sintaxe: boolean retainAll(Collection c); Mantém somente os elementos do Vetor que contém a coleção especificada. Sintaxe: Object set(int index, Object element); Troca o elemento da posição especificada do Vetor com o elemento especificado. Sintaxe: void setElementAt(Object obj, int index); Seta o componente com “index” especificado do Vetor para o objeto especificado. Sintaxe: void setSize(int newSize); Seta o tamanho do Vetor. Sintaxe: int size(); Retorna o número de componentes do Vetor. Sintaxe: List subList(int fromIndex, int toIndex); Retorna uma visão da porção da Lista entre “fromIndex” (inclusive) e “toIndex” (exclusive). Sintaxe: Object[] toArray(); Retorna um array contendo todos os elementos no Vetor na ordem correta. Sintaxe: Object[] toArray(Object[] a); Retorna um array contendo todos os elementos no Vetor ordem correta; o tipo “runtime” do array especificado é retornado. Sintaxe: String toString(); Retorna uma string do Vetor, contendo uma representação de cada elemento. Sintaxe: void trimToSize(); Ajusta a capacidade do Vetor para a atual dimensão do Vetor. Programa Exemplo (3): Exemplo de um vetor usando a classe “Vector”. // ------------------------------------------- Fonte: Prog3.java package Prog3; import java.util.Vector; import javax.swing.JOptionPane; public class Prog3 { public static void main(String[] args) { Vector vetor = new Vector(); String s, extenso = ""; int u = -1, nodo; do { u++; s = JOptionPane.showInputDialog("Nodo: "); nodo = Integer.parseInt(s); if (nodo != 0) { vetor.add(nodo); // vetor.add(u, nodo); } } while (nodo != 0); extenso = vetor.toString(); int n = vetor.size(); /* ------------------------------------------------- outra forma for (int i = 0; i < n;i++) extenso = extenso + vetor.get(i) + " "; ---------------------------------------------------------------*/

97

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(); } } Resultado do Programa:

98

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();

99

} } 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); } }

100

LinkedList (Lista Encadeada Simples) import java.util.LinkedList; A lista LinkedList é utilizada para armazenar elementos em uma lista encadeada simples, ou seja, lista alocada dinamicamente, onde a lista cresce enquanto houver memória livre. A seguir são descritos os principais métodos de uma LinkedList. Sintaxe: void add (int index, Object element); Insere o elemento especificado na posição especificada da lista. Sintaxe: boolean add (Objetc o); Anexa o elemento especificado no fim da lista. Sintaxe: boolean addAll (Collection c); Anexa todos os elementos da coleção especificada no fim da lista, na ordem que eles são retornados do iterador da coleção especificado. Sintaxe: boolean addAll (int index, Collection c); Insere todos os elementos da coleção especificada dentro da lista, começando na posição especificada. Sintaxe: void addFirst (Object o); Insere um dado elemento no começo da lista. Sintaxe: void addLast (Object o); Anexa um dado elemento no fim da lista. Sintaxe: void clear (); Remove todos os elementos da lista. Sintaxe: Object clone (); Retorna uma cópia superficial do LinkedList. Sintaxe: boolean contains (Object o); Retorna verdadeiro (true) se a lista contém o elemento especificado. Sintaxe: Object get (int index); Retorna o elemento da posição especificada na lista. Sintaxe: Object getFirst (); Retorna o primeiro elemento da lista. Sintaxe: Object getLast (); Retorna o último elemento da lista. Sintaxe: int indexOf (Object o); Retorna o índice da lista da primeira ocorrência do elemento especificado, ou -1 se a Lista não contém este elemento. Sintaxe: int lastIndexOf (Object o); Retorna o índice da lista da última ocorrência do elemento especificado, ou -1 se a lista não contém este elemento. Sintaxe: ListIterator listIterator (int index); Retorna um iterador da lista dos elementos da lista (na sequência correta), começando na posição especificada na lista.

101

Sintaxe: Object remove (int index); Remove o elemento da posição especificada na lista. Sintaxe: boolean remove (Object o); Remove a primeira ocorrência do elemento especificado na lista. Sintaxe: Object removeFirst (); Remove e retorna o primeiro elemento da lista. Sintaxe: Objetc removeLast (); Removes e retorna o último elemento da lista. Sintaxe: Object set (int index, Object element); Troca o elemento da posição especificada na lista pelo o elemento especificado. Sintaxe: int size (); Retorna o número de elementos na lista. Sintaxe: Object [] toArray (); Retorna um “array” (vetor) contendo todos os elementos da lista na ordem correta. 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.*;

102

public class Prog5 { public static void main(String[] args) { Queue fila = new LinkedList(); // Fila com uma Lista Encadeada Simples String s, extenso = ""; int nodo; do { s = JOptionPane.showInputDialog("Nodo: "); nodo = Integer.parseInt(s); if (nodo != 0) { fila.offer(nodo); } } while (nodo != 0); do { extenso = extenso + fila.poll() + " "; } while (!fila.isEmpty()); JOptionPane.showMessageDialog(null, "Fila: " + extenso, "Queue", JOptionPane.PLAIN_MESSAGE); } } 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); Procura em um vetor de “double” especificado por um valor específico usando algoritmo binário de busca.

103

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” são iguais. Sintaxe: static boolean equals(byte[] a, byte[] a2); Retorna “true” se os dois arrays especificados de “byte” são iguais. Sintaxe: static boolean equals(char[] a, char[] a2); Retorna “true” se os dois arrays especificados de “char” são iguais. Sintaxe: static boolean equals(double[] a, double[] a2); Retorna “true” se os dois arrays especificados de “double” são iguais. Sintaxe: static boolean equals(float[] a, float[] a2); Retorna “true” se os dois arrays especificados de “float” são iguais. Sintaxe: static boolean equals(int[] a, int[] a2); Retorna “true” se os dois arrays especificados de “int []” são iguais. Sintaxe: static boolean equals(long[] a, long[] a2); Retorna “true” se os dois arrays especificados de “long []” são iguais. Sintaxe: static boolean equals(Object[] a, Object[] a2); Retorna “true” se os dois arrays especificados de “Object []” são iguais. Sintaxe: static boolean equals(short[] a, short[] a2); Retorna “true” se os dois arrays especificados de “short” são iguais. Sintaxe: static void fill(boolean[] a, boolean val); Atribui um valor booleano especificado para cada elemento da matriz de booleanos. Sintaxe: static void fill(boolean[] a, int fromIndex, int toIndex, boolean val);

104

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); 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);

105

Retorna o código “hash” com base no conteúdo da array especificada. Sintaxe: static int hashCode(double[] a); Retorna o código “hash” com base no conteúdo da array especificada. Sintaxe: static int hashCode(float[] a); Retorna o código “hash” com base no conteúdo da array especificada. Sintaxe: static int hashCode(int[] a); Retorna o código “hash” com base no conteúdo da array especificada. Sintaxe: static int hashCode(long[] a); Retorna o código “hash” com base no conteúdo da array especificada. Sintaxe: static int hashCode(Object[] a); Retorna o código “hash” com base no conteúdo da array especificada. Sintaxe: static int hashCode(short[] a); Retorna o código “hash” com base no conteúdo da array especificada. Sintaxe: static void sort(byte[] a); Ordena o array especificado de “byte” em ordem ascendente numérica. Sintaxe: static void sort(byte[] a, int fromIndex, int toIndex); Ordena a faixa do array especificado de “byte” em ordem ascendente numérica. Sintaxe: static void sort(char[] a); Ordena o array especificado de “char” em ordem ascendente numérica. Sintaxe: static void sort(char[] a, int fromIndex, int toIndex); Ordena a faixa do array especificado de “char” em ordem ascendente numérica. Sintaxe: static void sort(double[] a); Ordena o array especificado de “double” em ordem ascendente numérica. Sintaxe: static void sort(double[] a, int fromIndex, int toIndex); Ordena a faixa do array especificado de “double” em ordem ascendente numérica. Sintaxe: static void sort(float[] a); 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);

106

Ordena o array especificado de “Object” em ordem ascendente numérica, de acordo com a ordem natutal dos elementos. Sintaxe: static void sort(Object[] a, int fromIndex, int toIndex); Ordena a faixa do array especificado de “Object” em ordem ascendente numérica. Sintaxe: static void sort(short[] a); Ordena o array especificado de “short” em ordem ascendente numérica. Sintaxe: static void sort(short[] a, int fromIndex, int toIndex); Ordena a faixa do array especificado de “short” em ordem ascendente numérica. Sintaxe: static String toString(boolean[] a) Retorna uma “string” o conteúdo do array de “boolean” especificado. Sintaxe: static String toString(byte[] a); Retorna uma “string” o conteúdo do array de “byte” especificado. Sintaxe: static String toString(char[] a); Retorna uma “string” o conteúdo do array de “char” especificado. Sintaxe: static String toString(double[] a); Retorna uma “string” o conteúdo do array de “double” especificado. Sintaxe: static String toString(float[] a); Retorna uma “string” o conteúdo do array de “float” especificado. Sintaxe: static String toString(int[] a); Retorna uma “string” o conteúdo do array de “int []” especificado. Sintaxe: static String toString(long[] a); Retorna uma “string” o conteúdo do array de “long []” especificado. Sintaxe: static String toString(Object[] a); Retorna uma “string” o conteúdo do array de “Object []” especificado. 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);

107

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; 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:

108

Nome: Paulo Roberto Idade: 48 Nome: Renato Luis Idade: 46 Nome: Francisco Carlos Idade: 50 Nome: Ana Maria Idade: 53 Nome: Julia Helena Idade: 52

109

14. Entrada e saída em disco (Arquivos)

Em Java é possível manipular arquivos através da classe File (Arquivo).

14.1 Métodos para manipular arquivos em Java

A seguir são descritos os principais métodos para manipular arquivos em Java:

Sintaxe: boolean canRead(); Testa se o aplicativo pode ler o arquivo indicado pelo “pathname” (caminho) indicado. Sintaxe: boolean canWrite(); Testa se o aplicativo pode modificar para o arquivo indicado pelo “pathname” (caminho) indicado. Sintaxe: int compareTo(File pathname); Compara dois “pathnames” lexicograficamente. Sintaxe: int compareTo(Object o); Compara o “pathname” com outro objeto. Sintaxe: boolean createNewFile(); Cria um novo arquivo vazio com o nome do “pathname”, se e somente se um arquivo com este nome ainda não existe. Sintaxe: static File createTempFile(String prefix, String suffix); Cria um arquivo vazio no diretório de arquivos temporários, usando o prefixo e o sufixo dado para gerar o seu nome. Sintaxe: static File createTempFile(String prefix, String suffix, File directory); Cria um novo arquivo vazio no diretório especificado, usando o prefixo e o sufixo dado pela String para gerar o seu nome. Sintaxe: boolean delete(); Deleta o arquivo ou diretório informado no “pathname”. Sintaxe: void deleteOnExit(); Solicita que o arquivo ou diretório indicado por este “pathname” ser excluído quando a máquina virtual termina. Sintaxe: boolean equals(Object obj); Testa se o “pathname” é igual ao objeto indicado. Sintaxe: boolean exists(); Testa se o arquivo ou diretório indicado para este “pathname” existe. Sintaxe: File getAbsoluteFile(); Retorna a forma absoluta do “pathname”. Sintaxe: String getAbsolutePath(); Retorna uma String absoluta do “pathname”. Sintaxe: File getCanonicalFile(); Retorna a forma canônica do “pathname”. Sintaxe: String getCanonicalPath();

110

Retorna uma String canônica do “pathname”. Sintaxe: String getName(); Retorna o nome do arquivo ou diretório indicado pelo “pathname”. Sintaxe: String getParent(); Retorna uma String do caminho pai, esse caminho abstrato, ou nulo se este caminho não é nome de um diretório pai. Sintaxe: File getParentFile(); Retorna o caminho abstrato pai deste caminho, ou nulo se este caminho não é nome de um diretório pai. Sintaxe: String getPath(); Converte este “pathname” em uma String do “pathname”. Sintaxe: int hashCode(); Calcula o código “hash” para este “pathname”. Sintaxe: boolean isAbsolute(); Testa se este “pathname” é absoluto Sintaxe: boolean isDirectory(); Testa se o arquivo indicado por este caminho (pathname) é um diretório. Sintaxe: boolean isFile(); Testa se o arquivo indicado por este caminho (pathname) é um arquivo (file). Sintaxe: boolean isHidden(); Testa se o arquivo indicado por este caminho (pathname) é um arquivo escondido. Sintaxe: long lastModified(); Retorna o tempo em que o arquivo indicado por este caminho foi modificado pela última vez. Sintaxe: long length(); Retorna o comprimento do arquivo indicado pelo “pathname”. Sintaxe: String[] list(); Retorna um vetor de Strings com os nomes dos arquivos e diretórios no diretório indicado por este caminho. Sintaxe: String[] list(FilenameFilter filter); Retorna um vetor de Strings com os nomes de arquivos e diretórios no diretório indicado por este caminho que satisfaçam o filtro especificado. Sintaxe: File[] listFiles(); Retorna um vetor de “pathnames” indicando os arquivos no diretório indicado por este caminho. Sintaxe: File[] listFiles(FileFilter filter); Retorna um vetor de “pathnames” indicando os arquivos e diretórios no diretório indicado por este caminho que satisfaçam o filtro especificado. Sintaxe: File[] listFiles(FilenameFilter filter); Retorna um vetor de “pathnames” indicando os arquivos e diretórios no diretório indicado por este caminho que satisfaçam o filtro especificado. Sintaxe: static File[] listRoots();

111

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: Arquivo: /Users/pluzzardi/luzzardi.txt <enter> Bytes: 131

14.3 Listar um diretório

112

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; public class Prog46 {

113

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.

114

// --------------------------------------------- Fonte: Prog47.java package prog47; import java.io.File; import java.io.FileWriter; import java.util.Scanner; public class Prog47 { public static void main(String[] args) throws Exception { Scanner entrada = new Scanner(System.in); String diretorio = "/Users/pluzzardi"; File arquivo = new File(diretorio, "palavras.dat"); if (!arquivo.exists()) { FileWriter file = new FileWriter(arquivo); System.out.print("Número de Palavras: "); String s = entrada.nextLine(); int numPalavras = Integer.parseInt(s); file.write((byte)numPalavras); file.write('\n'); for (int i = 1;i <= numPalavras;i++) { System.out.print("Palavra: "); byte a = (byte) System.in.read(); while(a != '\n') { file.write(a); a = (byte) System.in.read(); } file.write('\n'); } file.close(); } else { 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 {

115

public static void main(String[] args) throws Exception { String diretorio = "/Users/pluzzardi"; File arquivo = new File(diretorio, "palavras.dat"); byte a; if (arquivo.exists()) { FileReader file = new FileReader(arquivo); int numPalavras = file.read(); file.read(); for (int i = 1;i <= numPalavras;i++) { System.out.print("Palavra: "); a = (byte) file.read(); while(a != '\n') { System.out.printf("%c", a); a = (byte) file.read(); } System.out.println(); } file.close(); } else { System.out.println("ERRO: Arquivo não existe"); } } } Resultado do Programa: Palavra: carambola Palavra: beringela Palavra: abacate Palavra: ervilha Palavra: 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();

116

file.close(); int pos; do { System.out.print("Posição [1.." + numPalavras + "] ou [0] Sair: "); s = entrada.nextLine(); pos = Integer.parseInt(s); if (pos >= 1 && pos <= numPalavras) { System.out.println("Palavra: " + linha[pos - 1]); } else { if (pos != 0) { System.out.println("ERRO: Posição Inválida"); } } } while (pos != 0); } else { System.out.println("ERRO: Arquivo não existe"); } } } Resultado do Programa: Arquivo: /Users/pluzzardi/palavras.dat <enter> Total de Palavras: 5 Posição [1..5] ou [0] Sair: 1 <enter> Palavra: carambola <enter> Posição [1..5] ou [0] Sair: 2 <enter> Palavra: beringela <enter> Posição [1..5] ou [0] Sair: 3 <enter> Palavra: abacate <enter> Posição [1..5] ou [0] Sair: 4 <enter> Palavra: ervilha <enter> Posição [1..5] ou [0] Sair: 5 <enter> Palavra: damasco <enter> Posição [1..5] ou [0] Sair: 6 <enter> ERRO: Posição Inválida Posição [1..5] ou [0] Sair: 0 <enter>

14.5 Arquivo Texto A seguir é mostrado um programa que lê um arquivo texto contendo:

a) Total de Palavras b) Lista de Palavras (nome de frutas)

Arquito Texto: Frutas.txt 15 abacaxi abacate banana pitanga goiaba morango carambola kiwi laranja bergamota tomate uva caqui lima jaca

// ---------------------------------------------- Fonte: Leitura.java

117

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); 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;

118

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"); } } } 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");

119

} } } 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) 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"); } } }

120

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 { 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).

121

// -------------------------------------------------------- Fonte: ReadDados.java

package readdados; import java.io.File; import java.io.FileReader; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.Scanner; public class ReadDados { public static void main(String[] args) throws Exception { Scanner entrada = new Scanner(System.in); String diretorio = "/Users/pluzzardi/"; File arquivo = new File(diretorio, "Pessoa.dat"); FileInputStream in = new FileInputStream(arquivo); InputStreamReader conversor = new InputStreamReader(in); BufferedReader buffer = new BufferedReader(conversor); if (arquivo.exists()) { FileReader file = new FileReader(arquivo); String linha = buffer.readLine(); // lê todos os dados System.out.println("Linha: " + linha); String[] partes = linha.split(":"); int n = partes.length; System.out.println("Partes: " + n); for (int i = 0; i < n; i = i + 3) { System.out.println("Nome: " + partes[i]); System.out.println("Idade: " + Integer.parseInt(partes[i + 1])); System.out.println("Sexo: " + partes[i + 2]); } file.close(); buffer.close(); } else { System.out.println("ERRO: Arquivo já existe"); } System.exit(0); } } Resultado do Programa: Linha: Paulo Roberto:51:m:Rento Luis:49:m:Francisco Carlos:53:m: Partes: 9 Nome: Paulo Roberto Idade: 51 Sexo: m Nome: Rento Luis Idade: 49 Sexo: m Nome: Francisco Carlos Idade: 53 Sexo: m

14.6 Lista de exercícios (arquivos) 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

122

(44) Linhas ou ERRO: Arquivo não existe 14.6.2 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário consultar o arquivo através da entrada via teclado do número da linha. O programa deve imprimir a linha especificada ou ERRO: Linha não existe (zero para abandonar). Exemplo: Nome do arquivo texto: LISTA.JAVA <enter> Número de linha: 7 <enter> 7: int i, j, k; Número de linha: 70 <enter> ERRO: Linha não existe Número de linha: 0 <enter> // saída do programa ERRO: Arquivo não existe 14.6.3 Escreva um programa em Java que recebe via teclado o nome de dois arquivos texto (origem e destino). O programa deve copiar o conteúdo do arquivo origem para o arquivo destino. Exemplo: Arquivo origem: LISTA.JAVA <enter> Arquivo destino: LISTA.tmp <enter> (20345) Bytes copiados 14.6.4 Escreva um programa em Java que recebe via teclado o nome do arquivo texto fonte e o nome do arquivo texto destino. O programa deve converter o arquivo para maiúsculo ou minúsculo (conforme escolha do usuário) gerando o arquivo texto destino. Exemplo: Arquivo fonte: LISTA.JAVA <enter> Arquivo destino: LISTA.TMP <enter> [+] Maiúsculo ou [-] Minúsculo: + <enter> (1234) Bytes convertidos 14.6.5 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto e uma palavra. O programa deve imprimir todas as linhas que possuem esta palavra. 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) {

123

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 texto: LISTA.JAVA <enter> Número inicial: 7 <enter> Número final: 9 <enter> 7: int i, j, k; 8: char tecla; 9: long bytes = 0; ou Número inicial: 70 <enter> Número final: 90 <enter> ERRO: Linhas não existem 14.6.7 Escreva um programa em Java (grava.java) que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário inserir nomes neste arquivo via teclado. O programa termina quando o usuário digitar <enter> na entrada do nome. Exemplo: Nome do arquivo texto: NOMES.TXT <enter> Nome: Beatriz <enter> Nome: Eva <enter> Nome: Debora <enter> Nome: Carla <enter> Nome: Fatima <enter> Nome: Ana <enter> Nome: <enter> 14.6.8 Escreva um programa em Java (ler.java) que recebe via teclado o nome de um arquivo texto. O programa deve ler e imprimir na tela todos os nomes armazenados no arquivo pelo programa "grava.java". Exemplo: 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

124

Observação: Utilize o programa anterior (ler.java) para ver os nomes ordenados. 14.6.10 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário inserir nome, idade e sexo ([M]asculino ou [F]eminino) neste arquivo via teclado. O programa termina quando o usuário digitar <enter> na entrada do nome. Exemplo: Nome do arquivo texto: DADOS.TXT <enter> Nome: Paulo Roberto <enter> Idade: 41 <enter> Sexo [M/F]: m <enter> Nome: Renato Luis <enter> Idade: 38 <enter> Sexo [M/F]: m <enter> Nome: Ana Maria <enter> Idade: 44 <enter> Sexo [M/F]: f <enter> Nome: <enter> 14.6.11 Escreva um programa em Java que recebe via teclado o nome de um arquivo texto. O programa deve ler e imprimir na tela todos os dados (nome, idade e sexo) armazenados no arquivo pelo programa "14.6.10" (veja exemplo abaixo). Exemplo: Nome do arquivo texto: DADOS.TXT <enter> Nome: Paulo Roberto Idade: 41 Sexo: MASCULINO Nome: Renato Luis Idade: 38 Sexo: MASCULINO Nome: Ana Maria Idade: 44 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;

125

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"); } } } 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 java.io.File; import java.io.ObjectOutputStream; import java.io.FileOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner;

126

public class BinaryWrite { public static void main(String[] args) throws IOException { Scanner input = new Scanner(System.in); String s; ArrayList pessoa = new ArrayList(); System.out.print("Nome do Arquivo Binário: "); String nomeArquivo = input.nextLine(); try { File file = new File(nomeArquivo); ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(file)); do { System.out.print("Nome: "); String nome = input.nextLine(); System.out.print("Idade: "); s = input.nextLine(); int idade = Integer.parseInt(s); System.out.print("Sexo [M/F]: "); s = input.nextLine(); char sexo = s.charAt(0); pessoa.add(nome); pessoa.add(idade); pessoa.add(sexo); do { System.out.print("Continua [S/N]? "); s = input.nextLine(); } while ("SsNn".indexOf(s) == -1); } while ("Nn".indexOf(s) == -1); output.writeObject(pessoa); // grava ArrayList output.close(); } catch (Exception e) { System.out.println(e.toString()); } } } Resultado do Programa: Nome do Arquivo Binário: /Users/pluzzardi/pessoa.dat <enter> Nome: Paulo <enter> Idade: 51 <enter> Sexo [M/F]: m <enter> Continua [S/N]? s <enter> Nome: Renato <enter> Idade: 49 <enter> Sexo [M/F]: M <enter> Continua [S/N]? s <enter> Nome: Francisco <enter> Idade: 53 <enter> Sexo [M/F]: m <enter> Continua [S/N]? s <enter> Nome: Ana <enter> Idade: 55 <enter> Sexo [M/F]: f <enter> Continua [S/N]? s <enter> Nome: Julia <enter> Idade: 54 <enter> Sexo [M/F]: F <enter> Continua [S/N]? N <enter> // ---------------------------------------------- Fonte: BinaryRead.java package binaryread; import java.io.File; import java.io.FileInputStream; import java.io.ObjectInputStream; import java.util.ArrayList; import java.util.Scanner;

127

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]

128

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).

129

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 ... x += 10; Esta forma abreviada funcionará com todos os operadores aritméticos de Java. Forma normal: variável = variável operador constante; x = x + 7; Forma abreviada: variável operador= constante; x += 7;

130

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 Entrada: 1, 2 e 3 Saída: 3, 2 e 1 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;

131

import javax.swing.*; public class Prog51 { final static int SUCESSO = 0; final static int LISTA_CHEIA = 1; final static int LISTA_VAZIA = 2; public static void main(String[] args) { final int m = 7; int [] v = new int [m]; int valor; int erro = 0; criaLista(v); do { String s = JOptionPane.showInputDialog("Elemento: "); valor = Integer.parseInt(s); if (valor != 0) erro = incluiFim(m, v, valor); if (erro == LISTA_CHEIA) { JOptionPane.showMessageDialog(null, "Erro: Lista Cheia", "Atenção", JOptionPane.PLAIN_MESSAGE); exibeLista(v); return; } } while (valor != 0); exibeLista(v); } // -------------------------------------------------- criaLista static void criaLista(int [] v) { v[0] = 0; // armazena o número de elementos da lista } // -------------------------------------------------- incluiFim static int incluiFim(int m, int [] v, int valor) { int n = v[0]; if (n < m-1) { v[0]++; v[v[0]] = valor; return(SUCESSO); } else return(LISTA_CHEIA); } // -------------------------------------------------- exibeLista static void exibeLista(int [] v) { String s = ""; int n = v[0]; if (n == 0) JOptionPane.showMessageDialog(null, "Erro: Lista Vazia", "Atenção", JOptionPane.PLAIN_MESSAGE); else { for (int i = 1; i <= n; i++) s = s + v[i] + " "; JOptionPane.showMessageDialog(null, "Lista: " + s, "Lista", JOptionPane.PLAIN_MESSAGE); } } }

132

Programa exemplo (51): O programa permite inserir ([I]nício, [P]osição ou [F]im) números inteiros em uma Lista Linear implementada em um vetor. Quando o número digitado for igual à zero (0), todos os números da lista são exibidos na tela. // --------------------------------------------------------- Fonte: Prog51.java package prog51; import javax.swing.*; public class Prog51 { final static int SUCESSO = 0; final static int LISTA_CHEIA = 1; final static int LISTA_VAZIA = 2; public static void main(String[] args) { final int m = 7; int [] v = new int [m]; String s; int valor, pos, n; char ch, op; int erro = 0; criaLista(v); do { s = JOptionPane.showInputDialog("Elemento: "); valor = Integer.parseInt(s); if (valor != 0) { s = JOptionPane.showInputDialog( "[I]inicio, [P]osição ou [F]im: "); op = s.charAt(0); switch (op) { case 'I': case 'i': erro = incluiInic(m, v, valor); break; case 'P': case 'p': n = tamanhoLista(v); do { s = JOptionPane.showInputDialog( "Posição [1.." + n + "]: "); pos = Integer.parseInt(s); } while (pos < 1 && pos > n); erro = incluiPos(m, v, valor, pos); break; case 'F': case 'f': erro = incluiFim(m, v, valor); break; } if (erro == LISTA_CHEIA) { JOptionPane.showMessageDialog(null, "Erro: Lista Cheia", "Atenção", JOptionPane.PLAIN_MESSAGE); exibeLista(v); return; } } } while (valor != 0); exibeLista(v); } // -------------------------------------------------- criaLista static void criaLista(int [] v) { v[0] = 0; // armazena o número de elementos } // -------------------------------------------------- incluiFim

133

static int incluiFim(int m, int [] v, int valor) { int n = v[0]; if (n < m - 1) { v[0]++; v[v[0]] = valor; return(SUCESSO); } else return(LISTA_CHEIA); } // -------------------------------------------------- incluiInic static int incluiInic(int m, int [] v, int valor) { int n = v[0]; if (n < m - 1) { v[0]++; for (int i = n + 1;i >= 2;i--) v[i] = v[i-1]; v[1] = valor; return(SUCESSO); } else return(LISTA_CHEIA); } // -------------------------------------------------- incluiPos static int incluiPos(int m, int [] v, int valor, int pos) { int n = v[0]; if (n < m - 1) { v[0]++; if (pos == v[0] - 1) { v[v[0]] = v[n]; v[n] = valor; } else { for (int i = n + 1;i >= pos;i--) { v[i] = v[i-1]; System.out.println("Valor: " + v[i]); } v[pos] = valor; } return(SUCESSO); } 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,

134

"Erro: Lista Vazia", "Atenção", JOptionPane.PLAIN_MESSAGE); else { for (int i = 1; i <= n; i++) s = s + v[i] + " "; JOptionPane.showMessageDialog(null, "Lista: " + s, "Lista", JOptionPane.PLAIN_MESSAGE); } } }

16.2 Implementação de uma Pilha A seguir é mostrado uma implementação de Pilha usando a classe Pilha. Programa exemplo (52): O programa permite inserir números inteiros em uma Pilha usando uma classe Pilha implementada pelo programador. Quando o número digitado for igual à zero (0), todos os números da pilha são listados. // -------------------------------------------------------- Fonte: Prog52.java package prog52; import java.util.Scanner; public class Prog52 { public static void main(String[] args) { Pilha pilha = new Pilha(5); Scanner entrada = new Scanner(System.in); String s; int nodo; do { System.out.print("Elemento: "); s = entrada.nextLine(); nodo = Integer.parseInt(s); if (nodo != 0) pilha.push(nodo); } while (nodo != 0); pilha.exibe(); } } // ---------------------------------------------------------- Fonte: Pilha.java package prog52; public class Pilha { private int topo; private int [] dados; // ----------------------------------------------- construtor public Pilha(int numElementos) { // construtor dados = new int[numElementos]; topo = -1; } // ------------------------------------------------ push public void push(int i) { int n = dados.length; if (topo < n-1) { topo++; dados[topo] = i; } else

135

System.out.println("Erro: Pilha Cheia"); } // ------------------------------------------------ pop public int pop() { if (topo != 0) { int valor = dados[topo]; topo--; return(valor); } else return(0); } // ------------------------------------------------ exibe public void exibe() { System.out.print("Pilha: "); for (int i = 0;i <= topo;i++) { System.out.print(dados[i] + " "); } System.out.println(); } } Resultado do Programa: Elemento: 50 <enter> Elemento: 40 <enter> Elemento: 30 <enter> Elemento: 20 <enter> Elemento: 10 <enter> Elemento: 5 <enter> Erro: Pilha Cheia Elemento: 0 <enter> Pilha: 10 20 30 40 50

16.3 Implementação de uma Fila 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)

136

System.out.println("Fila: Vazia"); else { while (nodo != 0) { nodos = nodos + nodo + " "; nodo = fila.retiraFila(); } System.out.println("Fila: " + nodos); } } } // --------------------------------------------------- Fonte: Pilha.java // Fila.java package prog53; public class Fila { private int inic, fim, n; private int [] dados; // ---------------------------------------- construtor public Fila(int numElementos) { // construtor inic = -1; fim = 0; n = 0; dados = new int[numElementos]; } // ------------------------------------------------ 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

137

Um problema que ocorre em estruturas de dados do tipo Fila é que após algumas operações de inserção e remoção de elementos, pode existir nodos vagos que não podem ser reaproveitados, pois normalmente uma fila possui três informações que a controlam: primeiro, último e número de elementos, não permitindo que os nodos excluídos sejam ocupados novamente. Uma forma de resolver este problema, é a utilização de uma Fila Circular, onde todo nodo inserido ou removido tem sua posição calculada por uma equação, fazendo com que, desta forma, sempre todos os nodos sejam reocupados com uma informação. Programa exemplo (54): O programa permite inserir números inteiros em uma Fila Circular, ou seja, existe reaproveitamento da fila. Quando o número digitado for igual à zero (0), todos os números da fila são listados. // ------------------------------------------------------------ Fonte: prog54.java package prog54; import java.util.Scanner; public class Prog54 { public static void main(String[] args) { FilaCircular fila = new FilaCircular(5); Scanner entrada = new Scanner(System.in); 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

138

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 { tamanho--; int temp = primeiro; primeiro = (primeiro + 1) % n; return(elem[temp]); } } // -------------------------------- exibeFilaCircular public void exibeFilaCircular() { int n = elem.length; if (tamanho == 0) { System.out.println("Fila Circular: Fila Vazia"); } else { int temp = primeiro; System.out.print("Fila Circular: "); for (int i = 1;i <= tamanho;i++) { System.out.print(elem[temp] + " "); temp = (temp + 1) % n; } System.out.printf("\n"); } } } Resultado do Programa: [I]ncluir, [E]xcluir ou [F]im? i <enter> Valor: 10 <enter> [I]ncluir, [E]xcluir ou [F]im? i <enter> Valor: 20 <enter> [I]ncluir, [E]xcluir ou [F]im? i <enter> Valor: 30 <enter> [I]ncluir, [E]xcluir ou [F]im? i <enter> Valor: 40 <enter> ERRO: Fila Cheia [I]ncluir, [E]xcluir ou [F]im? e <enter> Elemento Retirado da Fila: 10 [I]ncluir, [E]xcluir ou [F]im? e <enter> Elemento Retirado da Fila: 20 [I]ncluir, [E]xcluir ou [F]im? i <enter> Valor: 50 <enter> [I]ncluir, [E]xcluir ou [F]im? i <enter> Valor: 60 <enter> [I]ncluir, [E]xcluir ou [F]im? i <enter> Valor: 70 <enter>

139

ERRO: Fila Cheia [I]ncluir, [E]xcluir ou [F]im? f <enter>

140

17. Tratamento de erros Na execução de um programa em Java, podem ocorrer erros não previstos que podem interromper a execução normal do programa. Tais erros podem ser:

• Conversão numérica inválida; • Limite de um vetor (acessor a índice inválido); • Problemas com arquivos: abertura, criação ou caminho; • Overflow; • Erro de entrada e saída (input/output); • Divisão por zero; • Validação de dados.

Em Java, o programa tem condições de assumir o controle da execução em caso que ocorra uma situação de erro não prevista. Isso é feito através do mecanismo de tratamento de exceções que ao detectar uma situação de erro, a máquina virtual Java gera uma exceção. Se o programa que estiver sendo executado possuir um tratamento de exceções, ele assume o controle da execução. Mas se a exceção não tiver um tratamento associado, o programa é interrompido e a máquina virtual Java gera uma mensagem de erro. Uma exceção é um evento que indica uma condição anormal que interrompe a execução normal de um programa.

O tratamento de erros no Java cria objetos da classe erro, o tratamento destes erros é feita

pela manipulação destes objetos. O tratamento de erros em Java basea-se em: try {} catch {} finally {}.

A execução de um bloco de código, protegido por um tratamento de erros, é feito colocando o

bloco no try, e para cada erro que se deseja tratar, deve-se colocar uma cláusula catch (tipo_de_erro variável_erro) {} e/ou uma cláusula finally (opcional) que é executada após a execução do bloco try se não houver erro. Sintaxe: try { // código fonte normal return; } catch (Exception error) { // código que trata um tipo de erro ou mostra o erro } catch (Exception error) { // código que trata outro tipo de erro ou exibe o erro } finally { // opcional // código executado, mesmo tendo excessão }

17.1 Tratamento de exceções

141

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).

142

// ------------------------------------------------------ Fonte: Divisao.java package divisao; import java.util.Scanner; public class divisao { public static void main (String args[]) { Scanner entrada = new Scanner(System.in); String s; float x, y, div = -999; try { System.out.print("Dividendo: "); s = entrada.nextLine(); x = Float.parseFloat(s); System.out.print("Divisor: "); s = entrada.nextLine(); y = Float.parseFloat(s); div = x / y; System.out.println ("Divisao: " + div); } catch (NumberFormatException error) { System.out.println("Status: " + error.getMessage()); } catch (ArithmeticException error) { // não funcinou System.out.println ("Divisao: " + div); } System.exit(0); } } Resultado do Programa (sem erro): [usuário digitou “3” + “2”] Dividendo: 3 Divisor: 2 Divisao: 1.5 Resultado do Programa (sem erro): [usuário digitou “3” + “0”] Dividendo: 3 Divisor: 0 Divisao: Infinity Resultado do Programa (com erro): [usuário digitou “abc”] Dividendo: abc Status: For input string: "abc"

17.4 Tratamento de exceção com Exception Em java pode-se usar o try ... catch da seguinte forma: // --------------------------------------------------------- Fonte: Teste.java package teste; import java.util.Scanner; 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 {

143

System.out.print("Dividendo: "); s = entrada.nextLine(); x = Integer.parseInt(s); System.out.print("Divisor: "); s = entrada.nextLine(); y = Integer.parseInt(s); div = (float) x / y; System.out.println("Divisao: " + div); } catch (Exception error) { error.printStackTrace(); System.out.println("Status: Divisao por zero"); } } } Resultado do Programa (sem erro): [usuário digitou “3” + “2”] Dividendo: 3 Divisor: 2 Divisao: 1.5 Resultado do Programa (sem erro): [usuário digitou “3” + “0”] Dividendo: 3 Divisor: 0 Divisao: Infinity

17.5 Tratamento de exceção com MyException Em java pode-se criar uma exceção da seguinte forma: // ----------------------------------------------------------- Fonte: MyException.java package myexception; class MyException extends Exception { public MyException(String msg) { super(msg); } } // --------------------------------------------------------- Fonte: Myexception.java package myexception; import java.util.Scanner; public class Main { public static void main(String[] args) throws Exception{ Scanner entrada = new Scanner(System.in); String s; int x, y; float div; System.out.print("Dividendo: "); s = entrada.nextLine(); x = Integer.parseInt(s); System.out.print("Divisor: "); s = entrada.nextLine(); y = Integer.parseInt(s); div = (float) x / y; if (y == 0) { throw new MyException("Erro: Divisao por zero"); // não funcionou } System.out.println("Divisao: " + div); } }

17.6 Exceção em ArrayList

144

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 { 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 pelo 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;

145

nome = s; } // ------------------------------------- getNome public String getNome() { return(this.nome); } // ------------------------------------- getCodigo public int getCodigo() { return(this.codigo); } } // -------------------------------------------------------- Fonte: ListObjet.java package listaobjeto; public class ListObjet { private Object [] v; private int n; // ------------------------------------- Construtor public ListObjet(int n) { v = new Object[n]; n = 0; } // ------------------------------------- getTamanho public int getTamanho() { return(n); } // ------------------------------------- incluiFim public void incluiFim(Object nodo) { if (n == v.length) { throw new ListaCheiaException(); } 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); } }

146

// ------------------------------------- IndiceInvalidoException public class IndiceInvalidoException extends RuntimeException { public IndiceInvalidoException () { super("Indice Invalido"); } public IndiceInvalidoException (String s) { super(s); } } } // ------------------------------------------------------ Fonte: ListaObjeto.java package listaobjeto; public class ListaObjeto { public static void main(String[] args) { ListObjet lista = new ListObjet(3); lista.incluiFim(new Aluno(10, "Ana")); lista.incluiFim(new Aluno(20, "Beatriz")); lista.incluiFim(new Aluno(30, "Carla")); // lista.incluiFim(new Aluno(40, "Debora")); // tente rodar com esta linha int tam = lista.getTamanho(); for (int i = 0;i < tam;i++) { // tenta rodar com (i <= tam) Aluno aluno = (Aluno) lista.consulta(i); System.out.println(aluno.getNome() + "(" + aluno.getCodigo() + ")"); } } } Resultado do Programa (sem erro): 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

147

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)

ü 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.

ü private (privado)

ü 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 é:

Especificador_de_acess class nome_classe_derivada extends nomeclasse_base {

// atributos

// métodos

}

148

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); } } // ---------------------------------------------------------- Fonte: Derivada.java package heranca; public class Derivada extends Base { private int z; public Derivada(int x) { z = x; System.out.println("z = " + z); }

149

public int Somador(int soma) { // não é possível acessar x e y pois são privados da classe base return(soma + z); } } Resultado do Programa: z = 3 x = 1 y = 2 Soma (x + y): 3 Somador (x + y + z): 6 Responda: Porque o atributo z é mostrado primeiro?

18.3 Tipos de acessos (especificadores de acesso)

ü public (público): Todos os atributos da classe base são públicos na classe derivada. ü private (privado): Os atributos só podem ser acessados pelos métodos que fazem parte da

classe. ü protected (protegido): Os atributos podem ser acessados pelos métodos de classes derivadas.

Programa exemplo (56): O objetivo do programa é demonstrar a utilização de herança simples (atributos da classe base são protegidos). // ---------------------------------------------------------- Fonte: Heranca.java package heranca; public class Heranca { public static void main(String[] args) { Derivada objeto = new Derivada(3); int resp; objeto.Seta(1, 2); resp = objeto.Soma(); System.out.println("Somador (x + y + z): " + objeto.Somador(resp)); } } // ----------------------------------------------------------- Fonte: base.java package heranca; 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 {

150

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 faz uma chamada ao construtor padrão da classe-pai. // ------------------------------------------------------------ Fonte: Derivada.java

package heranca; public class Derivada extends Base { private int z; public Derivada(int x) { super(10, 20); // chamada formal ao construtor da classe pai //super(); z = x; System.out.println("z = " + z); } public int Somador(int soma) { return(x + y + z); // é possível acessar x e y pois são privados a classe base } protected void finalize() { System.out.println("Derivada: Final"); } } // ------------------------------------------------------------ Fonte: Base.java

// A palavra-chave super permite acesso ao construtor da superclasse (base) // se for utilizada como nome de método, executa o construtor da superclasse // // Nota-se que se não houver, no construtor da subclasse, nenhuma chamada // explicita ao construtor da superclasse, o construtor sem argumento é // chamado por "default". Se for incluída uma chamada ao construtor da // superclasse, ela deve ser o primeiro comando executado no construtor // da subclasse. package heranca; public class Base { protected int x, y; // atributos protegidos Base() { // construtor default this.x = 0; this.y = 0; System.out.println("x = " + this.x + " - y = " + this.y); } Base(int a, int b) {

151

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(); } } // ----------------------------------------------------------------------- Pessoa.java package testaheranca; public class Pessoa {

152

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; Pessoa() { this.altura = 0.0;

153

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) {

154

Linha linha = new Linha(1, 2, 3, 4); Retangulo retangulo = new Retangulo(1, 2, 3, 4); System.out.println("Linha: "); linha.imprimeLinha(); System.out.println("Retângulo: "); retangulo.imprimeRetangulo(); } } // ------------------------------------------------------------------------ Objeto.java package testaobjetos; public class Objeto { protected int x; protected int y; Objeto() { x = 0; y = 0; } 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 = 2 x = 3 - y = 4 Retângulo: x = 1 - y = 2 x = 3 - y = 2 x = 3 - y = 4 x = 1 - y = 4

155

156

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.Somador(resp)); objeto = null; // marca para coletor de lixo System.gc(); // chamada do coletor de lixo System.out.println("Somador (x + y + z): " + objeto.Somador(resp)); } } // ------------------------------------------------ Fonte: base.java package heranca; public class Base { protected int x, y; // atributos protegidos public void Seta(int a, int b) { x = a; y = b; System.out.println("x = " + x); System.out.println("y = " + y); } public int Soma() { System.out.println("Soma (x + y): " + (x + y)); return(x + y); } } // --------------------------------------------------- Fonte: Derivada.java package heranca; public class Derivada extends Base { private int z; public Derivada(int x) { z = x; System.out.println("z = " + z); } public int Somador(int soma) { return(x + y + z); // é possível acessar x e y pois são privados a classe base } } Resultado do Programa: Observação: O erro se deve ao objeto ter sido desalocado pelo coletor z = 3 de lixo x = 1 y = 2 Soma (x + y): 3 Somador (x + y + z): 6 Derivada: Final Exception in thread "main" java.lang.NullPointerException

157

at testacoletorlixo.TestaColetorLixo.main(TestaColetorLixo.java:14) Java Result: 1

20. Construtor e finalizador em Java Em Java, uma classe além de poder ter um construtor, pode ter um finalizador (método: protected void finalize) que é executado automaticamente no término do programa. Veja o exemplo a seguir: // -------------------------------------------------------- Fonte: base.java package heranca; public class Base { protected int x, y; // atributos protegidos public void Seta(int a, int b) { x = a; y = b; System.out.println("x = " + x); System.out.println("y = " + y); } public int Soma() { System.out.println("Soma (x + y): " + (x + y)); return(x + y); } } // ---------------------------------------------------- Fonte: Derivada.java package heranca; public class Derivada extends Base { private int z; public Derivada(int x) { z = x; System.out.println("z = " + z); } public int Somador(int soma) { return(x + y + z); // é possível acessar x e y pois são privados a classe base } protected void finalize() { System.out.println("Finalizador: Final do programa"); } } // --------------------------------------------------------- Fonte: Heranca.java package heranca; public class Heranca { public static void main(String[] args) { Derivada objeto = new Derivada(3); int resp; 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

158

y = 2 Soma (x + y): 3 Somador (x + y + z): 6 Finalizador: Final do Programa

159

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();

160

super.paint(g); g.drawString("Calculadora 1.0 by Luzzardi", 300, 270); g.drawLine(0, 280, 1279, 280); if (erro == 0) { g.drawString("Resposta: " + resp, 340, 300); } else { switch (erro) { case 1: g.drawString("Erro: Divisao por Zero", 340, 300); break; case 2: g.drawString("Erro: Raiz Complexa", 340, 300); break; case 3: g.drawString("Erro: Tangente Infinita", 340, 300); break; } } g.drawLine(0, 310, 1279, 310); } } // ------------------------------------------------- Fonte: Calculadora.java import java.awt.Graphics; import javax.swing.*; public class Calculadora { private double x, y, resp; private char op; private int erro; public Calculadora () { // construtor erro = 0; } // -------------------------------- 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 '+': resp = soma(x, y); break; case '-': resp = subtracao(x, y); break; case '*': resp = multiplicacao(x, y); break; case '/': if (y == 0)

161

erro = 1; // divisão por zero else resp = divisao(x, y); break; case 'R': case 'r': if (x < 0) erro = 2; // raiz negativa else resp = raizQuadrada(x); // Raiz Quadrada break; case 'P': case 'p': resp = power(x, y); // potência break; case 'S': case 's': resp = seno(x); // seno break; case 'C': case 'c': resp = cosseno(x); // cosseno break; case 'T': case 't': 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

162

private double raizQuadrada(double x) { return(Math.sqrt(x)); } // ---------------------------- power private double power(double x, double y) { return(Math.pow(x, y)); } // ---------------------------- seno private double seno(double x) { final double pi = 3.14158; double rads; rads = x * pi / 180.0; return(Math.sin(rads)); } // ---------------------------- cosseno private double cosseno(double x) { final double pi = 3.14158; double rads; rads = x * pi / 180.0; return(Math.cos(rads)); } // ---------------------------- tangente private double tangente(double x) { final double pi = 3.14158; double rads; rads = x * pi / 180.0; return(Math.tan(rads)); } }

Inserção da Applet em um documento HTML:

<HTML> <APPLET code= "CalcApplet.class" width= "1280" height="800" > </APPLET> </HTML>

Para compilar a Applet:

$ javac Calculadora.java <enter> // é gerado Calculadora.class $ javac CalcApplet.java <enter> // é gerado CalcApplet.class $

Para testar a Applet:

$ appletviewer CalcApplet.html <enter> $

163

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.

164

23. Sockets em Java Socket é um mecanismo para comunicação de programas em dois sentidos que funcionam em uma rede de computadores. O pacote “java.net” possui duas classes principais: Socket (cliente) e ServerSocket (servidor) quando uma conexão entre cliente-servidor é realizada. O cliente solicita que uma conexão seja estabelida com o servidor através de um Socket. Quando o servidor aceita o pedido de conexão, ele cria um novo socket por uma porta diferente. No cliente, outro socket é criado e então é utilizado para a comunicação com este servidor. A seguir são vistos dois fontes: Server.java (Servidor) e Client.java (liente). // --------------------------------------------------------- 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 //Socket clientSocket = new Socket("200.132.45.130", 6789);

165

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$

166

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

167

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 operadores para realizar vários tipos de operações;

• Sobrecarga de Método: Permite que um método retorne diferentes tipos de informações e

aceita argumentos de vários tipos, inclusive com número diferentes de parâmetros;

168

• Classes abstratas e concretas: Permite representar entidades e conceitos abstratos, sendo sempre uma superclasse (ou classe Base) e não permite ser instanciada, a classe abstrata apenas define um modelo (template) para uma funcionalidade e fornece uma implementação incompleta que é herdada pelas classes derivadas. Cada classe derivada implementa as funcionalidades da classe abstrata. Uma classe abstrata pode possuir métodos abstratos, mas os métodos são escritos nas classes derivadas concretas. Métodos abstratos definem apenas a forma do método não contendo nenhum tipo de código. Classes concretas implementam todos os métodos e podem ser instanciadas.

Herança: É o processo pelo qual uma classe de objetos pode adquirir as propriedades de outra classe de objetos, em outras palavras, um objeto herda as características de outro (herança simples) ou vários objetos (herança múltipla – Java não possui herança múltipla). Encapsulamento (encapsulação): Os objetos possuem internamente atribu-tos e métodos agrupados no mesmo local, onde os métodos manipulam os atributos. UML (Unified Modeling Language) A linguagem UML especifica 9 tipos de diagramas para modelagem de sistemas orientados à objetos. Cada diagrama UML permite modelar uma distinta característica ou da estrutura ou do comportamento do sistema em especial. Os 4 primeiros, 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 relaciona-mentos em determinado

ponto no tempo (comportamento estático). • Diagrama de Componentes: Exibe as dependências entre componentes do sistema. São utilizados

para: (a) modelar a organização do código fonte; (b) modelar a chamada de programas externos; (c) modelar o banco de dados; (d) modelar sistemas adaptativos e (e) Engenharia de produção e Engenharia reversa.

• Diagrama de Instalação: Exibe a configuração dos nodos de processamento em tempo de execução e os componentes existentes.

• Diagrama de Atividades: São utilizados para detalhar classes, a implementação de operações e casos de uso.

• Diagrama de Mapa de Estados: Exibe o ciclo de vida de um objeto em níveis de detalhe simples ou complexos. Mostra a seqüência de estados que um objeto ou a interação percorrida durante sua vida em resposta a estímulos recebidos e as próprias ações e respostas (comportamento dinâmico).

• Diagrama de Colaborações: Modela as interações entre objetos. É focado na seqüência cronológica de uma situação que está sendo modelado, focalizando no relacionamento entre os objetos e na compreensão dos efeitos sobre um objeto durante uma situação.

• Diagrama de Sequência: Modela a interação entre objetos em um sistema. Apresenta os objetos e as mensagens (métodos) que são passadas entre estes objetos dentro do caso de uso.

• Diagrama de Casos de Uso: Exibe os usuários e a relação entre os usuários e os casos de uso. Diagrama de Classe: Pilha e Fila

Figura 5: Exemplos de Diagrama de Classes

169

170

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.

171

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 String: Paulo Roberto Objeto Inteiro: 48 Objeto Pilha: 123 Valor: 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;

172

System.out.print("Numero de Objetos: "); s = entrada.nextLine(); n = Integer.parseInt(s); Object [] objeto = new Object[n]; // vetor de objetos for (int i = 0;i < n;i++) { System.out.print("Nome: "); s = entrada.nextLine(); objeto[i] = s; } for (int i = n-1;i >= 0;i--) { System.out.println("String: " + objeto[i]); } } } Resultado do Programa: Número de Objetos: 4 Nome: paulo Nome: roberto Nome: gomes Nome: luzzardi String: luzzardi String: gomes String: roberto String: paulo A seguir são descritos os métodos da classe Object. Sintaxe: protected Object clone(); Cria e retorna uma cópia deste objeto. Sintaxe: boolean equals(Object obj); Indica se um objeto é igual a outro. Sintaxe: protected void finalize(); Chama o coletor de lixo do objeto quando a coletor de lixo determina que não há mais referências ao objeto. Sintaxe: Class getClass(); Retorna a classe “runtime” do objeto. Sintaxe: int hashCode(); Retorna o valor do código “hash” de um objeto. Sintaxe: void notify(); Aguarda uma thread que está esperando o monitor do objeto. Sintaxe: void notifyAll(); Aguarda todas as threads que estão esperando o monitor do objeto. Sintaxe: String toString(); 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.

173

Sintaxe: void wait(long timeout, int nanos); Faz a corrente thread esperar até que outra thread invoque os métodos notify() ou notifyAll() deste objeto, ou outra thread interrompa a corrente thread, ou um período especificado de tempo tiver decorrido.

28. Classe ArrayDeque

Java possui classes pré-definidas para trabalhar com Deque: ArrayDeque, LinkedBlockingDeque e LinkedList. Construtores: ArrayDeque() Construi um deque em um array vazio com 16 elements. ArrayDeque(int numElements); Construi um deque em um array vazio com numElements elementos. A seguir são descritos os métodos da classe ArrayDeque. Sintaxe: boolean add(E e); Insere um elemento especificado no fim do deque. Sintaxe: void addFirst(E e); Insere um elemento especificado na frente do deque. Sintaxe: void addLast(E e); Insere um elemento especificado no fim do deque. Sintaxe: void clear(); Remove todos os elementos deste deque. Sintaxe: ArrayDeque<E> clone(); Returna uma cópia deste deque. Sintaxe: boolean contains(Object o); Returna true se este deque contém o elemento especificado. Sintaxe: Iterator<E> descendingIterator(); Returna um iterator sobre os elementos neste deque em ordem sequencial reversa. Sintaxe: E element(); 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.

174

Sintaxe: boolean offer(E e); Insere um elemento especificado no fim deste deque. Sintaxe: boolean offerFirst(E e); Insere um elemento especificado na frente deste deque. Sintaxe: boolean offerLast(E e); Insere um elemento especificado no fim deste deque. Sintaxe: E peek(); Recupera, mas não remove, o cabeça da fila representada por este deque ou returna null se este deque está vazio. Sintaxe: E peekFirst(); Recupera, mas não remove, o primeiro elemento deste deque, ou retorna null se este deque está vazio. Sintaxe: E peekLast(); Recupera, mas não remove, o último elemento deste deque ou returna null se este deque está vazio. Sintaxe: E poll(); Recupera e remove o cabeça desta fila representada por este deque (em outras palavras, o primeiro elemento deste deque) ou returna null se este deque está vazio. Sintaxe: E pollFirst(); Recupera e remove o primeiro elemento deste deque ou returna null se este deque está vazio. Sintaxe: E pollLast(); Recupera e remove o último elemento deste deque ou returna null se este deque está vazio. Sintaxe: E pop(); Retira um elemento na pilha representada por este deque. Sintaxe: void push(E e); Insere um elemento na pilha representada por este deque. 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).

175

Sintaxe: int size(); Returna o número de elementos deste deque. Sintaxe: Object[] toArray(); Returna um array contendo todos os elementos deste deque em ordem crescente (do primeiro até o último elemento). Sintaxe: <T> T[] toArray(T[] a); Returna um array contendo todos os elementos deste deque em ordem crescente (do primeiro até o último elemento); o tipo do array retornado é aquela especificado pelo array.

A seguir é demonstrado a utilização de um ArrayDeque. Pacote: import java.util.ArrayDeque; // -------------------------------------------------- Fonte: Array_Deque.java package array_deque; import java.util.ArrayDeque; import java.util.Scanner; public class Array_Deque { public static void main(String[] args) { ArrayDeque deque = new ArrayDeque(); // 16 elementos Scanner entrada = new Scanner(System.in); String s; char tecla = 'f', op = 'f'; int nodo, n = 0; Object temp; do { System.out.println("Deque: " + deque); System.out.print("[I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: "); do { s = entrada.nextLine(); if (!s.equals("")) { 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':

176

case 'c': if (!deque.isEmpty()) { if (strChr("Ee", op)) { temp = deque.peekFirst(); } else { temp = deque.peekLast(); } nodo = temp.hashCode(); System.out.println("Consultado: " + nodo); } else { System.out.println("ERRO: Deque Vazio"); } break; case 'E': case 'e': if (!deque.isEmpty()) { if (strChr("Ee", op)) { temp = deque.pollFirst(); } else { temp = deque.pollLast(); } nodo = temp.hashCode(); System.out.println("Excluiu: " + nodo); n--; } else { System.out.println("ERRO: Deque Vazio"); } break; } } } while (!strChr("Ff", tecla)); } // ----------------------------------------------- strChr static boolean strChr(String s, char tecla) { 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 ou [F]inalizar: i [E]squerda ou [D]ireita: e Nodo: 10 Deque: [10] [I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: i [E]squerda ou [D]ireita: d Nodo: 20 Deque: [10, 20] [I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: i [E]squerda ou [D]ireita: d Nodo: 30 Deque: [10, 20, 30] [I]ncluir, [C]onsultar, [E]xcluir ou [F]inalizar: f

177

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

178

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);

179

fileOut.writeObject(registro.idade); fileOut.writeObject(registro.sexo); } // ------------------------------- closeFile public void closeFile() { try { if (fileOut != null) { fileOut.close(); System.out.println("Ok, Arquivo fechado: " + nomeFile); } } catch (IOException ioException) { System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile); System.exit(1); } } } // -------------------------------------------------------- WriteFile.java package writefile; import java.io.IOException; import java.util.Scanner; public class WriteFile { public static void main(String[] args) throws IOException, ClassNotFoundException { Scanner input = new Scanner(System.in); System.out.print("Nome do Arquivo Binário: "); String nomeArquivo = input.nextLine(); FileObjeto file = new FileObjeto(nomeArquivo); file.addFile("Paulo Roberto", 50, 'm'); file.addFile("Adriane Maria", 42, 'f'); file.addFile("Paola", 13, 'f'); file.closeFile(); } } Resultado do Programa: Nome do Arquivo Binário: /Users/pluzzardi/Objeto.dat Ok, Arquivo criado: /Users/pluzzardi/Objeto.dat Ok, Arquivo fechado: /Users/pluzzardi/Objeto.dat Observação: Por questões didáticas, simplificação, não foi testado se o arquivo binário existe, ou seja, se ele existir, será sobre-escrito. Solução 2: Nesta solução o usuário digita os nomes, idades e sexo das pessoas. // -------------------------------------------------------- Registro.java package writefile2; public class Registro { Object nome; Object idade; Object sexo; Registro(String nome, int idade, char sexo) { this.nome = nome; this.idade = idade; this.sexo = sexo; } } // -------------------------------------------------------- FileObjeto.java package writefile2;

180

import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; public class FileObjeto { // ------------------------------ atributos String nomeFile; private ObjectOutputStream fileOut; FileObjeto(String nomeArquivo) { nomeFile = nomeArquivo; try { fileOut = new ObjectOutputStream(new FileOutputStream(nomeFile)); System.out.println("Ok, Arquivo criado: " + nomeFile); } catch (IOException ioException) { System.out.println("ERRO Fatal: Problema na criação do Arquivo: " + nomeFile); } } // ------------------------------- addFile public void addFile(Registro registro) throws IOException, ClassNotFoundException { fileOut.writeObject(registro.nome); fileOut.writeObject(registro.idade); fileOut.writeObject(registro.sexo); } // ------------------------------- closeFile public void closeFile() { try { if (fileOut != null) { fileOut.close(); System.out.println("Ok, Arquivo fechado: " + nomeFile); } } catch (IOException ioException) { System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile); System.exit(1); } } } // -------------------------------------------------------- WriteFile2.java package writefile2; import java.io.IOException; import java.util.Scanner; public class WriteFile2 { public static void main(String[] args) throws IOException, ClassNotFoundException { 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);

181

System.out.print("Continua [S/N]? "); do { s = input.nextLine(); ch = s.charAt(0); } while (!strChr("SsNn", ch)); } while (strChr("Ss", ch)); file.closeFile(); } // ------------------------------- strChr static boolean strChr(String s, char ch) { int n = s.length(); for (int i = 0;i < n;i++) { if (s.charAt(i) == ch) { return(true); } } return(false); } } Resultado do Programa: Nome do Arquivo: /Users/pluzzardi/luz.dat Ok, Arquivo criado: /Users/pluzzardi/luz.dat Nome: Paulo Roberto Idade: 51 sexo [M]asculino ou [F]eminino: m Continua [S/N]? s Nome: Renato Luis Idade: 49 sexo [M]asculino ou [F]eminino: m Continua [S/N]? s Nome: Francisco Carlos Idade: 53 sexo [M]asculino ou [F]eminino: m Continua [S/N]? n Ok, Arquivo fechado: /Users/pluzzardi/luz.dat

30.2 Leitura objetos em um arquivo binário de objetos O programa abaixo permite carregar (ler) de um arquivo binário de objetos com as seguintes informações: nome, idade e sexo. // ------------------------------------- Registro.java package readfile; public class Registro { Object nome; Object idade; Object sexo; } // ------------------------------------------------------- FileObjeto.java package readfile; import java.io.FileInputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.EOFException; public class FileObjeto { // ------------------------------ atributos String nomeFile; private ObjectInputStream fileIn;

182

// ------------------------------ construtor FileObjeto(String nomeArquivo) { nomeFile = nomeArquivo; try { fileIn = new ObjectInputStream(new FileInputStream(nomeFile)); System.out.println("Ok, Arquivo Aberto: " + nomeFile); } catch (IOException ioException) { System.out.println("ERRO Fatal: Problema na Abertura do Arquivo: " + nomeFile); System.exit(1); } } // ------------------------------- getFile public void getFile() throws IOException, ClassNotFoundException { Registro registro = new Registro(); System.out.println("Nome Idade Sexo"); try { while (true) { registro.nome = fileIn.readObject(); registro.idade = fileIn.readObject(); registro.sexo = fileIn.readObject(); System.out.printf("%-20s %2d %c\n", registro.nome, registro.idade, registro.sexo); } } catch (EOFException endOfFileException) { } } // ------------------------------- closeFile public void closeFile() { try { if (fileIn != null) { fileIn.close(); System.out.println("Ok, Arquivo fechado: " + nomeFile); } } catch (IOException ioException) { System.out.println("ERRO Fatal: Impossível fechar o arquivo: " + nomeFile); System.exit(1); } } } // ------------------------------------------------------ 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

183

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

184

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).

185

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); } }

186

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 = "";

187

} 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 + '.';

188

copiou = true; } } } return (r.toCharArray()); } // -------------------------------------------------- retiraNegativosForaLugar private static String retiraNegativosForaLugar(String s) { String r = ""; int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) != '-' || i == 0) { r = r + s.charAt(i); } } return (r); } // -------------------------------------------------- verificaLimites private static String verificaLimites(String s) { String limiteInferior = "-2147483648"; String limiteSuperior = "2147483647"; if (s.compareTo(limiteInferior) > 0 || s.compareTo(limiteSuperior) > 0) { System.out.println("ERRO: Excedeu o Limite dos Números Inteiros"); return (""); } return (s); } } A seguir a outra versão utilizando o pacote swing.

// --------------------------------- Programa Principal: ProgEntradaDadosSwing.java package progentradadadosswing; import javax.swing.JOptionPane; public class ProgEntradaDadosSwing { public static void main(String[] args) { EntradaDadosSwing entrada = new EntradaDadosSwing(); int inteiro = entrada.leInteiro("Digite um Inteiro: "); JOptionPane.showMessageDialog(null, "Inteiro Digitado: " + inteiro); Double real = entrada.leReal("Digite um Real: "); JOptionPane.showMessageDialog(null, "Real Digitado: " + real); } } // --------------------------------------------------- Classe: EntradaDadosSwing.java 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) {

189

s = retiraNegativosForaLugar(s); if (s.charAt(0) == '-') { limite = 11; } else { limite = 10; } if (n >= limite) { s = verificaLimites(s); } } } else { s = ""; } } while (s.isEmpty()); int inteiro = Integer.parseInt(s); return (inteiro); } // -------------------------------------------------- leReal public double leReal(String mensagem) { String s; do { s = JOptionPane.showInputDialog(mensagem); s = s.replaceAll("[^0-9\\-.,]", ""); // eliminar letras s = verificaVirgulaPonto(s); s = retiraNegativosForaLugar(s); int n = s.length(); if (n == 1 && (s.charAt(0) == '-' || s.charAt(0) == '.')) { s = ""; } } while (s.isEmpty()); double real = Double.parseDouble(s); return (real); } // ----------------------------------------------------- métodos privados da classe // -------------------------------------------------- verificaVirgulaPonto private String verificaVirgulaPonto(String s) { int pontos = 0; char[] r = s.toCharArray(); int n = s.length(); for (int i = 0; i < n; i++) { if (r[i] == ',' || r[i] == '.') { r[i] = '.'; pontos++; } } if (pontos > 1) { 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; }

190

} } return (r.toCharArray()); } // -------------------------------------------------- retiraNegativosForaLugar private static String retiraNegativosForaLugar(String s) { String r = ""; int n = s.length(); for (int i = 0; i < n; i++) { if (s.charAt(i) != '-' || i == 0) { r = r + s.charAt(i); } } return (r); } // -------------------------------------------------- verificaLimites private static String verificaLimites(String s) { String limiteInferior = "-2147483648"; String limiteSuperior = "2147483647"; if (s.compareTo(limiteInferior) > 0 || s.compareTo(limiteSuperior) > 0) { JOptionPane.showMessageDialog(null, "ERRO: Excedeu o Limite dos Números Inteiros"); return (""); } return (s); } }