José Maria Rodrigues Santos Júnior

Java Standard

Aracaju, 16 de julho de 2002

INTRODUÇÃO...................................................................................................................................................4
JAVA COMO LINGUAGEM DE PROGRAMAÇÃO....................................................................................................4
JAVA COMO PLATAFORMA DE DESENVOLVIMENTO DE APLICAÇÕES.................................................................7
CONCEITOS BÁSICOS.....................................................................................................................................8
A MÁQUINA VIRTUAL JAVA..............................................................................................................................8
COLETA DE LIXO (GARBAGE COLLECTOR).........................................................................................................9
JAVA DEVELOPMENT KIT - JDK......................................................................................................................10
AMBIENTE INTEGRADO DE DESENVOLVIMENTO - IDE.....................................................................................11
TIPOS DE PROGRAMAS JAVA: APPLICATIONS, APPLETS E SERVLETS...............................................................13
ESTRUTURA DE UM PROGRAMA JAVA..............................................................................................................14
APLICAÇÕES JAVA - APPLICATION...................................................................................................................15
A LINGUAGEM JAVA....................................................................................................................................16
COMENTÁRIOS.................................................................................................................................................16
IDENTIFICADORES............................................................................................................................................17
PALAVRAS RESERVADAS..................................................................................................................................17
VARIÁVEIS E CONSTANTES..............................................................................................................................18
ARRAYS...........................................................................................................................................................22
LENDO E ESCREVENDO VARIÁVEIS..................................................................................................................23
OPERADORES...................................................................................................................................................24
COMANDOS......................................................................................................................................................29
INTRODUÇÃO A ORIENTAÇÃO A OBJETOS...........................................................................................39
TIPOS DE DADOS ABSTRATOS..........................................................................................................................40
CLASSE............................................................................................................................................................40
OBJETO............................................................................................................................................................40
ENCAPSULAMENTO..........................................................................................................................................40
MENSAGEM......................................................................................................................................................41
HERANÇA.........................................................................................................................................................41
ORIENTAÇÃO A OBJETOS EM JAVA........................................................................................................42
PACOTES..........................................................................................................................................................42
ARQUIVOS JAR (JAVA ARCHIVE) E CLASSPATH..........................................................................................43
CLASSE............................................................................................................................................................44
ENCAPSULAMENTO..........................................................................................................................................46
MEMBROS DE CLASSE......................................................................................................................................47
ATRIBUTOS......................................................................................................................................................47
MÉTODOS.........................................................................................................................................................48
OBJETO............................................................................................................................................................49
MENSAGEM......................................................................................................................................................50
SOBRECARGA DE MÉTODOS.............................................................................................................................51
HERANÇA.........................................................................................................................................................52
REDEFINIÇÃO DE MÉTODOS.............................................................................................................................56
CLASSES E MÉTODOS ABSTRATOS...................................................................................................................57
CLASSES, MÉTODOS E VARIÁVEIS FINAL.........................................................................................................59
MEMBROS ESTÁTICOS......................................................................................................................................60
CLASSES INTERNAS..........................................................................................................................................61
INTERFACES.....................................................................................................................................................62
POLIMORFISMO................................................................................................................................................63
TRATAMENTO DE EXCEÇÕES............................................................................................................................64
JAVADOC.........................................................................................................................................................68
CODE CONVENTIONS........................................................................................................................................71
API JAVA..........................................................................................................................................................72

Java - 2
 JAVA.LANG.......................................................................................................................................................73
JAVA.UTIL..........................................................................................................................................................81
JAVA.TEXT..........................................................................................................................................................82
JAVA.IO..............................................................................................................................................................93
THREADS............................................................................................................................................................101
JAVA.NET..........................................................................................................................................................102
JAVAX.SWING....................................................................................................................................................107
JAVA.SQL.JDBC...............................................................................................................................................122

FONTES DE PESQUISA................................................................................................................................136

Exercícios..........................................................................................................................................................137

Java - 3
Introdução
“Java é uma Linguagem de Programação e uma Plataforma de Desenvolvimento de Aplicações”

Java como Linguagem de Programação

A linguagem de programação Java é de alto nível com as seguintes características:

Simples Orientada a Objetos Distribuída

Compilada “Interpretada” Segura
Robusta Portável Arquitetura Neutra
Multithread Alto desempenho Dinâmica

Site(s) http://java.sun.com/docs/white/langenv/Intro.doc2.html

Java - 4
Java possui a singular característica de ser compilada e interpretada obtendo o melhor desses dois
mecanismos de tradução/execução de programas. Primeiro o compilador Java transforma um
programa fonte em bytecodes e posteriormente, na execução, os bytecodes são interpretados pela
máquina virtual Java (JVM).

Com isso um programa Java é um conjunto de instruções para a JVM, dessa forma o mesmo é
independente de plataforma, pois basta que haja uma implementação de máquina virtual para a
plataforma a ser utilizada.

Java - 5
Observação : Esse foi o modelo inicial para execução de programas Java, a fim de possibilitar
independência de plataforma, sendo que atualmente o processo de interpretação foi substituído por
outra compilação, sendo que, não mais para bytecodes e sim para código executável dependente de
plataforma. Dessa forma a perda de performance com a interpretação foi eliminada e o programa em
bytecodes continua independente de plataforma, pois a MVJ de cada plataforma será responsável
pela compilação em executável.

Site(s) http://www.javasoft.com/products/hotspot/

Java - 6
Java como Plataforma de Desenvolvimento de Aplicações
O termo plataforma normalmente é definido como a combinação de sistema operacional mais
hardware, sendo que a plataforma Java é definida apenas em software, por isso o conceito de
máquina virtual.
A plataforma Java possui dois componentes:
1. Máquina Virtual Java (JVM)
2. Interface para Desenvolvimento de Aplicações (API Java)

Java - 7
Conceitos Básicos
A Máquina Virtual Java
A Especificação da Máquina Virtual Java define a JVM (Máquina Virtual Java) como:
Uma máquina imaginária que é implementada através da emulação em um software executado em
uma máquina real.
A Especificação da Máquina Virtual Java fornece as especificações da plataforma de hardware para
a qual todo o código Java está compilado. Essa especificação permite que os programas Java sejam
independentes de plataforma já que a compilação é feita para uma máquina imaginária. Cabe ao
Interpretador Java de cada plataforma de hardware assegurar a execução do código compilado para
a JVM.
A especificação da JVM fornece definições concretas para a implementação dos seguintes itens:
 Conjunto de Instruções (equivalente ao conjunto de instruções de uma CPU)
 Conjunto de registradores
 Formato do arquivo de classe
 Pilha
 Heap (coletado como lixo)
 Área da memória

Java - 8
Coleta de lixo (Garbage Collector)
Várias linguagens de programação permitem a alocação dinâmica da memória no tempo de
execução. O processo de alocação de memória varia baseado na sintaxe da linguagem, mas sempre
envolve o retorno de um ponteiro ao endereço inicial do bloco de memória.
Quando a memória alocada não é mais necessária (quando o ponteiro que faz referência à memória
está fora do escopo), é aconselhável que o ambiente do programa ou do tempo de execução
desaloque a memória para evitar que o programa seja executado com falta de memória.
No C e C++ (e outras linguagens), o desenvolvedor do programa é responsável pela desalocação da
memória. Esse procedimento algumas vezes pode ser trabalhoso, principalmente porque nem
sempre é possível saber antecipadamente quando a memória deve ser liberada. Os programas que
não são desalocados da memória podem, conseqüentemente, sofrer algum tipo de falha caso não
haja memória suficiente a ser alocada pelo sistema. Esses programas têm, portanto, vazamentos de
memória.
A linguagem Java realiza a liberação da memória, que antes era responsabilidade do programador,
fornecendo um thread em segundo plano, em nível de sistema, que registra cada alocação de
memória e mantém uma contagem do número de referências feitas a cada ponteiro de memória.
Durante os ciclos ociosos, no tempo de execução da Máquina Virtual Java, o thread da coleta de lixo
verifica se existe algum ponteiro de memória em que o número de referências tenha baixado para 0.
Se houver, a memória marcada pelo thread da coleta de lixo será varrida (desalocada).
A coleta de lixo ocorre automaticamente durante o tempo de vida de um programa Java e dispensa a
desalocação de memória, além de eliminar os vazamentos de memória.

Java - 9
Java Development Kit - JDK
Conjunto de ferramentas para o desenvolvimento em JAVA fornecidas pela Sun, sendo os principais:

Ferramenta Descrição
javac Compilador
java Executor de Programas
javadoc Gerador de documentação da API
appletviewer Visualizador de applet
jar Gerenciador de arquivos .jar
jdb Debuger
javap Faz engenharia reversa de classes

Versões Existentes: JDK 1.0.x JDK 1.1.x JDK 1.2.x JDK 1.3.x JDK 1.4.x

Site(s) http://www.javasoft.com/products/

Java - 10
Ambiente Integrado de Desenvolvimento - IDE
Ambiente com interface gráfica que interage com o JDK para oferecer um ambiente de
desenvolvimento mais produtivo.
Exemplos:
Inprise JBuilder Microsoft Visual J++ Symantec Visual Café
Tek-Tols Kawa Sun Forte CE

Jbuilder 6.0 Foundation

Ferramenta da Borland, de uso livre e utilizando apenas a API padrão. Possui os mesmos recursos
de edição das versões comerciais.
Site(s) http://www.borland.com/jbuilder/foundation/download/windows.html

Configurando o ambiente : “Tools\IDE Options...” : (Editor/Block Ident e Tab Size =2)

Criação de Projeto
Demonstraçã 1. Novo Projeto (C:\CursoJava\Standard\Fontes\ProjetoDemo.jpr)
o 2. Propriedades do Projeto
JBuilder 3. Nova Classe
4. Edição/Compilação/Execução

Java - 11
 Exercício :
/**
* Demonstração de um Application Java
*/

/* Definição do pacote */
package introducao;

/* Definição da classe */
public class Aplicacao {

/* Método main, o qual define um application */

public static void main(String[] args) {

/* Escrevendo os parâmetros passados na saida padrao */

for (int i = 0; i < args.length; i++ ) {
System.out.println( args[i] );
}
}
}

Java - 12
Tipos de Programas Java: Applications, Applets e Servlets
A linguagem Java possui diferentes tipos de programas, sendo que a classificação é feita através da
modalidade/localização de execução dos mesmos.

Applications
Aplicações stand-alone com "todos" os recursos de acesso ao Sistema Operacional. Semelhantes
aos programas convencionais.

Applets
Programas que são carregadas através de uma rede TCP/IP (Internet/Intranet) e são executadas na
JVM de um browser. A máquina virtual impõe sérias restrições aos Applets, em relação ao uso de
recursos do sistema operacional local, para evitar problemas de segurança.

Servlets
Programas que são executadas remotamente no servidor Web através de um Gerenciador de
Servlets (Servlet Engine). São utilizados em aplicações para Internet/Intranet, os quais são
executadas no servidor, evitando assim problemas de compatibilidade, distribuições de versões e
aumentando a segurança.

Java - 13
Estrutura de um Programa Java
Todo programa Java é uma classe e mesmo possuindo três possíveis modalidades para programas
Java (Applications, Applets e Servlets) a estrutura básica é sempre a mesma : "uma classe".
Um Programa Java é organizado em arquivos texto com a extensão .java e cada arquivo contem
apenas uma classe pública. O nome do arquivo da classe Java deve possuir exatamente o mesmo
nome da classe pública, pois a máquina virtual procura o arquivo da classe através do nome da
classe. O comando package informar a qual pacote (diretório) a classe pertence. Quando uma
classe utilizar outras classes, estas devem ser importadas através do comando import, o qual deve
indicar o pacote da classe importada e o seu nome.

Programa(s) Demonstração introducao.ClasseJava.java

/**
* Demonstração de uma classe Java
*/

/* Definição do pacote */
package introducao;

/* Definição da classe (O mesmo nome do arquivo fonte) */

public class ClasseJava {

/* Corpo da Classe */

/* Atributos */

/* Construtore(s) */
public ClasseJava ( /* Parâmetros */ ) {
/* procedimentos de inicialização da classe */
}

/* Finalizador */
protected void finalize () {
/* procedimentos de finalização da classe */
}

/* Métodos */
}

Java - 14
Aplicações Java - Application
Como demonstrado anteriormente, a linguagem de programação Java possui três tipos de
programas. Dessa forma iremos nos aprofundar um pouco mais no tipo Application, pois os recursos
básicos da linguagem Java serão demonstrados através de Application.
Um application Java nada mais é que uma classe Java possuindo um método específico que o
caracteriza como uma aplicação para a Máquina Virtual Java. Dessa forma, todo programa/classe
Java que possuir o método com o seguinte assinatura “public static void main (String[]
argumentos){ }“ será um application. E o corpo desse método será executado automaticamente
quando o programa for submetido a JVM. Um detalhe importante é que o array String[] argumentos
contém os parâmetros de linha de comando passados ao programa.

Programa(s) Demonstração introducao.Aplicacao.java

/**
* Demonstração de um Application Java
*/

/* Definição do pacote */
package introducao;

/* Definição da classe */
public class Aplicacao {

/* Método main, o qual define um application */

public static void main(String[] args) {

/* Escrevendo os parâmetros passados na saida padrao */

for (int i = 0; i < args.length; i++ ) {
System.out.println( args[i] );
}
}
}

Java - 15
A Linguagem Java
Comentários
Existem três tipos de comentários em Java, sendo eles :
// Usado para indicar comentários em uma única linha, pode ser inserido em qualquer
posição de uma linha, e todo o texto até o final do marcador de linha é tratado como
comentário.
/* */ Usados para indicar comentários que se estendem por uma ou mais linhas.
/** */ Comentário de documentação. Devem ser inseridos imediatamente antes de uma
declaração de classes, variável ou método e indicam que o comentário deve ser incluído
em qualquer documentação gerada automaticamente (como os arquivos HTML gerados
pelo comando javadoc)

Programa(s) Demonstração introducao.Comentarios.java

/**
* Descriçao: <p>Aplicação java demonstrando os tipos de comentários
* Empresa: <p>Infonet
* @author José Maria Rodrigues Santos Junior
* @version 1.0
*/

//Definição do pacote
package introducao;

//Definição de classe
public class Comentarios {

/**
* Método main da Aplicação
* @param args parâmetros da linha de comando
*/
public static void main(String[] args) {

/*
* O laço abaixo irá passar por todos os parâmetros fornecidos na linha
* de comando e irá escrevê-los na saída padrão
*/
int i = 0; // Variável inteira
System.out.print("Parâmetros : ");
while (i < args.length) {
/* Ecreve posição i do array args na saída padrão */
System.out.print(args[i] + " ");
i++; // Incrementa a variável i de 1 unidade
}
}
}

Java - 16
Identificadores
Os identificadores em Java devem seguir as seguintes regras :
1. A primeira posição deverá ser com uma letra, “_” ou “$”
2. Ser formado por caracteres UNICODE
3. Não ser uma palavra reservada
4. Não ser igual as literais : true, false ou null
5. Não ser repetido dentro do seu escopo
Observação : Os identificadores Java são case-sensitive

Palavras Reservadas
abstract double int strictfp
boolean else interface super
break extends long switch
byte final native synchronized
case finally new this
catch float package throw
char for private throws
class goto protected transient
const if public try
continue implements return void
default import short volatile
do instanceof static while

Java - 17
Variáveis e Constantes
Podem ser declaradas em qualquer lugar dentro de uma classe ou de um método. Uma constante é
definida com a palavra reservada final e o seu conteúdo uma vez atribuído não poderá mais ser
alterado.
A declaração de variáveis e constantes em Java é feita colocando o identificador do tipo seguido do
identificador da variável.

tipo variável [ = ValorInicial ];

final tipo CONSTANTE [ = ValorInicial ];

Tipos de Dados Primitivos

Java é uma linguagem de programação fortemente orientada a objetos e, com exceção dos tipos
primitivos, “qualquer” coisa em Java é uma classe/objeto.

Tipos Numéricos Inteiros

Tipo Tamanho em bits Faixa
byte 8 -128 até +127
short 16 -32,768 até +32,767
int 32 -2,147,483,648 até+2,147,483,647
long 64 -9,223,372,036,854,775,808 até
+9,223,372,036,854,775,807

Tipos Numéricos Reais

Tipo Tamanho em bits Faixa
float 32 -3.40292347E+38 até +3.40292347E+38
double 64 -1.79769313486231570E+308 até
+1.79769313486231570E+308

Java - 18
Tipo caracter
Tipo Tamanho em bits Faixa
char 16 UNICODE - 65536 caracteres possíveis
Observação: Um caracter é delimitado por apóstrofos ‘caracter’. O que causa confusão, pois as
Strings são delimitadas por aspas “String”.

Caracteres Especiais de Escape:

'\u0000' a caracteres Unicode
'\uFFFF'
\b retrocesso
\t tab
\n avanço de linha
\r retorno de carro
\” aspas
\' apóstrofo
\\ barra invertida
Observação: A linguagem Java não possui o tipo primitivo string, bastante conhecido em várias
outras linguagens. Para manipulação de texto são utilizadas as classes String e StringBuffer.

Java - 19
Tipo Lógico
Tipo Faixa
boolean true ou false

Conversão entre tipos primitivos

É possível transformar um tipo primitivo em outro, através de uma operação chamada typecast,
colocando o tipo destino da transformação, entre parêntesis, antes da expressão a ser convertida.
Esse tipo de conversão é chamado de conversão explícita. Por outro lado existe a conversão
implícita, a qual é realizada pela MVJ, mesmo sem possuir operador de typecast, isso quando o tipo
de retorno é menos abrangente que o tipo que o recebe.

Java - 20
Programa(s) Demonstração introducao.TiposPrimitivos.java
/**
* Demonstração de Tipos Primitivos
*/

package introducao;

public class TiposPrimitivos {

public static void main ( String[] args ) {

/* Declarando tres variaveis do tipo float */
float nota1, nota2, nota3;
/* Inicializando as tres variáveis float */
nota1 = 10;
nota2 = 7;
nota3 = 3;
/* Declarando e inicializando três variaveis float*/
float n1 = 5, n2 = 2, n3 = 9;

int idade = 28;

char sexo = 'M'; //Lembrar de usar apóstofros
double salario = 3000.00;
boolean achou = false;

/*
* quando uma variável é declarada como final a mesmo não pode ter seu
* conteúdo alterado
*/
final char FLAG = 'F';

/*
* Erro, pois literais numéricas com casas decimais são double
*/
// nota1 = 8.5
nota1 = 8.5f; // conversão explicita para float
nota2 = 7.0f; // conversão explicita para float
nota3 = (float) 9.0; // conversão explicita para float

System.out.println("Dados do Aluno");
System.out.print("Idade \t= " + idade + "\n" );
System.out.println("Sexo \t= " + sexo);
System.out.println("Notas \t= " +
nota1 + "\t" +
nota2 + "\t" +
nota3);
System.out.println("Achou \t= " + achou);
System.out.println("Flag \t= " + FLAG);

/* Conversão de double para int */

double d = 34.78;
int i = (int) d;
System.out.println("double : " + d + "\n int : " + i);

}
}

Java - 21
Arrays
São estruturas homogêneas e estáticas. A linguagem Java possui somente arrays unidimensionais,
sendo que arrays multidimensionais podem ser simulados, através da definição de array de array. A
propriedade length representa o tamanho do array. A primeira posição de um array é 0 e a última
(length – 1)

Programa(s) Demonstração introducao.Array.java

/**
* Demonstração de array
*/

package introducao;

public class Array {

public static void main(String[] args) {

/* declarando dois arrays do tipo int*/
int[] a1;
int[] a2;
/* instanciando os dois arrays */
a1 = new int[ 10 ]; // array com 10 posições de int
a2 = new int[ 30 ]; // array com 30 posições de int
/* imprimindo o tamanho dos array a1 e a2 */
System.out.println("a1 tamanho : " + a1.length);
System.out.println("a2 tamanho : " + a2.length);

/* declarando, instanciando e atribuindo valores ao array notas */

float[] notas = { 7.5f , 9.0f , 10.0f };
/* imprimindo as posições do array notas */
System.out.println("Notas : " + notas[0] + " - " +
notas[1] + " - " +
notas[2]);

/* simulando array bidimensional*/

int[][] matriz = new int[ 3 ][ 4 ];
System.out.println("Linhas da Matriz : " + matriz.length);
System.out.println("Colunas da Matriz : " + matriz[0].length);
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[0][2] = 3;
matriz[0][3] = 4;
matriz[1][0] = 5;
matriz[1][1] = 6;
matriz[1][2] = 7;
matriz[1][3] = 8;
matriz[2][0] = 9;
matriz[2][1] = 10;
matriz[2][2] = 11;
matriz[2][3] = 12;
/* Imprimindo o array */
for (int i = 0; i < matriz.length; i++)
for (int j = 0; j < matriz[0].length; j++)
System.out.print(matriz[i][j] + " ");
}
}

Java - 22
Lendo e Escrevendo Variáveis
A linguagem Java não possui comandos específicos para leitura de variáveis, pois a entrada e saída
de dados são tratadas de forma independente de dispositivo, através das classes do pacote
java.io. Dessa forma foi criada uma classe (Keyboard), contendo métodos "estáticos" para leitura
de variáveis do tipo int, char, float e String, afim de facilitar a prática dos conceitos visto
durante o curso.

Para escrever variáveis na saída padrão podem ser utilizados os comando:

System.out.print(String);
System.out.println(String); //Salta Linha
Observação: Tipos primitivos/“objetos” podem ser concatenados com o sinal "+".

Programa(s) Demonstração introducao.Teclado.java

/**
* Demonstração do uso da classe Keyboard
*/

package introducao;

import util.Keyboard;

public class Teclado {

public static void main (String[] args) {

/* Lendo uma Variável int */

System.out.print("int : ");
int i = Keyboard.readInt();
System.out.println(i);

/* Lendo uma Variável float */

System.out.print("float : ");
float f = Keyboard.readFloat();
System.out.println(f);

/* Lendo uma Variável char */

System.out.print("char : ");
char c = Keyboard.readChar();
System.out.println(c);
}
}

Java - 23
Operadores

Aritméticos
Operador Uso Descrição
+ op1 + op2 Adiciona op1 e op2
- op1 - op2 Subtrai op2 de op1
* op1 * op2 Multiplica op1 por op2
/ op1 / op2 Divide op1 por op2
% op1 % op2 Resto de op1 / op2

Incremento
Operador Uso Descrição
++ var++ usa a variável e depois incrementa
++var incrementa a variável e depois usa
-- var-- usa a variável e pois decrementa
--var decrementa a variável e depois usa

Relacionais
Operador Descrição
== Igual
!= Diferente
< Menor
> Maior
<= Menor ou igual
>= Maior ou igual

Java - 24
Atribuição
Operador Uso Equivale a
=
+= Op1 += op2 Op1 = op1 + op2
-= Op1 -= op2 Op1 = op1 - op2
*= Op1 *= op2 Op1 = op1 * op2
/= Op1 /= op2 Op1 = op1 / op2
%= Op1 %= op2 Op1 = op1 % op2
&= Op1 &= op2 Op1 = op1 & op2
|= Op1 |= op2 Op1 = op1 | op2
^= Op1 ^= op2 Op1 = op1 ^ op2
<<= Op1 <<= op2 Op1 = op1 << op2
>>= Op1 >>= op2 Op1 = op1 >> op2
>>>= Op1 >>>= op2 Op1 = op1 >>> op2

Java - 25
Binários
Operador Descrição
>> shift binário para direita
<< shift binário para esquerda
>>> shift binário para direita (unsigned)
& AND binário
| OR binário
^ XOR binário
~ complemento binário

Lógicos
Operador Descrição
&& AND com curto-circuito
|| OR com curto-circuito
! NOT
& AND sem curto-circuito
| OR sem curto-circuito

Java - 26
Condicional
Operador Uso Descrição
?: expressão_logica?val1:val2 Caso a expressão lógica seja verdade o val1 será
retornado, caso contrário será retornado val2

Precedência dos Operadores

Os operadores estão listados na ordem decrescente de precedência;
Os operadores na mesma linha têm a precedência igual;
Todos os operadores binários, à exceção dos operadores de atribuição, são avaliados da esquerda
para direita;

Descrição Operadores
operadores do sufixo [ ] . () Chamada de função
operadores unários !, ~, +, -, ++, --
Criação (Type-cast), new
multiplicativos *, /, %
aditivos +, -
SHIFT <<, >>, >>>
relacional <, >, <=, >= instanceof
igualdade ==, !=
AND binário &
XOR binário ^
OR binário |
AND lógico &&
OR lógico ||
Condicional ?:
Atribuição +=, -=, *=, /=, %=, &=, ^=, |=, <=, <=, >>, >=, >>, =

Java - 27
Programa(s) Demonstração introducao.Operadores.java
/**
* Demonstração do Operadores
*/
package introducao;
import util.Keyboard;
public class Operadores {
public static void main(String[] args) {
/* declarando e inicializando 3 variáveis inteiras */
int i1 = 7;
int i2 = 3;
int i3;
i3 = i1 + i2; // adição
i3 = i1 - i2; // subtração
i3 = i1 * i2; // multiplicação
i3 = i1 / i2; // divisão inteira, pois n1 e n2 são do tipo int
i3 = i1 % i2; // resto da divisão inteira
/* declarando e inicializando 3 variáveis float */
float f1 = 12.8f; // conversão explícita para float
float f2 = 6.4f;
float f3;
f3 = i1 * f2; // conversão implícita para float
f3 = f2 / i2; // divisão float, pois o numerador é float
f3++; // incremento
f3--; // decremento
f1 = ++f2 + f3; // a variável i2 será incrementada antes da atribuição
f1 = f2++ + f3; // a variável i2 será incrementada após a atribuição
/* Operador relacional */
System.out.println( f1 > f2 ? f1 : f2 );
System.out.println( "f1 = " + f1 );
System.out.println( "f2 = " + f2 );
/* Calculo do preço de venda um produto baseado no preço de compra e
e no percentual de lucro */
float preçoCompra;
float percentualLucro;
System.out.print( "Preço de Compra : " );
preçoCompra = Keyboard.readFloat();
System.out.print("Percentual de Lucro : ");
percentualLucro = Keyboard.readFloat();
float lucro = preçoCompra * (percentualLucro/100);
float preçoVenda = preçoCompra + lucro;
System.out.println("Preço de Compra : " + preçoCompra +
"\nPercentual de Lucro : " + percentualLucro +
"\nLucro : " + lucro +
"\nPreço de Venda : " + preçoVenda);

int i = 10;
System.out.println( " i " + i );
i = i << 1;
System.out.println( " i " + i );
i = i >> 2;
System.out.println( " i " + i );
int a = 5;
int b = 10;
int c = a | b;
int d = a & b;
System.out.println( "a = " + a + "\nb = " + b +
"\nc = " + c + "\nd = " + d);
}
}

Java - 28
Comandos

Sequência { sequência }
Cria uma seqüência, a qual agrupa comandos e variáveis. Quando uma sequência possuir apenas
um comando os operadores { e } são opcionais, caso contrários são obrigatórios e cada comando
dentro da sequência deve ser terminado por “;”

Java - 29
Comando if – else
Comando de seleção, o qual permite analisar uma expressão lógica e direcionar a execução do
programa. Caso a expressão lógica seja verdadeira (true) a sequência do if será executado e
caso a expressão lógica seja falsa (false), e exista a cláusula else, a sequência do else será
executada.

if ( expressão_lógica )
Sequência;

if ( expressão_lógica )
Sequência_1;
else
Sequência_2;

if ( expressão_lógica )
Sequência_1;
else if ( expressão_lógica )
Sequência_2;
else if ( expressão_lógica )
Sequência_3;
else if ( expressão_lógica )
Sequência_4;
else
Sequência_5;

Java - 30
Programa(s) Demonstração comandos.ComandoIF.java
/**
* Demonstração do comando if else
*/

package comandos;

import util.Keyboard;

public class ComandoIF {

public static void main(String[] args) {

/* Validando uma data */
int dia, mes, ano;
System.out.print("Dia : ");
dia = Keyboard.readInt();
System.out.print("Mês : ");
mes = Keyboard.readInt();
System.out.print("Ano : ");
ano = Keyboard.readInt();
boolean data = false;
/* meses de 30 dias */
if ( mes == 4 || mes == 6 || mes == 9 || mes == 11) {
if ( dia >= 1 && dia <= 30 ) {
data = true;
}
} else {
/* meses de 31 dias */
if ( mes == 1 || mes == 3 || mes == 5 || mes == 7 ||
mes == 8 || mes == 10 || mes == 12 ) {
if ( dia >= 1 && dia <= 31 ) {
data = true;
}
} else {
/* fevereiro */
if ( mes == 2 ) {
if ( dia >= 1 && dia <= 28 ) {
data = true;
} else {
/* 29 de fevereiro */
if ( dia == 29 ) {
/* Ano bissexto */
boolean bissexto = ( (ano % 4 == 0) &&
(ano % 100 != 0) ) ||
(ano % 400 == 0);
if ( bissexto ) {
data = true;
}
}
}
}
}
}
System.out.print(dia + "/" + mes + "/" + ano + " : ");
if ( data )
System.out.println("Data Válida");
else
System.out.println("Data Inválida");
}
}

Java - 31
Comando switch
Compara (igualdade) uma variável ( byte, char, short ou int ) a uma relação de valores,
permitindo associar comandos a cada valor da relação.

switch (variável) {
case valor1 : sequência_1;
case valor2 : sequência2;
...
case valorN : sequênciaN;
[ default : sequênciaDefault; ]
}

Obs : O comando break normalmente é utilizado como último comando de cada sequência, indicando
que, quando uma sequência for executada todas as outras serão ignoradas.

Java - 32
Programa(s) Demonstração comandos.ComandoSwitch.java
/**
* Demonstração do comando switch
*/

package comandos;

import util.Keyboard;

public class ComandoSwitch {

public static void main(String[] args) {

/* Validando uma data */
int dia, mes, ano;
System.out.print("Dia : ");
dia = Keyboard.readInt();
System.out.print("Mês : ");
mes = Keyboard.readInt();
System.out.print("Ano : ");
ano = Keyboard.readInt();
boolean data = false;
switch (mes) {
/* meses de 30 dias */
case 4 :
case 6 :
case 9 :
case 11 :
if ( dia >= 1 && dia <= 30 )
data = true;
break;
/* meses de 31 dias */
case 1 :
case 3 :
case 5 :
case 7 :
case 8 :
case 10 :
case 12 :
if ( dia >= 1 && dia <= 31 )
data = true;
break;
/* fevereiro */
case 2 :
if ( dia >= 1 && dia <= 28 ) {
data = true;
} else {
/* 29 de fevereiro */
if ( dia == 29 ) {
/* Ano bissexto */
boolean bissexto = ( (ano % 4 == 0)&&
(ano % 100 != 0) ) ||
(ano % 400 == 0);
if ( bissexto ) {
data = true;
}
}
}
default : data = false;
}

System.out.print(dia + "/" + mes + "/" + ano + " : ");

if ( data )
System.out.println("Data Válida");
else
System.out.println("Data Inválida");
}
}

Java - 33
Comando while
Executa a sequência do comando enquanto a expressão lógica for verdadeira. Sendo que, antes de
cada execução a expressão lógica é analisada.

while ( expressão_lógica )
Sequência;

Programa(s) Demonstração comandos.ComandoWhile.java

/**
* Demonstração do comando while
*/

package comandos;

import util.Keyboard;

public class ComandoWhile {

public static void main( String[] args ) {

int numero;
int fatorial;
System.out.println("Calculo do fatorial (flag < 0)");
System.out.print("Número : ");
numero = Keyboard.readInt();
while ( numero >= 0 ) {
fatorial = 1;
while ( numero > 1 ) {
fatorial *= numero;
numero--;
}
System.out.println( "Fatorial : " + fatorial );
System.out.print( "Número : ");
numero = Keyboard.readInt();
}
System.out.println( "Fim" );
}
}

Java - 34
Comando do while
Executa a sequência do comando enquanto a expressão lógica for verdadeira. Sendo que, após a
execução da sequência a expressão lógica é analisada.

do
Sequência;
while ( expressão_lógica );

Programa(s) Demonstração comandos.ComandoDoWhile.java

/**
* Demonstração do comando do while
*/

package comandos;

import java.lang.String;
import util.Keyboard;

public class ComandoDoWhile {

public static void main(String[] args) {

int numero;
int fatorial;
System.out.println("Calculo do fatorial (flag = 0)");
do {
System.out.print("Número : ");
numero = Keyboard.readInt();
fatorial = 1;
while (numero > 1) {
fatorial *= numero;
numero--;
}
System.out.println("Fatorial : " + fatorial);
} while (numero != 0);
}
}

Java - 35
Comando for
Executa a sequência do comando enquanto a expressão lógica for verdadeira. Sendo que permite
inicializar variável, na entrada do comando e incrementar variável a cada repetição.

for ( expressão_inicializacao ; expressão_lógica ; expressão_incremento )

Sequência;

Programa(s) Demonstração comandos.ComandoFor.java

/**
* Demonstração do comando for
*/

package comandos;

import util.Keyboard;

public class ComandoFor {

public static void main(String[] args) {

final int inicio = 10;
final int fim = 10;
int resultado = 0;
System.out.print("Tabuada de (+ x) : ");
char tabuada = Keyboard.readChar();

for (int i = 0; i <= inicio; i++ ) {

for (int j = 0; j <= fim; j++) {
switch (tabuada) {
case '+' :
resultado = i + j;
break;
case 'x' :
resultado = i * j;
break;
}
System.out.print(i + " " + String.valueOf(tabuada) + " " + j +
" = " + resultado + "\t");
}
System.out.println();
}
}
}

Java - 36
Comando break
Força a saída de um comando de repetição ou do comando switch

Comando continue
Força o início da próxima iteração de um comando de repetição

Programa(s) Demonstração comandos.ComandoBreakContinue.java

/**
* Demonstração do comando break e continue
*/

package comandos;

public class ComandoBreakContinue {

public static void main(String[] args) {

for (int i = 0; i <= 1000 ; i++ ) {
if ( i == 10 )
break;
System.out.print(i + " ");
}
System.out.println();

for (int i = 0; i <= 20 ; i++) {

if ( i <= 10 )
continue;
System.out.print(i + " ");
}
}
}

Java - 37
Exercício(s) Exercício 2: Resolva os problemas abaixo com applications Java
Problema 1: "Leia um valor inteiro representando o valor solicitado para saque num caixa
eletrônico, em seguida, sabendo que o caixa está alimentado com notas de 1, 5, 10, 50 e 100 reais,
calcule e escreva quantas notas de cada valor serão necessárias para atender a solicitação de
saque"

Problema 2: "Leia um salário, atualize e escreva-o de acordo com a tabela abaixo"

Faixa salarial Percentual de aumento
até 1.000,00 30%
acima de 1.000,00 e até 2.000,00 20%
acima de 2.000,00 10%

Problema 3: Ler três valores float e imprimir se estes podem ou não formar os lados de um
triângulo e qual triângulo seria (Equilátero, Isóceles ou escaleno).
Observação: Para formar os lados de um triângulo cada um dos valores deve ser menor que a
soma dos outros dois. Um triângulo pode ser : equilátero (3 lados iguais), isósceles (apenas 2 lados
iguais) e escaleno (3 lados diferentes).

Problema 4: Leia o nome, as três notas e o número de faltas de um aluno e calcule e imprima sua
situação ("Aprovado", "Reprovado por Falta" ou "Reprovado por média").
Observação: A média para aprovação é 5,0 (cinco) e o limite de faltas é 18 e a reprovação por falta
sobrepõe a reprovação pode média.

Problema 5: Leia um conjunto de números inteiros, onde o flag será o valor 0 (zero) e em seguida
escreva a média dos números lidos e o maior valor lido.

Problema 6: Leia (ou inicialize) um vetor com 10 elementos de números inteiros e em seguida leia
um conjunto de números inteiros e para cada número lido informe se o mesmo está ou não
presente no vetor.

Problema 7: Leia (ou inicialize) uma matriz 5x5 de números inteiros e em seguida escreva cada
valor presente na matriz e quantas vezes o mesmo aparece na matriz.

Java - 38
Introdução a Orientação a Objetos
A metodologia orientada a objetos representa um modo muito diferente dos enfoques usuais
sustentados por linguagens de programação estruturadas. Os recursos fornecidos pela metodologia
orientada a objetos suportam conceitos que tornam a solução de problemas pelo computador uma
atividade mais humanizada.
A programação orientada a objetos é um método relativamente novo na concepção e implementação
de sistemas de software. Seus maiores objetivos são aumentar a produtividade do programador
através de uma maior expansibilidade e reutilização de software, além de controlar a complexidade e
o custo de manutenção do mesmo.
A programação orientada a objetos centraliza-se nos seguintes conceitos : Tipos de dados abstratos,
herança e polimorfismo.
O objetivo principal da orientação a objetos é permitir que os programas sejam organizados de forma
a espelhar o modo como os objetos são organizados no mundo real.

Java - 39
Tipos de Dados Abstratos
Representam a parte central da metodologia orientada a objetos. Um tipo de dado abstrato é um
modelo formado por propriedades (atributos) e operações (métodos), onde estas definem o
comportamento básico do mesmo. Tipo de dado abstrato permite a modelagem de entidades do
mundo real de uma forma mais natural, pois estamos acostumados a lidar com "objetos" os quais
possuem características "atributos" e funcionalidades "métodos".

Classe
Representa a implementação de um tipo de dado abstrato, onde a mesma possuirá a declaração dos
atributos e implementação dos métodos. Uma classe representa o "molde" através do qual os objetos
serão criados, assim a definição de uma classe possui todas as propriedades e funções que
caracterizam o comportamento de qualquer objeto da classe.

Objeto
É a instância de uma classe possuindo valores próprios para os atributos definidos na classe.

Encapsulamento
Mecanismo utilizado com o objetivo de esconder detalhes de implementação das classes, permitindo
assim, maior domínio da complexidade, pois uma classe deve ofertar apenas o que ela pode fazer e
não como ela faz. Uma classe deve impedir o acesso aos seus atributos e métodos internos e
disponibilizar métodos públicos, os quais representam a "real" funcionalidade da classe. Dessa forma
é possível utilizar uma classe como um objeto real, pois assistimos televisão, ouvimos rádio, ..., sem
ter a menor idéia de como os mesmos funcionam internamente, basta apenas saber como interagir
(ligar, desligar, mudar de canal, ...) com os mesmos.

Java - 40
Mensagem
É a forma como um objeto interage com outro objeto, corresponde a chamada (execução) de um
método do objeto, o que pode exigir a passagem de parâmetro(s).

Herança
É a capacidade de herdar atributos e métodos de uma classe já definida (superclasse), possibilitando
estender o comportamento de uma classe adicionando novos atributos e métodos (subclasse). A
grande vantagem da herança é permitir o reaproveitamento de código, pois a subclasse recebe os
atributos e métodos da superclasse e permite a implementação de novas funcionalidades.

Java - 41
Orientação a Objetos em Java
Pacotes
As classes Java são organizadas em pacotes, os quais são estruturas de diretórios com a finalidade
de melhor agrupar e organizar as classes. Outras vantagens obtidas com a utilização de pacotes são
evitar conflito de nomes e proteger o acesso às classes. A criação de um pacote consiste na criação
de uma estrutura de diretório, colocação das classes nesses diretórios e definição do pacote nas
classes através do identificador package seguido do nome do pacote. Para utilizar classes é
necessário importá-las através do identificador import seguido de nomeDoPacote.NomeDaClasse
ou nomeDoPacote.* quando for necessário importar todas as classes do pacote (diretório).

Programa(s) Demonstração oo.controleEstoque.*

Java - 42
Arquivos JAR (Java Archive) e CLASSPATH
São arquivos compactados e independentes de plataforma que agregam classes Java e arquivos
utilizados por estas classes. Os applets normalmente são colocados num arquivo .jar contendo os
arquivos .class, imagens e sons utilizados pelo applet, facilitando assim o download do mesmo.
Normalmente bibliotecas de classes são distribuídas em arquivos .jar, os quais podem ser inseridos
na variável CLASSPATH da máquina virtual Java, após o que as classes contidas no jar podem ser
importadas (utilizadas).
O arquivo .jar usa o mesmo algoritmo de compactação do programa zip, tendo a peculiaridade de
possuir no diretório meta-inf o arquivo Manifest.MF, o qual possui atributos para os arquivos
contidos no jar e pode indicar qual a classe main a ser executada quando o comando “java –jar
arquivo.jar” for executado.

Programa(s) Demonstração ..\CursoJava\Standard\Fontes\jar\ControleEstoque.jar

Java - 43
Classe
Em Java uma classe é definida através da palavra reservada class, normalmente cada classe fica
num arquivo fonte separado. A definição de uma classe é dividida em declaração e corpo da classe,
onde na declaração são definidas a sua visibilidade, nome, superclasse e interfaces. E no corpo da
classe são definidos os atributos e os métodos. Normalmente as classes possuem um tipo de
método especial chamado construtor, o qual possui o mesmo nome da classe e é utilizado para
instanciar objetos da classe. É possível também definir um método com a assinatura protected
void finalize(), o qual será executado pelo garbage collector antes do objeto ser retirado da
memória.
A definição de uma classe é feita de acordo com a sintaxe abaixo

public Acesso público

abstract Não pode ser instanciada
final Indicação que nenhuma outra classe pode herdá-la
class NomeDaClasse Nome da Classe
extends SuperClasse Classe a ser estendida (Herança)
implements Interfaces Interfaces a serem implementadas
{
Corpo da Classe Atributos e métodos
}

Java - 44
Programa(s) Demonstração oo.cadastroDeClientes.Cliente.java
/**
* Classe modelando cliente com o objetivo de demonstrar os seguintes
* conceitos de orientação a objetos : Classe, Encapsulamento e Membros
* (Atributos e Métodos)
*/

package oo.cadastroDeClientes;

/* Definição da classe */
public class Cliente {
/* Corpo da classe */
/* Atributos da classe */
private int matrícula; //Matrícula do cliente
private String nome; //Nome do cliente
private char plano; //Plano de assinatura do cliente

/* Métodos da classe */
/* Construtor */
public Cliente() {
super();
}
/* Construtor */
public Cliente (int matrícula, String nome, char plano) {
setMatrícula(matrícula);
setNome(nome);
setPlano(plano);
}
/* Métodos para leitura e escrita dos atributos */
public void setMatrícula (int matrícula) {
this.matrícula = matrícula;
}
public void setNome (String nome) {
this.nome = nome;
}
public void setPlano (char plano) {
this.plano = plano;
}
public int getMatrícula () {
return matrícula;
}
public String getNome () {
return nome;
}
public char getPlano () {
return plano;
}
/* Método que escreve os atributos do cliente na saída padrão */
public void escreve() {
System.out.print(matrícula + " | " + nome);
if (plano == '1')
System.out.println(" | 20 horas");
else if (plano == '2')
System.out.println(" | Horas livres");
else
System.out.println(" | Plano Inválido");
}
}

Java - 45
Encapsulamento
O encapsulamento é feito através da definição da visibilidade de classes, atributos e métodos. A
visibilidade é definida pelos identificadores: private, protected e public. Quando nenhum
destes identificadores é usado a visibilidade definida é package. Classes somente podem possuir
visibilidades public ou package.

Identificador Visibilidade
public Qualquer classe de qualquer pacote.
private Apenas na própria classe.
protected Na própria classe, sub-classes e classes no mesmo pacote.
package Classes do mesmo pacote.
Observação: Normalmente os atributos de uma classe devem ser privados e o acesso (atribuição e
leitura) destes devem ser feitos através de métodos públicos. É comum também a existência de
métodos privados com a finalidade de auxiliar os métodos públicos, esses métodos privados são
comumente chamados de métodos de serviço. Os métodos públicos representam o que a classe
oferece.

Java - 46
Membros de Classe
Os atributos e métodos de uma classe são chamados de membros da classe e os mesmo são
definidos no corpo da classe.

Atributos
São as variáveis da classe podendo ser de tipos primitivos ou outras classes. Onde as mesmas são
definidas de acordo com a sintaxe abaixo.

Visibilidade Tipo nomeDoAtributo [ = ValorInicial ];

Java - 47
Métodos
Cada método possui uma assinatura e corpo, onde a assinatura é definida por: Visibilidade, Tipo de
Retorno, Nome e Lista de Parâmetros. E o Corpo representa a implementação do método.
No corpo de um método o identificador this pode ser utilizado para fazer referência a uma variável
da classe, pois é comum que parâmetros possuam nomes iguais a variáveis de classe, dessa forma
o identificador this serve para resolver conflitos de nomes entre parâmetros e variáveis da classe.
Na verdade o identificador this é uma referência ao objeto corrente, ou seja, aquele no qual o
método está sendo executado. E this() representa uma chamada ao construtor da classe.

A declaração de um método é feita de acordo com a sintaxe abaixo.

Visibilidade TipoDeRetorno/void nomeDoMétodo ([Lista de Parâmetros])

{
Corpo do método
[ return expressão_de_retorno ]
}
Sendo que, quando o método não necessitar retorna valor, no lugar do TipoDeRetorno deve ser
utilizado o identificador void e a expressão "return expressão_de_retorno" não deverá existir
no corpo do método.
Observação: Em Java todo parâmetro é passado por valor para um método.

Programa(s) Demonstração oo.cadastroDeClientes.Cliente.java

Java - 48
Objeto
Um objeto é criado a partir de uma classe através do identificador new seguido do construtor da
classe. O nomeDoObjeto na verdade é uma referência para o objeto criado.

TipoDoObjeto nomeDoObjeto [= new Construtor([Parâmetros])];

Java - 49
Mensagem
É a chamada a um método através do nome da classe ou objeto seguido de ".", nome do método e
lista de parâmetros entre parêntesis.

NomeDaClasse.nomeDoMétodo([ Lista de Parâmetros ])

nomeDoObjeto.nomeDoMétodo([ Lista de Parâmetros ])

Programa(s) Demonstração oo.cadastroDeClientes.ClienteApp

/**
* Application Demonstrandos as classes : Cliente, ClientePF, ClientePJ e
* Clientes
*/

package oo.cadastroDeClientes;

public class ClienteApp {

public static void main (String[] args) {

/* Declarando e instanciando um objeto do tipo Clientes */
Clientes clientes = new Clientes(50);
/* Declarando um objeto do tipo Cliente */
Cliente cliente;
/*Instanciando um objeto do tipo Cliente */
cliente = new Cliente(1, "Pelé", '2');
/* inserindo em clientes */
clientes.insere(cliente);
cliente = new Cliente(2, "Guga", '1');
clientes.insere(cliente);
cliente = new Cliente(3, "Popó", '2');
clientes.insere(cliente);
cliente = new Cliente(4, "Senna", '2');
clientes.insere(new Cliente(5,"Anderson",'8'));

System.out.println(clientes.quantidade() + " Clientes");

clientes.escreve();

/* Instanciando um objeto do tipo ClientePF */

ClientePF clientePF = new ClientePF(5, "José Maria",
'1', "661.764.335-68");
clientePF.escreve();
clientes.insere(clientePF);

/* Instanciando um objeto do tipo ClientePJ */

ClientePJ clientePJ = new ClientePJ(6, "Infonet",
'2', "99.999.999.9999");
clientePJ.escreve();
clientes.insere(clientePJ);

System.out.println("\nTodos os Clientes");

/*
* Exemplo de Polimorfismo, pois os métodos escreve() de
* ClientePF e ClientePJ são chamados automaticamente
*/
System.out.println(clientes.quantidade() + " Clientes");
clientes.escreve();

/* Conversão explícita de Cliente ClientePJ */

cliente = new ClientePJ(6, "Sefaz",'1', "99.999.999.9999");
System.out.println(((ClientePJ)cliente).cgc());
}
}

Java - 50
Sobrecarga de Métodos
Em Java é possível que uma classe possua métodos com o mesmo nome, desde que, as listas de
parâmetros sejam diferentes em quantidade, tipo ou em ordem. Esse tipo de polimorfismo é
chamado de sobrecarga de métodos.
Observação: O tipo de retorno não diferencia métodos, ou seja, não é possível definir métodos com
nome iguais e lista de parâmetros iguais, mesmo que possuam tipos de retorno diferentes.

Programa(s) Demonstração oo.sobreCarga.*

/**
* Classe com o objeto de demonstrar a sobrecarga de métodos
*/
package oo.sobreCarga;
public class SobreCarga {
public static float media (int a, int b) {
return ( a + b ) / 2;
}
public static float media (float a, float b) {
return ( a + b ) / 2;
}
public static float media (int a, int b, int c) {
return ( a + b + c ) / 3;
}
public static float media ( float a, float b, float c ) {
return ( a + b + c ) / 3;
}
/* Não é possível ter um método com apenas o tipo de retorno diferente */
/*
public static double media ( float a, float b, float c ) {
return ( a + b + c) / 3;
}
*/
}
/**
* Classe com o objeto de demonstrar a sobrecarga de métodos
*/
package oo.sobreCarga;
public class SobreCargaApp {
public static void main (String[] args) {
System.out.println( SobreCarga.media( 5, 7 ) );
System.out.println( SobreCarga.media( 5, 7, 3 ) );
System.out.println( SobreCarga.media( 8f, 2f ) );
System.out.println( SobreCarga.media( 5.3f, 7.9f, 3.1f ) );
/* Conversão explicita pra float */
System.out.println( SobreCarga.media( 8f, 4 ) );
}

Java - 51
Herança
Para que uma classe Java (SubClasse) herde atributos e métodos de outra classe Java
(SuperClasse) basta que na declaração da SubClasse o identificador extends seja seguido do
nome da SuperClasse. Assim todos os membros "públicos" serão herdados pela SubClasse. Uma
SubClasse apenas pode possuir uma SuperClasse, ou seja, herança múltipla não é permitida em
Java. Caso métodos tenham sido redefinidos e seja necessário chamar os métodos da SuperClasse
o identificador super deve ser utilizado (super.MetodoDaSuperClasse()), sendo que super()
representa o construtor da SuperClasse. Toda classe Java é automaticamente subclasse de
Object.

Java - 52
Programa(s) Demonstração oo.cadastroDeClientes.*
/**
* Classe modelando cliente com o objetivo de demonstrar os seguintes
* conceitos de orientação a objetos : Classe, Encapsulamento e Membros
* (Atributos e Métodos)
*/
package oo.cadastroDeClientes;

/* Definição da classe */
public class Cliente {
/* Corpo da classe */

/* Atributos da classe */
private int matrícula; //Matrícula do cliente
private String nome; //Nome do cliente
private char plano; //Plano de assinatura do cliente

/* Métodos da classe */

/* Construtor */
public Cliente() {
super();
}

/* Construtor */
public Cliente (int matrícula, String nome, char plano) {
setMatrícula(matrícula);
setNome(nome);
setPlano(plano);
}

/* Métodos para leitura e escrita dos atributos */

public void setMatrícula (int matrícula) {

this.matrícula = matrícula;
}

public void setNome (String nome) {

this.nome = nome;
}

public void setPlano (char plano) {

this.plano = plano;
}

public int getMatrícula () {

return matrícula;
}

public String getNome () {

return nome;
}

public char getPlano () {

return plano;
}

/* Método que escreve os atributos do cliente na saída padrão */

public void escreve() {
System.out.print(matrícula + " | " + nome);
if (plano == '1')
System.out.println(" | 20 horas");
else if (plano == '2')
System.out.println(" | Horas livres");
else
System.out.println(" | Plano Inválido");
}
}

Java - 53
/**
 SubClasse de Cliente com o objetico de demonstrar os seguintes conceitos de
 orientação a objetos : Herança, Redefinição de Métodos, Polimorfismo e
 SobreCarga de Métodos
*/

package oo.cadastroDeClientes;

public class ClientePF extends Cliente {

private String cpf;

/* Construtores */
public ClientePF () {
super();
}

public ClientePF (int matrícula, String nome, char plano) {

/* Chamando o construtor da superclasse (Cliente) */
super( matrícula, nome, plano );
}

public ClientePF (String cpf) {

/* Chamando o construtor da superclasse (Cliente) */
super(0, “”, ‘1’);
setCPF( cpf );
}

public ClientePF (int matrícula, String nome, char plano, String cpf) {
/* Chamando o construtor da superclasse (Cliente) */
super(matrícula, nome, plano);
setCPF ( cpf );
}

/* Métodos para leitura e escrita dos atributos */

public void setCPF (String cpf) {
this.cpf = cpf;
}

public String getCPF () {

return cpf;
}

/* Redefinição do método escreve da superclasse Cliente */

public void escreve () {
System.out.println(“*****************************”);
System.out.println(“Cliente Pessoa Física”);
/* Chamndo escreve da superclasse */
super.escreve();
System.out.println(“cpf : “ + cpf);
System.out.println(“*****************************”);
}
}

Java - 54
/**
* SubClasse de Cliente com o objetico de demonstrar os seguintes conceitos de
* orientação a objetos : Herança, Redefinição de Métodos, Polimorfismo e
* SobreCarga de Métodos
*/

package oo.cadastroDeClientes;

public class ClientePJ extends Cliente {

private String cgc;

public ClientePJ () {
super();
}

public ClientePJ (int matrícula, String nome, char plano, String cgc) {
super(matrícula, nome, plano);
this.cgc = cgc;
}

public void cgc (String cgc) {

this.cgc = cgc;
}

public String cgc () {

return cgc;
}

public void escreve () {

System.out.println("*****************************");
System.out.println("Cliente Pessoa Jurídica");
super.escreve();
System.out.println("cgc : " + cgc);
System.out.println("*****************************");
}
}

Java - 55
Redefinição de Métodos
É possível que métodos herdados sejam redefinidos, ou seja, implementados de uma forma diferente
bastando para isso que seja criado um método com a mesma assinatura que o método a ser
redefinido (Caso o método herdado seja final não é possível redefini-lo).

Programa(s) Demonstração oo.cadastroDeClientes.*

Java - 56
Classes e Métodos Abstratos
Numa hierarquia de classes, quanto mais alta for uma classe, mais abstrata é sua definição. Uma
classe no topo (raiz) de uma hierarquia de classes define o comportamento e atributos comuns a
todas as subclasses, e quando mais as classes estiveram próximas das folhas (abaixo) na hierarquia
de classes, mas especializadas elas serão. Assim é possível definir classes em Java que sirvam
apenas como base para uma hierarquia de classe, sendo que classes abstratas não podem ser
instanciadas. A sua utilidade é apenas servir como superclasse, onde as subclasses irão acrescentar
e redefinir seus métodos a medida da necessidade.
Para definir uma classe como abstrata basta colocar o identificador abstract na definição da
mesma.

Java - 57
Programa(s) Demonstração oo.classeAbstrata.*
/**
* Classe asbstrata pessoa
*/
package oo.classeAbstrata;
public abstract class Pessoa {
private String identificacao;
private String nome;
private String dataNascimento;
private char sexo;
public Pessoa (String id, String nome, String datNasc, char sexo) {
this.nome = nome;
this.dataNascimento = datNasc;
this.sexo = sexo;
}
public void id (String id) {
this.identificacao = id;
}
public void nome (String nome) {
this.nome = nome;
}
public void dataNascimento (String dataNascimento) {
this.dataNascimento = dataNascimento;
}
public void sexo (char sexo) {
this.sexo = sexo;
}
public String id () {
return identificacao;
}
public String nome () {
return nome;
}
public String dataNascimento () {
return dataNascimento;
}
public char sexo () {
return sexo;
}

public String toString () {

return(nome + " | " + dataNascimento + " | " + sexo);
}
}

Java - 58
Classes, Métodos e Variáveis Final
É possível definir uma classe, método ou variável como final, significando que :
Classes final não podem ser herdadas
Métodos final não podem ser redefinidos
Variáveis final não podem ter seu conteúdo alterado.
Para definir uma classe, método ou variável como final, basta acrescentar o identificador final na
definição dos mesmos.
Observação: Métodos final são executados com maior eficiência pela JVM.
Observação: Todos os métodos de uma classe final também são final, independente de possuir o
identificador final na sua declaração.
Observação: Algumas das classes da API Java são final tais como : java.lang.String,
java.lang.Math, java.net.InetAddress, ...

Programa(s) Demonstração oo.classeFinal.MinhaString

/**
* Classe que tentar herdar de String, mas não é possível, pois
* String é final e não pode ser superclasse
* Será gerado erro de compilação
*/

package oo.classeFinal;

public class MinhaString /* extends String */ {

public MinhaString() {
}
}

Java - 59
Membros Estáticos
Atributos e métodos podem ser de classe ou de objeto (instância). A diferença entre ambos está no
fato de que os membros de instância são propriedades de cada objeto e os membros de classe são
compartilhados por todos os objetos. Assim quando houver a necessidade de compartilhar o
conteúdo de um atributo com todos os objetos de uma classe, esse atributo deverá ser estático. Já
os métodos estáticos possuem a características de poder serem chamados diretamente através da
classe, sem a necessidade de instanciar um objeto. Os métodos estáticos somente podem utilizar
atributos estáticos. Para definir um membro como estático basta colocar o identificador static na
sua declaração.

Programa(s) Demonstração oo.membrosEstáticos.*

/**
* Classe para demonstrar membros estáticos
*/

package oo.membrosEstaticos;

public class MembrosEstaticos {

/* Atributo estático */
private static int contObjetos = 0;

public MembrosEstaticos () {
contObjetos++;
}

/* Método estático */
public static void numeroDeOjetos () {
System.out.println("Número de objetos instanciados : " + contObjetos);
}
}
/**
* Application para demonstrar membros estáticos
*/

package oo.membrosEstaticos;

public class MembrosEstaticosApp {

public static void main (String[] args) {

for (int i = 1; i <= 10; i++) {
MembrosEstaticos me = new MembrosEstaticos();
/* chamada ao método estático */
me.numeroDeOjetos();
}

/* chamada ao método estático */

MembrosEstaticos.numeroDeOjetos();
}
}

Java - 60
Classes Internas
São classes definidas dentro de outras classes. Normalmente são utilizadas para simular a estrutura
de dados conhecida como registro.
Observação: As classes internas geram arquivos .class diferentes sendo que o nome segue o
seguinte formato : Classe$ClasseInterna.class

Programa(s) Demonstração oo.classeInterna.*

/**
* Classe Alunos contendo a classe interna Aluno
*/

package oo.classeInterna;

public class Alunos {

private Aluno[] alunos;

private int posNovoAluno = 0;

public Alunos() {
alunos = new Aluno[10];
}

public void insere (int mat, String nome, float n1, float n2, float n3) {
alunos[posNovoAluno] = new Aluno(mat, nome, n1, n2,n3);
posNovoAluno++;
}

public void escreve () {

String linha = "****************************************************";
System.out.println(linha);
for (int i = 0; i < posNovoAluno; i++) {
alunos[i].escreve();
}
System.out.println(linha);
}

/* Classe Interna : Aluno */

class Aluno {
int matricula;
String nome;
float nota1, nota2, nota3;

Aluno (int mat, String nome, float n1, float n2, float n3) {
this.matricula = mat;
this.nome = nome;
this.nota1 = n1;
this.nota2 = n2;
this.nota3 = n3;
}

void escreve() {
String linha = "_________________________________________________";
System.out.println(linha +
"\nMatrícula : \t" + matricula +
"\nNome : \t" + nome +
"\nNotas : \t" + nota1 + "\t" + nota2 + "\t" +
nota3 +
"\n" + linha);
}
}
}

Java - 61
Interfaces
Representam a definição de comportamentos esperados na definição de classes, contendo apenas
definições de métodos abstratos e constantes, ou seja, não possuem variáveis de instância ou
implementação de métodos.
A definição de uma interface é feita semelhante a uma classe, sendo que no lugar do identificador
class é usado interface. Uma interface não pode ser instanciada, seu objetivo é definir um
modelo de comportamento abstrato para classes. Para que uma classe implemente uma interface, na
definição da classe deve ser colocado o identificador implements seguido da lista de interfaces
separadas por vírgulas. Quando uma classe implementa uma interface, é obrigado a essa classe
implementar todos os métodos definidos na interface e a classe pode acessar qualquer constante
definida na interface.

Programa(s) Demonstração oo.classeAbstrata. *

/**
* Interface modelando as operações de verificação da situação final
* de alunos
*/

package oo.classeAbstrata;

public interface SituacaoAcademica {

public static final float MEDIA = 5.0f;
public static final int FALTAS = 18;
public static final String AP = "Aprovado";
public static final String RF = "Reprovado por Falta";
public static final String RM = "Reprovado por Média";

public abstract void faltas (int faltas);

public abstract void notas (float n1, float n2, float n3);
public abstract void nota1 (float n);
public abstract void nota2 (float n);
public abstract void nota3 (float n);

public abstract String situacaoFinal ();

public abstract float media ();
public abstract int faltas ();
public abstract float nota1 ();
public abstract float nota2 ();
public abstract float nota3 ();

Java - 62
Polimorfismo
Em Java todo objeto de uma subclasse pode ser tratado como um objeto da superclasse, e isso
permite que objetos sejam tratados de forma genérica dentro de uma hierarquia de classe. É possível
também realizar uma conversão explicita de um objeto de uma classe para outra, essa operação é
conhecida como typecast e para isso é necessário colocar o tipo da classe, entre parêntesis antes do
objeto a ser convertido: (Classe) Objeto. Sendo que as classes origem e destino da conversão
devem ter relação de herança.
Obaservação : O typecast de uma subclasse para uma superclasse é automático e garantido, mas o
inverso não é garantido e é necessário o typecast explícito.
É possível verificar se um objeto é de uma determinada classe através do operador instanceof.

Programa(s) Demonstração oo.cadastroDeClientes.*

Java - 63
Tratamento de Exceções
Uma exceção em Java é um sinal que alguma condição excepcional aconteceu. Por exemplo,
solicitação de abertura de um arquivo não encontrado, índice de um array fora de faixa ou uma
conexão de rede perdida. Verificações com recursos convencionais de programação por essas
situações indesejadas, normalmente levam a programas de difícil compreensão e manutenção, pois
é comum haver mais código tratando tais situações, que código desempenhando realmente o
objetivo do programa. Java prover um mecanismo para tratar de forma sistemática essas situações
indesejadas denominado tratamento de exceções.
Exceções em Java são objetos e a hierarquia de classe possui diversas classes representando
exceções. O uso da API Java, em muitos casos, exige o tratamento dessas exceções para verificar
as potenciais situações de erros na execução dos programas.
Esse mecanismo é baseado no paradigma Tentar-e-Capturar (try-and-catch), onde, quando um
comando puder gerar exceções, o mesmo será tentado (executado) e caso a exceção ocorra, a
mesma será capturada.
Para tratar exceções à linguagem Java fornece a seguinte estrutura de comandos:
try {
/* Comandos do Try */
} catch ( TipoDaExceção1 ObjetoDaExceção1 ) {
/* Tratamento da Exceção1*/
} ... {
} catch ( TipoDaExceção2 ObjetoDaExceção2 ) {
/* Tratamento da Exceção2*/
} finally {
/* Comandos do Finally*/
}

, onde :
1º Os Comandos do Try serão executados
2º Caso ocorram exceções, o Tratamento da Exceção ocorrida será executado
3º Os Comandos do Finally serão executados
Observações
 Podem existir diversos catchs.
 Apenas uma cláusula Finally pode ser usada por try.
 Assim que um tratamento de exceção for executado os demais serão ignorados.
 Os Comandos do Finally sempre serão executados.
 Assim como qualquer classe uma exceção deve ser importada para ser usada.

Caso um método possa gerar uma exceção é possível que na definição do mesmo seja utilizado o
identificador throws seguido da lista das possíveis exceções geradas, dessa forma fica "obrigado"
(Existem exceções que não obrigam) ao usuário do método, tratar tais exceções. Ainda assim é
possível o levantamento explícito de uma exceção através do identificador throw seguido de new e
o construtor da classe da exceção.

Programa(s) Demonstração oo.tratamentoDeExcecoes.*

Java - 64
/**
* Classe representando um array de inteiros, com o objetivo de demonstrar
* Tratamento de Exceções
*/

package oo.tratamentoDeExcecoes.arrayDeInteiros;

import java.lang.NegativeArraySizeException;
import java.lang.ArrayIndexOutOfBoundsException;
import java.lang.ArithmeticException;

public class ArrayDeInteiros {

private int[] array;

int posNovo ;

public ArrayDeInteiros() {
posNovo = 0;
array = new int[10];
}

/* Obrigando o usuário do método a capturar e tratar a exceção */

public ArrayDeInteiros( int tam ) throws NegativeArraySizeException {
posNovo = 0;
array = new int[tam];
}

public ArrayDeInteiros( int[] array ) {

this.array = array;
}

/* Personalizando a mensagem da exceção e lançando-a */

public void insere ( int pos, int valor )
throws ArrayIndexOutOfBoundsException {
try {
array[pos] = valor;
} catch ( ArrayIndexOutOfBoundsException e ) {
String msg = " Erro-> Posição inválida do array : " + pos;
throw new ArrayIndexOutOfBoundsException(msg);
}
}

/* Personalizando a mensagem da exceção e lançando-a */

public void insere ( int valor )
throws ArrayIndexOutOfBoundsException {
try {
array[posNovo] = valor;
posNovo++;
} catch ( ArrayIndexOutOfBoundsException e ) {
String msg = e.getMessage() +
" Erro-> quantidade máxima de elementos encontrada " + array.length;
throw new ArrayIndexOutOfBoundsException(msg);
}
}

/* Capturando e tratando a exceção */

public float media (int posInicial, int posFinal)
throws ArrayIndexOutOfBoundsException,
ArithmeticException {
float soma = 0;
float media = 0;
int quantElementos = (posFinal - posInicial + 1);

if ( quantElementos == 0 ) {
throw new DivideByZeroException();
}

try {
for (int i = posInicial; i <= posFinal; i ++) {

Java - 65
 soma += array[i];
}
media = ( soma / quantElementos );
} catch (ArrayIndexOutOfBoundsException e1 ) {
String msg = "Erro: Intervalo[" + posInicial + "..." + posFinal +
"] Inválido";
throw new ArrayIndexOutOfBoundsException(msg);
} catch ( ArithmeticException e2 ) {
String msg = "Divisao por zero";
throw new ArrayIndexOutOfBoundsException(msg);
}

return media;
}

public float media () {

try {
return media(0, array.length - 1);
} catch ( DivideByZeroException e ) {
System.out.println("Erro :" + e.getMessage());
} finally {
return 0;
}
}

public String toString() {

StringBuffer sb = new StringBuffer();
sb.append("[");
for (int i = 0; i < (array.length - 1); i ++) {
sb.append(array[i] + ",");
}

/* Caso o tamanho do array seja 0 */

try {
sb.append(array[array.length - 1]);
} catch (ArrayIndexOutOfBoundsException e) {
/* */
};
sb.append("]");

return sb.toString();
}

public void escreve () {

System.out.println( toString() );
}

/* Exemplo de throws com uma exceção que obriga o seu tratamento*/

public void preenche (int valor) throws Exception {
for (int i = 0; i < array.length; i ++) {
array[i] = valor;
}
}
}

Java - 66
package oo.tratamentoDeExcecoes.arrayDeInteiros;

public class DivideByZeroException extends ArithmeticException {

public DivideByZeroException() {
super("Divisão por zero.");
}

public DivideByZeroException(String msg) {

super(msg);
}
}

/**
* Application demonstrando o uso da classe ArrayDeInteiros
*/

package oo.tratamentoDeExcecoes.arrayDeInteiros;

public class ArrayDeInteirosApp {

public static void main(String[] args) {

int[] n = {6,1,2,3,4,5,6,7,8,9} ;

ArrayDeInteiros inteiros = new ArrayDeInteiros( n );

inteiros.escreve();
try {
inteiros.insere(0,0);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println( e.getMessage() );
}
inteiros.escreve();
try {
inteiros.insere(-1,0);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println( e.getMessage() );
}
try {
System.out.println(inteiros.media(2,1));
} catch ( Exception e ) {
System.out.println( e.getMessage() );
}

try {
inteiros.preenche(5);
} catch (Exception e) {}
inteiros.escreve();
}
}

Java - 67
JavaDoc
JavaDoc é uma ferramenta para geração de documentação de classes, distribuída com o jdk (Java
Development Kit), sendo que, processa classes java e transforma os comentários /**...*/ em
documentos html, os quais possibilitam um "fácil" entendimento e uso das classes (API)
documentadas. Para que a documentação seja gerada adequadamente tags reconhecidas pelo
JavaDoc devem ser inseridas nos comentários.

Tag Descrição
@author autor
@version versão
@param parâmetro do método
@return retorno do método
@exception exceção
@see veja também

Java - 68
Programa(s) Demonstração controleEstoque.*
/**
* @author José Maria Rodrigues Santos Junior
* [email protected] - www.unit.br/zemaria
*
*/

package oo.controleDeEstoque.cliente;

import oo.controleDeEstoque.util.Registro;
import oo.controleDeEstoque.util.Endereco;

/**
* Classe representando um cliente
* @see oo.controleDeEstoque.util.Registro
* @see oo.controleDeEstoque.util.Endereco
* @see oo.controleDeEstoque.cliente.DataAniversario
*/
public class Cliente extends Registro {
/** data de aniversário */
public DataAniversario aniv;
/** telefone */
private String fone;
/** observacao */
private String obs;
/** endereço */
public Endereco end;

/**
* Construtor da classe
* @param cod código do cliente
* @param nome nome do cliente
* @param end endereço do cliente
* @param aniv data de aniversário
* @param fone telefone
* @param obs observação
*/
public Cliente (int cod, String nome, Endereco end,
DataAniversario aniv,
String fone, String obs) {

super(cod,nome);
this.end = end;
this.aniv = aniv;
this.fone = fone;
}

/**
* atribui o nome
* @param nome nome do cliente
*/
public void nome (String nome) {
desc(nome);
}

/**
* obtem o nome
* @return nome do cliente
*/
public String nome () {
return super.desc();
}

/**
* obtem a data de aniversário
* @return data de aniversário
* @see controleDeEstoque.cliente.DataAniversario
*/

Java - 69
 public DataAniversario dataAniversario () {
return aniv;
}

/**
* Retorna a representação string do objeto
* @return objeto como string
*/
public String toString () {
return "[" + chave() + ", " + desc() + ", " + end + ", " + aniv +
", " + fone + "]";
}
}

Comando JavaDoc para geração da documentação das classes do exemplo, executado no

diretório "C:InfoNet\Treinamento"
C:\devtools\jdk1.3\bin\javadoc.exe -d docs -version -author java\oo\controleDeEstoque\util\Registro.java
java\oo\controleDeEstoque\util\Endereco.java java\oo\controleDeEstoque\util\Arquivo.java
java\oo\controleDeEstoque\produto\Produtos.java java\oo\controleDeEstoque\produto\Produto.java
java\oo\controleDeEstoque\fornecedor\Fornecedores.java java\oo\controleDeEstoque\fornecedor\Fornecedor.java
java\oo\controleDeEstoque\fornece\Fornecimentos.java java\oo\controleDeEstoque\fornece\Fornece.java
java\oo\controleDeEstoque\cliente\DataAniversario.java java\oo\controleDeEstoque\cliente\Clientes.java
java\oo\controleDeEstoque\cliente\Cliente.java java\oo\controleDeEstoque\CliForPro.java

Site(s) http://java.sun.com/products/jdk/javadoc/index.html#javadoc1.3documents

Java - 70
Code Conventions
Um fator determinante na qualidade de um programa é como o mesmo está escrito, dessa forma,
veremos algumas regras que devem ser seguidas para padronizar a escrita de programas em Java a
fim de evitar dificuldades na leitura dos mesmo, regras estas extraídas de publicação da própria Sun
como proposta para a padronização da escrita de programas em Java.

Regras de Padronização na Escrita de Programas Java

O conteúdo de arquivos fontes JAVA segue a seguinte ordem:
1. Comentários iniciais
2. Parâmetros de Pacotes (package) e importação (import)
3. Declaração de Classes (class) ou Interfaces (interface)
Todo programa JAVA deve começar com um comentário contendo : identificação do programador, data de atualização,
informação de direitos autorais e uma breve descrição do objetivo do programa.
A tabela a seguir descreve os componentes da declaração de uma classe ou interface e indica em qual ordem os mesmos
devem aparecer.
1 Comentário de documentação da Classe/Interface
2 Parâmetro class ou interface
3 Comentário de implementação da classe/interface
4 Variáveis de classe (static) na ordem : public, protected e private
5 Variáveis de instância, na ordem : public, protected e private
6 Construtores
7 Métodos. Os quais devem ser agrupados por funcionalidade
Quatro espaços devem ser usados como unidade de endentação (Tab Space = 4)
Uma linha não deve possuir mais de 80 caracteres
Quando uma expressão não couber inteiramente em uma linha, a mesma deve ser quebrada seguindo os seguintes
princípios :
 Quebrar após uma vírgula
 Quebrar após um operador
 Quebrar preferencialmente em parênteses de nível mais alto
 Alinhar a nova linha de acordo com a expressão na linha anterior
Linhas em branco facilitam a leitura de programas, pois delimitam seções de código relacionadas logicamente.
Cada palavra dos identificadores de classes deve começar com letras maiúsculas
Identificadores de pacotes, métodos e variáveis/objetos devem começar com letras minúsculas, sendo que, quando
possuir outras palavras, às mesmas deverão começar com letra maiúscula
Identificadores de constantes devem ser escritos em letras maiúsculas e as palavras separadas por "_"

Programa(s) Demonstração oo.controleEstoque.*

Site(s) http://java.sun.com/docs/codeconv/index.html

Java - 71
API Java
A API Java é bastante extensa. O JavaDoc da API Java é a melhor referência para o programador
Java.
Os principais pacotes são :

Pacote Descrição
java.applet Applets
java.awt Interface com usuário
java.beans JavaBeans
java.io Entrada e Saída de Dados
java.lang Classes fundamentais à programação Java
java.math Operações matemáticas
java.net Implementação de aplicações de rede
java.rmi Chamada Remota de Métodos
java.security Segurança
java.sql Acesso a Banco de Dados
java.text Formatação de texto, datas e números
java.util Classes utilitárias. As principais representam estrutura de dados.
javax.accessibilit Acessibilidade
y
javax.naming Serviço de Acesso de Nomes
javax.rmi RMI-IIOP
javax.sound Som - MIDI (Musical Instrument Digital Interface)
javax.swing Interface Gráfica com o usuário

Java - 72
java.lang
Contém classes básicas para a programação Java e suas classes não precisam ser importadas, pois
todo o pacote java.lang é importado automaticamente por qualquer classe Java.

Classe Descrição
System Representa o sistema no qual as aplicações são executadas.
Runtime Representa o ambiente de execução.
Object Superclasse de toda classe Java (Raiz da hierarquia de classe), ou seja,
qualquer objeto Java é um Object.
Class Representação de classes e interface na execução de programas Java. Útil
para extrair em tempo de execução informações sobre objetos, tais como :
atributos, métodos, superclasse, etc.
String Classes para tratamento de cadeias de caracteres, sendo que a classe
StringBuffer String não permite alteração na cadeia de caracteres armazenados.
Classes Wrappers Classes que encapsulam os tipos primitivos, sendo elas : Boolean, Byte,
Character, Double, Float, Integer, Long e Short.
Math Operações matemáticas

Java - 73
Programa(s) Demonstração api.java.lang.JavaLangSystem
/* @author José Maria R S Junior
* [email protected] / www.unit.br/zemaria
*
* Aplicação para demonstrar as principais classes do pacote java.lang
* Math, Object, String, StringBuffer, System, Execptions e Wrappers
*
**/

package api.java.lang;

import java.util.Properties;
import java.util.Enumeration;
import java.io.IOException;

public class JavaLangSystem {

public static void main (String[] args) {
/* Classe System */
/* Imprindo na saída padrão */
System.out.println("Olá Mundo");
/* Obtendo e imprimindo informações do Sistema */
Properties prop = System.getProperties();
Enumeration nomesProp = prop.propertyNames();
while (nomesProp.hasMoreElements()) {
String nomeProp = nomesProp.nextElement().toString();
String valorProp = System.getProperty(nomeProp);
System.out.println(nomeProp + " = " + valorProp);
}
/* Executando o Garbage Collector */
System.gc();
}
}

Java - 74
Programa(s) Demonstração api.java.lang.JavaLangObject
package api.java.lang;

public class JavaLangObject {

/* Classe demonstrando o método equals */

static class Objeto {
String chaveA;
String chaveB;
Objeto ( String ca, String cb ) {
chaveA = ca;
chaveB = cb;
}

public boolean equals ( Objeto obj ) {

return chaveA.equals( obj.chaveA ) &&
chaveB.equals( obj.chaveB );
}

public String toString () {

return "[" + chaveA + ", " + chaveB + "]";
}
}

public static void main (String[] args) {

Objeto obj1 = new Objeto( "valor A", "valor B" );
Objeto obj2 = new Objeto( "valor A", "valor B" );
Objeto obj3 = new Objeto( "A", "B" );

Objeto obj4 = obj1;

System.out.println( obj1.equals( obj2 ) );

System.out.println( obj1.equals( obj3 ) );
System.out.println( obj1 == obj2 );
System.out.println( obj1 == obj4 );

System.out.println( obj1 );

System.out.println( "hashcode : " + obj2.hashCode() );

/* Demonstração do método clone

* Obs : O objeto deve implementar a interface Cloneable
*/
int[] array1 = {1,2,3,4,5};
int[] array2 = array1;
array1[0] = 0;
System.out.println(array1[0] + " " + array2[0]);
array2 = (int[]) array1.clone();
array1[0] = 1;
System.out.println(array1[0] + " " + array2[0]);
}
}

Java - 75
Programa(s) Demonstração api.java.lang.JavaLangClass
package api.java.lang;

import java.lang.reflect.Method;

public class JavaLangClass {

public static void main(String[] args) {

String s = "";
StringBuffer sb = new StringBuffer();
Object o = new Object();
System.out.println(nomeDaClasse(s) + "\n" + metodos(s));
System.out.println(nomeDaClasse(sb));
System.out.println(nomeDaClasse(o));
}

public static String nomeDaClasse(Object obj) {

return obj.getClass().getName();
}

public static String metodos(Object obj) {

StringBuffer resp = new StringBuffer();
Method[] metodos = obj.getClass().getMethods();
for (int i = 0; i < metodos.length; i++) {
resp.append(metodos[i] + "\n");
}
return resp.toString();
}
}

Java - 76
Programa(s) Demonstração api.java.lang.JavaLangStringStringBuffer
package api.java.lang;

public class JavaLangStringStringBuffer {

public static void main (String[] args) {
/* Operações com String */
//String strA = new String (" José Maria R S Junior ");
String strA = " José Maria R S Junior ";
for (int i = 0; i < strA.length(); i++)
System.out.println("Posição [" + i + "] Caracter + [" +
strA.charAt(i) + "]");
System.out.println("José : " + strA.indexOf("José"));
System.out.println("Junior : " + strA.indexOf("Junior"));
System.out.println(strA.toLowerCase());
System.out.println(strA.toUpperCase());
System.out.println(strA.trim());
System.out.println(String.valueOf(true));
System.out.println(String.valueOf(Math.pow(3,13)));
int tamStrA = strA.length();
System.out.println("Tamanho do Nome : " + tamStrA);
String strB = strA.substring(8,17);
System.out.println("Caracteres de 8 a 17 : " + strB);

/* Operações com StringBuffer */

StringBuffer strbA = new StringBuffer("José");
strbA.append(" R S Junior");
strbA.insert(5,"Maria ");
strbA.replace(11,12, "Rodrigues Santos");
System.out.println(strbA.toString());

String s1 = new String( "Infonet" );

String s2 = new String( "Infonet" );
if ( s1 == s2 ) {
System.out.println( "( s1 == s2 )" );
}
if ( s1.equals( s2 ) ) {
System.out.println( "( s1.equals( s2 ) )" );
}

System.out.println( "Objeto String".length() );

}
}

Java - 77
Programa(s) Demonstração api.java.lang.JavaLangWrappers
package api.java.lang;

public class JavaLangWrappers {

public static void main (String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
int inteiro = 0;
/* String para inteiro */
try {
inteiro = Integer.parseInt("1456");
} catch ( NumberFormatException e ) {
System.out.println( "Erro na conversão :" + e.getMessage() );
}
/* Inteiro para String */
String str = Integer.toString(inteiro);
/* String na base 2*/
str = Integer.toBinaryString(inteiro);
System.out.println(inteiro + " em binário é " + str);
/* String na base 8*/
str = Integer.toOctalString(inteiro);
System.out.println(inteiro + " em Octal é " + str);
/* String na base 16*/
str = Integer.toHexString(inteiro);
System.out.println(inteiro + " em Hexadecimal é " + str);
/* Objeto do tipo Interger */
Integer integer = new Integer(234);
System.out.println(integer.intValue());
}
}

Java - 78
Programa(s) Demonstração api.java.lang.JavaLangMath
package api.java.lang;

public class JavaLangMath {

public static void main (String[] args) {
/* Imprimdindo potências de 2 */
int a = 2;
int b = 20;
for (int i = a; i <= b; i++) {
System.out.println(a + " elevado a " + i +
" = " + (int) (Math.pow(a,i)));
}
/* Sorteando um número inteiro */
System.out.println("Número sorteado = " + (int) (Math.random() * 100));
/* Valor de PI */
System.out.println("PI = " + Math.PI);
}
}

Java - 79
Exceptions

ArithmeticException ArrayIndexOutOfBoundsException ArrayStoreException

ClassCastException ClassNotFoundException CloneNotSupportedException
Exception IllegalAccessException IllegalArgumentException
IllegalMonitorStateExceptio IllegalStateException IllegalThreadStateException
n
IndexOutOfBoundsException InstantiationException InterruptedException
NegativeArraySizeException NoSuchFieldException NoSuchMethodException
NullPointerException NumberFormatException RuntimeException
SecurityException StringIndexOutOfBoundsException UnsupportedOperationException

Java - 80
java.util
Pacote que tem como principal objetivo fornecer classes representando estruturas de dados
(Coleções), sendo que possui também classes de uso geral para manipulação de hora e data,
internacionalização, geração de números randômicos, etc.
Uma coleção representa um grupo de objetos agrupados em uma única classe. As coleções Java
são capazes de armazenar elementos do tipo Object, dessa forma qualquer objeto criado pode ser
armazenado nas classes coleções. As coleções possuem duas interfaces base (Collection e Map)
que determinam o seu padrão de comportamento. As classes que implementam Collection
armazém objetos, enquanto as que implementam Map armazenam pares de objetos, onde um dos
objeto s funciona como chave.

<<Interface>> <<Interface>>
Collection Map

<<Interface>>
HashMap HashTable
SortedMap

<<Interface>> <<Interface>>
Set List

TreeMap

HashSet <<Interface>> ArrayList Vector LinkedList

SortedSet

TreeSet

Interface Descrição
Collection Interface base que determina quais operações as classes armazenam coleções de
objetos deve possuir.
Set Estende a interface Collection não permitindo a repetição de elementos.
SortedSet Estende a Interface Set para manter os elementos ordenados.
List Estende a interface Collection representando uma lista de elementos.
Map Interface base para classes que armazenam elementos associados a uma chave.
SortedMap Estende a interface Map para armazenar os elementos ordenados pela chave.

Java - 81
Principais Classes
Classes Coleções
Classe Descrição
Collections Possui métodos estáticos para realizar operações sobre coleções, tais como :
copia, valor máximo e mínimo, pesquisa, ordenação, etc.
Stack Representa a estrutura de dados Pilha.
Vector Coleção de objetos, os quais podem ser acessados através do índice.
HashTable Estrutura de dados Hashtable armazenado pares de objetos (chave + dados),
não permite chaves repetidas. Os objetos armazenados devem implementar os
métodos hashcode e equals. Os valores podem ser recuperados pela chave.
TreeMap Árvore que armazena pares de objetos (chave + dados), armazenado-os em
ordem ascendente de chaves. Garante acesso em ordem de complexidade
Log(n).
TreeSet Conjunto de objetos armazenado em ordem ascendente e sem repetição.
Garante acesso em ordem de complexidade Log(n).
Observação : As classes que armazena objetos sem repetição necessitam que os objetos a ser
armazenados implementem o método public boolean equals(Object obj) e as que
armazenam objetos ordenadamente necessitam da implementação da interface comparable e
consequente redefinição do método : public int compareTO (Object obj), onde o mesmo
deve retorna um valor negativo quando obj for menor, 0 quando for igual e positivo quando for
maior.

Classes Utilitárias
Classe Descrição
StringTokenizer Permite quebrar uma string em tokens.
Date Classe Data.
Calendar Permite trabalhar com datas, extraindo seus campos (dia, mês, ano, hora, etc).
Random Geração de números randômicos.

java.text
Possui um conjunto de classes e interfaces para tratamento de texto, datas, números e mensagens.
Principais Classes
Classe Descrição
SimpleDateFormat Permite formatar, converter e tratar datas.
DecimalFormat Permite formatação de números decimais.

Java - 82
Programa(s) Demonstração api.java.util.Item
package api.java.util;

public class Item implements Comparable {

private String chave;

private String campo;

public Item ( String chave, String campo ) {

setChave( chave );
setCampo( campo );

public void setChave (String chave ) {

this.chave = chave;
}

public void setCampo (String campo ) {

this.campo = campo;
}

public String getChave () {

return chave;
}

public String getCampo () {

return campo;
}

public String toString () {

return "[" + chave + ", " + campo + "]";
}

/* Redefinindo o método equals() */

public boolean equals ( Object obj ) {
Item item = ( Item ) obj;
return getChave().equals( item.getChave() );
}
/* Redefinindo o método compareTo() */
public int compareTo ( Object obj ) {
Item item = ( Item ) obj;
return getChave().compareTo( item.getChave() );
}

Java - 83
Programa(s) Demonstração api.java.util.JavaUtilVector
package api.java.util;

import java.util.Vector;
import java.util.Collections;

public class JavaUtilVector {

public static void main (String[] args) {
/* Declarando e instanciando o vetor */
Vector itens = new Vector();

/* Inserindo itens no vetor */

Item item;
item = new Item("2", "Punisher");
itens.addElement( item );
item = new Item("4", "Wiseman");
itens.addElement( item );
item = new Item("1", "Airamez");
itens.insertElementAt(item,1);
item = new Item("3", "P4tinh0");
itens.addElement( item );
item = new Item("0", "Rampage");
itens.addElement( item );

System.out.println( "Quantidade de itens : " + itens.size() );

System.out.println( itens );
/*
* Ordenando o Vector, para isso os objetos armazenados
* devem implementar a interface Comparable e consequentemente
* redefinir o método compareTo();
*/
Collections.sort( itens );
System.out.println( "Vector ordenado : " + itens );

System.out.println( "Elemento da posiçao 3 : " + itens.get(3) );

item = new Item( "1", "José" );

System.out.println( item + " está na posiçao : " +
itens.indexOf( item ) );
System.out.println( "Removendo : " + item + " : " +
itens.remove( item ) );
System.out.println( itens );
System.out.println( "Removendo : " + item + " : " +
itens.remove( item ) );
System.out.println( itens );
System.out.println( "Removendo : " + itens.remove( 2 ) );
System.out.println( itens );
itens.clear();
System.out.println( "Itens : " + itens );
}
}

Java - 84
Programa(s) Demonstração api.java.util.JavaUtilHashtable
package api.java.util;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Enumeration;

public class JavaUtilHashtable {

public static void main(String args[]) {

/* Declarando e Instanciando o Hashtable */

Hashtable itens = new Hashtable();

/* Inserindo itens no HashTable */

Item item;
item = new Item("0", "Huguinho");
itens.put( item.getChave(), item );
item = new Item("1", "Zezinho");
itens.put( item.getChave(), item );
item = new Item("2", "Luizinho");
itens.put( item.getChave(), item );
item = new Item("3", "Tio Patinhas");
itens.put( item.getChave(), item );
item = new Item("4", "Pato Donald");
itens.put( item.getChave(), item );

System.out.println( "Quantidade de itens : " + itens.size() );

System.out.println( itens );

item = new Item("3", "Pluto");

itens.put( item.getChave(), item );

System.out.println( itens );

/* O método keys() retorna um Enumeration */

Enumeration e = itens.keys();
while(e.hasMoreElements()) {
Object chave = e.nextElement();
System.out.println( chave );
}

/*
* O metodo values() retorna um collection, o qual possui o metodo
* iterator()
*/
Iterator valores = itens.values().iterator();
while ( valores.hasNext() ) {
System.out.println( valores.next() );
}
}
}

Java - 85
Programa(s) Demonstração api.java.util.JavaUtilTreeSet
package api.java.util;

import java.util.TreeSet;
import java.util.Iterator;
import java.util.SortedSet;

public class JavaUtilTreeSet {

public static void main(String[] args) {

TreeSet itens = new TreeSet();

/* Inserindo itens no TreeSet */

Item item;
item = new Item("3", "Junior Baiano");
itens.add( item );
item = new Item("2", "Naza");
itens.add( item );
item = new Item("5", "Alemão");
itens.add( item );
item = new Item("4", "Casa Grande");
itens.add( item );
item = new Item("1", "Rocha");
itens.add( item );

/* Obtendo os elementos do TreeSet */

Iterator iterator = itens.iterator();
while ( iterator.hasNext() ) {
System.out.println( iterator.next() );
}

/* Obtendo elementos de um intervslo do TreeSet */

SortedSet itensNoIntervalo = itens.subSet(new Item("2",""),
new Item("5",""));
System.out.println("Intervalo");
iterator = itensNoIntervalo.iterator();
while ( iterator.hasNext() ) {
System.out.println( iterator.next() );
}

}
}

Java - 86
Programa(s) Demonstração api.java.util.JavautilTreeMap
package api.java.util;

import java.util.TreeMap;
import java.util.Iterator;

public class JavaUtilTreeMap {

public static void main(String[] args) {

TreeMap itens = new TreeMap();

/* Inserindo itens no TreeSet */

Item item;
item = new Item("3", "Mickel Jackson");
itens.put( item.getChave(), item );
item = new Item("2", "Maguila");
itens.put( item.getChave(), item );
item = new Item("5", "Hebe Camargo");
itens.put( item.getChave(), item );
item = new Item("4", "Ratinho");
itens.put( item.getChave(), item );
item = new Item("1", "Fernando Henrique");
itens.put( item.getChave(), item );
System.out.println( itens );
item = new Item("1", "Gil Gomes");
itens.put( item.getChave(), item );
System.out.println( itens );

System.out.println("Obtendo um elemento");
System.out.println( itens.get("3") );

System.out.println( "Itens" );

Iterator keys = itens.keySet().iterator();

while ( keys.hasNext() ) {
System.out.println( itens.get( keys.next() ) );
}

}
}

Java - 87
Programa(s) Demonstração api.java.util.JavaUtilStack
package api.java.util;

import java.util.Stack;

public class JavaUtilStack {

public static void main ( String[] args ) {

Stack stack = new Stack();

stack.push( "a" );
stack.push( "+" );
stack.push( "b" );
stack.push( "+" );
stack.push( "c" );
StringBuffer expressao = new StringBuffer();
while ( ! stack.empty() ) {
String termo = ( String ) stack.pop();
expressao.append( termo );
}
System.out.println( expressao );
}
}

Java - 88
Programa(s) Demonstração api.java.util.JavaUtilDate
package api.java.util;

import java.util.Date;
import java.util.Calendar;
import java.text.DateFormat;

public class JavaUtilDate {

public static void main(String[] args) {

Date data1 = new Date( System.currentTimeMillis() );
Date data2 = new Date( System.currentTimeMillis() + 600000) ;
Date data3 = new Date( System.currentTimeMillis() - 600000 );
System.out.println( data1 );
System.out.println( data2 );
System.out.println( data3 );
if ( data1.before( data2 ) ) {
System.out.println( data1 + " é menor que " + data2 );
}
}
}

Java - 89
Programa(s) Demonstração api.java.util.JavaUtilCalendar
package api.java.util;

import java.util.Date;
import java.util.TimeZone;
import java.util.Calendar;

public class JavaUtilCalendar {

public static void main (String[] args) {
TimeZone tz = TimeZone.getTimeZone( "GMT-3:00" );
Calendar cal = Calendar.getInstance( tz );
int dia = cal.get(Calendar.DAY_OF_MONTH);
int mes = cal.get(Calendar.MONTH);
int ano = cal.get(Calendar.YEAR);
int hora = cal.get(Calendar.HOUR);
int min = cal.get(Calendar.MINUTE);
int seg = cal.get(Calendar.SECOND);
int miliseg = cal.get(Calendar.MILLISECOND);
int diaSemana = cal.get(Calendar.DAY_OF_WEEK);
System.out.println("Data : " + dia + "/" + mes + "/" + ano);
System.out.println("Hora : " + hora + ":" + min + ":" +
seg + ":" + miliseg);
System.out.println("Dia da semana : " + diaSemana);
System.out.println(cal);
System.out.println(cal.getTime());

Date data = new Date( System.currentTimeMillis() );

cal.setTime( data );
System.out.println( cal.get( Calendar.HOUR) + ":" +
cal.get( Calendar.MINUTE ) + ":" +
cal.get( Calendar.SECOND ) + ":" +
cal.get( Calendar.MILLISECOND ) );
}
}

Java - 90
Programa(s) Demonstração api.java.util.JavaUtilRandom
package api.java.util;

import java.io.*;
import java.lang.StringBuffer;
import java.lang.NumberFormatException;
import java.util.Random;
import util.Keyboard;

public class JavaUtilRandom {

public static void main (String args[]) {

int limiteInferior = 1;
int limiteSuperior = 100;
Random r = new Random();
int numeroSorteado = r.nextInt(100);
int chute;
int tentativas = 0;

do {
System.out.print("Digite um número entre " + limiteInferior +
" e " + limiteSuperior + " = > ");
chute = Keyboard.readInt();
if ((chute >= limiteInferior) && (chute <= limiteSuperior)) {
if (chute > numeroSorteado) {
limiteSuperior = chute - 1;
} else {
limiteInferior = chute + 1;
}
} else {
System.out.println("Número digitado fora do intervalo");
}
tentativas++;
} while (chute != numeroSorteado);

System.out.println("Parabens !!, acertou em " + tentativas +

" tentativas");
}
}

Java - 91
Programa(s) Demonstração api.java.util.JavaUtilStringTokeninzer
package api.java.util;

import java.util.StringTokenizer;

public class JavaUtilStringTokenizer {

public static void main (String[] args) {
StringTokenizer st = new StringTokenizer("José Maria R S Junior");
System.out.println(st.countTokens());
while (st.hasMoreTokens()) {
System.out.println(st.nextToken());
}
st = new StringTokenizer("Campo1,Campo2,,,,Campo3, Campo4" , ",");
while (st.hasMoreTokens()) {
System.out.println(st.nextToken());
}
st = new StringTokenizer("Campo1##Campo#Campo3###Campo4#" , "#");
while (st.hasMoreTokens()) {
System.out.println(st.nextToken());
}
}
}

Java - 92
java.io
 O pacote java.io fornece uma extensa biblioteca de classes para operações de Entrada e
Saída, Serialização e acesso ao Sistema de Arquivos
 As operações de I/O são realizadas através da conexão de objetos Streams (Fluxo de
Dados), aos dispositivos de I/O. Representando assim, uma forma uniforme para operações
de I/O.
 Existem conjuntos de classes representando streams de entrada e saída, representando a
origem e o destino dos dados respectivamente.
 Filtros (streams) podem ser associados a outros streams a fim de fornecer novas
funcionalidades.
 As classes de I/O são divididas em dois grandes grupos, um grupo para dados no formato de
bytes (Stream) e outro para dados no formato de caracteres UNICODE (Read/Write).
 Esses grupos ainda são divididos em dois sub-grupos um para tratar dados de forma bruta e
outro que realiza algum tipo de processamento (buferização ou codificação).
 O pacote java.io também fornece classes para acesso randômico a arquivos e uma interface
que interage com o sistema de arquivos da plataforma host.
As interfaces e superclasses do pacote java.io fornecem o padrão de comportamento para entrada e
saída de dados. Numa operação de I/O fluxos devem ser associado a dispositivos de I/O. Os fluxos
são abertos automaticamente na sua criação e fechados com o métodos close().

Caractes Bytes
Reader InputStream (Bytes)
int read() int read()
int read(char cbuf[]) int read(byte cbuf[])
int read(char cbuf[], int offset, int length) int read(byte cbuf[], int offset, int length)
Writer OutputStream
int write(int c) int write(int c)
int write(char cbuf[]) int write(byte cbuf[])
int write(char cbuf[], int offset, int length) int write(byte cbuf[], int offset, int length)

AS OPERAÇÕES COM FLUXOS NORMALMENTE OBEDECEM AOS SEGUINTES ALGORITMOS

Leitura Escrita
open(stream) open(stream)
while (more information) while (more information)
read(information) write(information)
close(stream) close(stream)

Java - 93
File
Fornece um mecanismo independente de plataforma para acessar o sistema de arquivos.
Representa o pathname de um arquivo ou diretório e permite também realizar operações e obter
informações sobre o sistema de arquivos da máquina host, tais como : separador de arquivos,
criação de diretório, etc. Essa classe não fornece mecanismo para manipular o conteúdo do arquivo,
para isso devem ser usadas às classes : FilerReader, FileWriter, FileInputStream, FileOutputStream
e RandomAccessFile.

Java - 94
Programa(s) Demonstração api.java.io.JavaIOFile
package api.java.io;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;

public class JavaIOFile {

public static void main (String[] args) {
/* Obtendo atributos do sistema de arquivo local */
System.out.println( "Separator : " + File.separator );
System.out.println( "PathSeparador : " + File.pathSeparator );
/* Declarando e instanciando um objeto do tipo File */
File arq = new File( "arquivo.txt" );
/* Obtendo atributos da classe File */
System.out.println( "exists : " + arq.exists() );
System.out.println( "getAbsolutePath : " + arq.getAbsolutePath() );
System.out.println( "getName : " + arq.getName() );
System.out.println( "getPath : " + arq.getPath() );
System.out.println( "isDirectory : " + arq.isDirectory() );
System.out.println( "isFile : " + arq.isFile() );
System.out.println( "toString : " + arq.toString() );
System.out.println( "canWrite : " + arq.canWrite() );
System.out.println( "canRead : " + arq.canRead() );
System.out.println( "length : " + arq.length() );

/* Criando um novo arquivo no sistema de arquivos host */

try {
arq.createNewFile();
} catch (IOException e) {
System.out.println( "Erro na criação do arquivo : " +
e.getMessage());
}
/* deletando o arquivo criado */
System.out.println( "delete : " + arq.delete() );

System.out.println( );

/* Declarando e instanciando um File para p ditetório corrente */

File dirCorrente = new File( "C:\\" );
System.out.println( "getAbsolutePath : " +
dirCorrente.getAbsolutePath() );
System.out.println( "isDirectory : " +
dirCorrente.isDirectory() );
System.out.println( "isFile : " +
dirCorrente.isFile() );
/* Listando o conteúdo da classe File */
String[] conteudo = dirCorrente.list();
System.out.println( "Conteúdo : " + dirCorrente.getName() );
for (int i = 0; i < conteudo.length; i++) {
System.out.println( conteudo[i] );
}
System.out.println( );
/* Listando apenas os arquivos do diretório corrente */
File[] diretorios = dirCorrente.listFiles();
System.out.println( "Diretorios : " + dirCorrente.getName());
for (int i = 0; i < diretorios.length; i++) {
if ( diretorios[i].isDirectory() ) {
System.out.println( diretorios[i] );
}
}

}
}

Java - 95
Fluxo de Dados para Arquivos
As seguintes classes são usadas para interação com arquivos : FileReader, FileWriter,
FileInputStream, FileOutputStream e RandomAccessFile. Os fluxos para leitura e escrita em arquivos
podem ser criados através de um objeto da classe File ou FileDescriptor.

Lendo e escrevendo em arquivos texto

java.io.File;
java.io.FileReader;
java.io.FileWriter;
java.io.FileNotFoundException;
java.io.IOException;

Programa(s) Demonstração api.java.io.JavaIOFileReaderWriter

package api.java.io;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FileNotFoundException;
import java.io.IOException;

public class JavaIOFileReaderWriter {

public static void main (String[] args) {
/* Criando os objetos do tipo File */
File arqOrigem = new File( "c:\\autoexec.bat" );
File arqDestino = new File( "c:\\autoexec.bak" );
try {
/*
* Criando os Stream de leitura e escrita para os arquivos de
* origem e destino respectivamente
*/
FileReader fr = new FileReader(arqOrigem);
FileWriter fw = new FileWriter(arqDestino);
System.out.println("Copiando o arquivo " + arqOrigem +
" para " + arqDestino);
/* Verificando permissões nos arquivos */
if ( arqOrigem.canRead() && arqDestino.canWrite() ) {
int c;
/* lendo, enquando existir bytes no stream de entrada */
while ( ( c = fr.read() ) != -1 ) {
/* escrevendo no stream de saida */
fw.write(c);
char caracter = ( char ) c;
System.out.print( caracter );
}
} else {
System.out.println("Acesso não permitido");
System.out.println("Origem : " + arqOrigem.toString());
System.out.println("Destino : " + arqDestino.toString());
}
fr.close();
fw.close();
} catch ( FileNotFoundException e ) {
System.out.println("Arquivo não encontrado :" + e.getMessage());
} catch ( IOException e ) {
System.out.println("Erro de Entrada/Saída : " +
e.getMessage());
}
}
}

Java - 96
Filtrandro Fluxos e “Serializando Objetos” ( Serializable )
Serializar um objeto significa criar uma seqüência de bytes que represente o objeto, dessa forma o
mesmo pode ser trasmitido através de um stream. Para que um objeto seja serializado o mesmo
deve implementar a interface Serializable.

java.io.Serializable;
java.io.FileOutputStream;
java.io.FileInputStream;
java.io.ObjectOutputStream;
java.io.ObjectInputStream;

Java - 97
Programa(s) Demonstração api.java.io.JavaIOSerializable
package api.java.io;

import java.io.Serializable;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.FileNotFoundException;
import java.io.NotSerializableException;
import java.io.OptionalDataException;
import java.io.IOException;
import java.util.Vector;

public class JavaIOSerializable {

public static void main ( String[] args ) {

/* Declarando uma classe interna para simular registros num Vector */

class Registro implements Serializable {
int codigo;
String nome;

public Registro ( int cod, String nome ) {

this.codigo = cod;
this.nome = nome;
}

public String toString() {

return "[" + codigo + ", " + nome + "]";
}
}

Vector v = new Vector();

/* Inserindo 10 registo no Vector */
for ( int i = 1; i <= 10; i++ ) {
Registro reg = new Registro( i,"Nome_" + ( i ) );
v.add(reg);
}
System.out.println( "Vetor gerado : " + v );
try {
/* Criando um stream de escrita de arquivo*/
FileOutputStream fos = new FileOutputStream( "Vetor.dat" );
/*
* Criando um filtro (Stream) de escrita de objetos e associando-o
* ao stream de escrita de arquivo
*/
ObjectOutputStream oos = new ObjectOutputStream( fos );
/* Escrevendo o Vector */
oos.writeObject( v );
/* Esvaziando o buffer do stream */
oos.flush();
/* Fechando os Streams */
fos.close();
/* Limpando o vetor*/
v.clear();
System.out.println( "Vetor vazio :" + v );
/* Criando um stream de leitura de arquivo*/
FileInputStream fis = new FileInputStream( "Vetor.dat" );
/*
* Criando um Stream de leitura de objetos e associando-o ao
* stream de leitura de arquivo
*/
ObjectInputStream ois = new ObjectInputStream( fis );
/* Lendo o objeto do stream*/
v = ( Vector ) ois.readObject();
System.out.println( "Vetor recuperado : " + v );
/*

Java - 98
 * Demonstração da gravação e leitura de diversos objetos no arquivo
*/
/* Gravando os objetos no arquivo */
fos = new FileOutputStream( "Objetos.dat" );
oos = new ObjectOutputStream( fos );
for ( int i = 0; i < v.size(); i++ ) {
oos.writeObject( v.get( i ) );
}
v.clear();
oos.flush();
fis = new FileInputStream( "Objetos.dat" );
ois = new ObjectInputStream( fis );
try {
while ( true ) {
v.add( ois.readObject() );
}
} catch ( IOException e ) {
System.out.println( "Todos os objetos foram lidos : " +
e.getMessage() );
}
System.out.println( v );
} catch ( FileNotFoundException e ) {
System.out.println( "Arquivo não encontrado : " +
e.getMessage() );
} catch ( NotSerializableException e ) {
System.out.println( "Objeto não serializável : " +
e.getMessage() );
} catch ( IOException e ) {
System.out.println( "Erro de I/O : " + e.getMessage() );
} catch ( ClassNotFoundException e ) {
System.out.println( "Classe não encontrada : " +
e.getMessage() );
}
}
}

Java - 99
RandomAccessFile
Fornece acesso direto a arquivos, onde bytes podem ser lido e/ou gravados em uma determinada
posição do arquivo. Um objeto do tipo RandomAccess deve ser criado e associado a um arquivo
antes de ser usado.

Programa(s) Demonstração api.java.io.JavaIoRandomAccessFile

package api.java.io;

import java.io.RandomAccessFile;
import java.io.File;
import java.io.IOException;

public class JavaIoRandomAccessFile {

public static void main( String[] args ) {

File arqOrigem = new File( "c:\\autoexec.bat" );
RandomAccessFile arq;
try {
arq = new RandomAccessFile ( arqOrigem , "r");
System.out.println( "Tamanho do arquivo : " + arq.length() );
long posicaoLeitura = arq.length() - 1;
int bytesLidos = 0;
while ( posicaoLeitura >= 0 ) {
arq.seek( posicaoLeitura );
// System.out.println( "FP: " + arq.getFilePointer() );
System.out.print( ( char ) arq.read() );
bytesLidos++;
posicaoLeitura--;
}
System.out.println( "\nBytes lidos : " + bytesLidos );
} catch ( IOException e ) {
System.out.println( "Erro no acesso ao arquivo" + e.getMessage() );
}
}
}

Java - 100
Threads
Documento Threads.doc

Programa(s) Demonstração threads.*

Java - 101
java.net

Redes
Camada de Aplicação
...
Camada de Transporte
Transport Control Protocol
Comunicação ponto a ponto com confirmação de entrega. (HTTP, FTP)
User Datagram Protocol
Comunicação ponto a ponto sem confirmação de entrega.
Endereço IP ( xxx.xxx.xxx.xxx ), onde 0 <= xxx <= 254
Portas :
Número inteiro 16 bits (0..65535)
As portas de 0 a 1023 são dos Well-Known Services
TCP e UDP usam portas para mapear a comunicação com processos.
URL (Uniform Resource Locator)
Protocolo + Recurso
Socket
Endereço IP + Porta
Socket Servidor
Socket Client

Java - 102
URL

URLConnection
Programa(s) Demonstração api.java.net.url.JavaNetUrl
package api.java.net.url;

import java.io.*;
import java.net.*;
import util.Keyboard;

public class JavaNetUrl {

public static void main ( String[] args ) {
try {
String url = "http://www.unit.br:80/zemaria";
/* Declarando e instanciando um objeto do tipo URL */
URL pagina = new URL( url );
/* Obtendo propriedades do objeto URL */
System.out.println( "protocolo = " + pagina.getProtocol() );
System.out.println( "servidor = " + pagina.getHost() );
System.out.println( "arquivo = " + pagina.getFile() );
System.out.println( "porta = " + pagina.getPort() );
/* Declarando um objeto do tipo URL */
URLConnection conexaoUrl;
/* Declarando um stream de entrada */
InputStreamReader isr;
/* Declarando um stream de leitura com buffer para leitura */
BufferedReader dados;
/* String para armazenar uma linha lida */
String linha;
/* Abrindo a conexão através do objeto URL */
conexaoUrl = pagina.openConnection();
/* Conectando através do objeto URLConnection */
conexaoUrl.connect();
/* Associando o stream de entrada a conexão */
isr = new InputStreamReader( conexaoUrl.getInputStream() );
/* Associando o stream com buffer ao stream de entrada */
dados = new BufferedReader( isr );
/* Lendo linhas do stream */
while ( ( linha = dados.readLine() ) != null ) {
System.out.println( linha );
}
/* Fechando o stream */
dados.close();
} catch ( MalformedURLException e ) {
System.out.println( "Erro na URL : " + e.getMessage() );
} catch ( IOException e ){
System.out.println( "Erro de I/O : " + e.getMessage() );
}
}
}

Java - 103
Sockets

ServerSockets
Programa(s) Demonstração api.java.net.socket.ClientSocket
package api.java.net.socket;

import java.io.*;
import java.net.*;
import util.Keyboard;

public class ClientSocket {

public static void main(String[] args) {
String server = "localhost"; //Servidor
int port = 44444; //Porta
System.out.print("Mensagem : ");
/* Lendo a mensagem a ser enviado ao servidor */
String message = Keyboard.readString();
/* Stream de Entrada */
BufferedReader in = null;
/* Stream de saída */
PrintWriter out = null;
/* socket cliente */
Socket socket = null;
try {
/* Instanciando o socket */
socket = new Socket( server, port );
/* Associando os Streams de Entrada e Saída ao socket */
InputStreamReader isr =
new InputStreamReader( socket.getInputStream() );
in = new BufferedReader( isr );
out = new PrintWriter( socket.getOutputStream(), true );
/* Eviando a mensagem para o socket servidor atrvés do Stream */
out.println(message);
/* Obtendo mensagem do socket servidor */
String fromServer = in.readLine();
/* Imprimindo a mensagem recebida do socket servidor */
System.out.println("Mensagem do servidor socket : " + fromServer);
/* Fechando os streams */
out.close();
in.close();
/* Fechando o socket */
socket.close();
} catch (UnknownHostException e) {
System.err.println("Servidor não encontrado: " + server);
System.exit( 1 );
} catch (IOException e) {
System.err.println("Erro de I/O com o servidor : " + server);
System.exit( 1 );
}
}
}

Java - 104
Programa(s) Demonstração api.java.net.socket.ServerSocketThread
package api.java.net.socket;

import java.net.*;
import java.io.*;
import util.Keyboard;

public class ServerSocketThread extends Thread {

/* Socket cliente */
private Socket socket = null;
/* Mensagem a ser enviada ao cliente */
private String msg;

public ServerSocketThread( Socket socket, String msg ) {

super("ServerSocketThread");
this.socket = socket;
this.msg = msg;
}

public void run() {

try {
/* Criando e associando os Streams de I/O com o socket cliente */
PrintWriter out = new PrintWriter( socket.getOutputStream(), true );
InputStreamReader isr =
new InputStreamReader( socket.getInputStream() );
BufferedReader in = new BufferedReader( isr );
/* Obtendo e imprimindo a mensagem do socket Cliente */
String inputLine = in.readLine();
System.out.println( "Porta do socket associado ao cliente :" +
socket.getPort() );
System.out.println( "Mensagem do socket cliente : " + inputLine );
/* Enviando a mensagem para o socket cliente */
out.println( msg );
/* Fechando os Streams */
out.close();
in.close();
/* Fechando o socket cliente */
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

Java - 105
Programa(s) Demonstração api.java.net.socket.ServerSocketApplication
package api.java.net.socket;

import java.net.*;
import java.io.*;
import util.Keyboard;

public class ServerSocketApplication {

public static void main(String[] args) {
/* Socket servidor */
ServerSocket serverSocket = null;
/* Porta */
int port = 44444;
System.out.println("Inicializando a aplicação servidor socket");
try {
/* Inicializando o servidor socket */
serverSocket = new ServerSocket( port );
/* Mensagem a ser enviado ao cliente */
System.out.print( "Mensagem : " );
String msg = Keyboard.readString();
/* Laço para responder as conexões dos clientes socket */
for ( int i = 0; i <= 100; i++ ) {
/* Criando uma thread para responder ao socket cliente */
new ServerSocketThread( serverSocket.accept(), msg ).start();
}
/* fechando o socket servidor */
serverSocket.close();
} catch ( IOException e ) {
System.err.println("Erro na incialização da Porta: " + port);
System.exit(-1);
}
}
}

Programa(s) Demonstração api.java.net.socket.

Java - 106
javax.swing
Java Foundation Classes (JFC) : Conjunto de ferramentas para desenvolvimento de interfaces
gráficas, com as seguintes características :
1. Componentes SWING
2. Look and Feel
3. API de acessibilidade
4. Java 2D API
5. Suporte para Drag and Drop
Pacote : javax.swing
Os nomes dos componentes SWINGs começam com a letra "J", exemplo : JButton.
Diferentemente dos componentes AWT, os componentes SWINGs são escritos completamente em
Java sem possuir código nativo.

Componente Container
Componentes “CONTAINERES” são componentes com a capacidade de armazenar e exibir outros
componentes.
Todo programa que possuir componentes SWINGs irá necessitar de um componente container top-
level (JFrame ou JDialog), o qual prover suporte para exibição e tratamento de eventos para os
demais componentes. Sendo que, os componentes não serão inseridos diretamente no container
top-level e sim em outro componente container, JPanel por exemplo, o qual será inserido no
container top-level.

Java - 107
Layout Managers
São objetos que determinam como os componentes visuais de um container serão exibidos, com o
objetivo de permitir o ajuste automático da interface de acordo com a plataforma. Todo componente
container possui um layout manager, o qual irá controlar como os seus componentes serão exibidos
(tamanho e posição). A API padrão Java possui seis layout managers, sendo eles: FlowLayout,
GridLayout, BorderLayout, CardLayout, GridLayout e BoxLayout.
BorderLayout
Possui cinco áreas para colocação de componetes (NORTH, SOUTH, WEST, EAST E CENTER).
BoxLayout
Armazena os componentes numa simples coluna, respeitando os seus tamanhos.
CarLayout
Permite definir áreas para armazenar diferentes componentes em momentos diferentes.
FlowLayout
Armazena os componentes da esquerda para direita, passando para próxima linha quando
necessário.
GridLayout
Redimensiona os componentes para o mesmo tamanho e exibe-os numa tabela com número de
linhas e colunas especificadas.
GridBagLayout
Alinha os componentes colocando-os numa tabela, permitindo que um componente ocupe mais de
uma célula.

Java - 108
Criando uma aplicação Swing no JBuilder
Para criar uma aplicação swing devemos criar uma classe que estenda a classe
javax.swing.JFrame e em seguida utilizar a opção de design do JBuilder, lembrando que a
primeira coisa a ser feita é inserir um JPanel. O JBuilder irá a partir de agora manipular o código
fonte da classe para refletir as alterações feitas no design. Para isso o JBuilder declara e instancia
cada objeto visual utilizado como um atributo da classe e no método jbInit() realiza as alterações
nas propriedades dos objetos. Para que o JFrame seja exibido é necessário adicionar o método
this.show() ao construtor.

Tratamento de Eventos (java.awt.event e javax.swing.event)

Para tratar eventos de componentes gráficos são necessários dois passos : Registrar um event
listener e implementar um event handler. Um event listener para eventos GUI é um objeto da classe
que implementa uma ou mais interfaces event-listener do pacote java.awt.event ou do pacote
javax.swing.event. Um event handler é um método chamado automaticamente em resposta a
um evento. No caso do JBuilder o código para o tratamento de eventos é inserido automaticamente.

Programa(s) Demonstração swing.SwingApp.java

package swing;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class SwingApp extends JFrame {

JPanel jPanel1 = new JPanel();
JButton jButton1 = new JButton();

public static void main(String[] args) {

SwingApp swingApp = new SwingApp();
}

public SwingApp() {
try {
jbInit();
this.pack();
this.show();
}
catch(Exception e) {
e.printStackTrace();
}
}

private void jbInit() throws Exception {

jButton1.setText("jButton1");
jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButton1_actionPerformed(e);
}
});
this.getContentPane().add(jPanel1, BorderLayout.CENTER);
jPanel1.add(jButton1, null);
}

void jButton1_actionPerformed(ActionEvent e) {
System.out.println( "Resposta ao evento" );
}
}

Java - 109
Caixa de Diálogo
Uma forma simples de exibir diálogos é através da classe javax.swing.JOptionPane, usando
um dos métodos showXxxxDialog.

Programa(s) Demonstração swing.Dialogos.java

/**
* Title: <p> Dialogos
* Description: <p> Aplicação demonstrando o uso de diálogos swing
* @author José Maria Rodrigues Santos Junior / [email protected]
*/

package swing;

import javax.swing.JOptionPane;

public class Dialogos {

public static void main (String[] args) {

String tituloDialogo = "Título da caixa de Diálogo";
String msg = "Mensagem";
JOptionPane.showMessageDialog(null, msg);
JOptionPane.showMessageDialog(null, msg, tituloDialogo,
JOptionPane.PLAIN_MESSAGE);
JOptionPane.showMessageDialog(null, msg, tituloDialogo,
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null, msg, tituloDialogo,
JOptionPane.WARNING_MESSAGE);
JOptionPane.showMessageDialog(null, msg, tituloDialogo,
JOptionPane.ERROR_MESSAGE);
msg = "Você gosta de Java";
Object[] opcoes = {"Sim","Não","Mais ou Menos"};
int resp = JOptionPane.showOptionDialog(null, msg,
"Pergunta",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,
opcoes,
opcoes[2]
);
System.out.println("Resposta : " + opcoes[resp].toString());

String nome = JOptionPane.showInputDialog("Digite o seu nome : ");

System.out.println( "nome : " + nome );

System.exit( 0 );
}
}

Java - 110
Agenda Eletrônica usando Swing

Programa(s) Demonstração swing.agenda.ItemAgenda

/**
* Title: <p> ItemAgenda
* Description: <p> Item a ser armazenado na Agenda
* @author José Maria Rodrigues Santos Junior / [email protected]
*/

package swing.agenda;

import java.lang.Comparable;
import java.io.Serializable;

/**
* Classe representando um item a ser armazenado na agenda
*/
public class ItemAgenda implements Comparable, Serializable {
private String nome;
private String telefone;
private String email;

/**
* Construtor padrão
*/
public ItemAgenda ( ) {
}

/**
* Construtor inicializando todos os atributos
* @param nome Nome
* @param telefone Telefone
* @param email Email
*/
public ItemAgenda ( String nome, String telefone, String email ) {
setNome( nome );
setTelefone ( telefone );
setEmail ( email );
}

/**
* Atribui o nome
* @param nome Nome
*/
public void setNome ( String nome ) {
/* nome não pode ser nulo */
if ( ! nome.equals( "" ) ) {
this.nome = nome;
}
}

/**
* Atribui o telefone
* @param telefone Telefone
*/
public void setTelefone ( String telefone ) {
this.telefone = telefone;
}

/**
* Atribui o Email
* @param email Email
*/
public void setEmail ( String email ) {
this.email = email;
}

Java - 111
 /**
* Retorna o nome
* @result Nome
*/
public String getNome () {
return nome;
}

/**
* Retorna o Telefone
* @result Telefone
*/
public String getTelefone () {
return telefone;
}

/**
* Retorna o email
* @result Email
*/
public String getEmail () {
return email;
}

/**
* Retorna a representaçao String do Objeto
* @result representação String do Objeto
*/
public String toString () {
return "[" + nome + ", " + telefone + ", " + email + "]";
}

/**
* Redefiniçao do método java.Object.equals()
* @see java.lang.Object.equals()
*/
public boolean equals ( Object obj) {
/* o nome determina a igualdade */
ItemAgenda itemAgenda = ( ItemAgenda ) obj;
return getNome().endsWith( itemAgenda.getNome() );
}

/**
* Redefiniçao do método java.Comparable.compareTo()
* @see java.lang.Comparable.compareTo();
*/
public int compareTo ( Object obj ) {
ItemAgenda itemAgenda = ( ItemAgenda ) obj;
return getNome().compareTo( itemAgenda.getNome() );
}
}

Java - 112
Programa(s) Demonstração swing.agenda.ItensAgenda
/**
* Title: <p> ItensAgenda
* Description: <p> Classe para armazenar os itens da Agenda
* @author José Maria Rodrigues Santos Junior / [email protected]
*/

package swing.agenda;

import java.util.Vector;
import java.util.Collections;
import java.io.*;

/**
* Classe para armazenar uma coleçao de items da Agenda
*/
public class ItensAgenda {
/** Vector para armazenar os itens da Agenda */
private Vector itensAgenda;
/**
* Posiçao do item corrente da Agenda
*/
private int posItemCorrente;
/** Nome do arquivo para salvar/carregar o Vector dos itens da agenda */
private String arquivo;

/**
* Construtor
* @param nome do arquivo para salvar/carregar a coleçao de itens
*/
public ItensAgenda( String arquivo ) {
this.posItemCorrente = -1;
this.itensAgenda = new Vector();
this.setArquivo( arquivo );
}

private void setArquivo ( String arquivo ) {

this.arquivo = arquivo;
}

public String getArquivo () {

return arquivo;
}

public void salvar () throws Exception {

FileOutputStream fos;
ObjectOutputStream oos;
try {
fos = new FileOutputStream( getArquivo() );
oos = new ObjectOutputStream( fos );
oos.writeObject( itensAgenda );
oos.flush();
oos.close();
fos.close();
} catch ( NotSerializableException e ) {
String msg = "Objeto não serializável : " + e.getMessage();
throw new NotSerializableException( msg );
} catch ( IOException e ) {
String msg = "Erro de I/O : " + e.getMessage();
throw new IOException( msg );
}
}

public void abrir ( String arquivo ) throws Exception {

this.setArquivo( arquivo );

FileInputStream fis;
ObjectInputStream ois;

Java - 113
 try {
fis = new FileInputStream( arquivo );
ois = new ObjectInputStream( fis );
itensAgenda = ( Vector ) ois.readObject();
} catch ( FileNotFoundException e ) {
String msg = "Arquivo não encontrado : " + e.getMessage();
throw new FileNotFoundException( msg );
} catch ( IOException e ) {
String msg = "Erro de I/O : " + e.getMessage();
throw new IOException( msg );
} catch ( ClassNotFoundException e ) {
String msg = "Classe não encontrada : " + e.getMessage();
throw new ClassNotFoundException( msg );
}
posItemCorrente = 0;
}

public ItemAgenda getItemCorrente() {

if ( itensAgenda.isEmpty() ) {
return null;
} else {
return ( ItemAgenda ) itensAgenda.get( posItemCorrente );
}
}

public void primeiro () {

posItemCorrente = 0;
}

public void proximo () {

if ( posItemCorrente < itensAgenda.size() - 1 ) {
posItemCorrente++;
}
}

public void anterior () {

if ( posItemCorrente > 0 ) {
posItemCorrente--;
}
}

public void ultimo () {

posItemCorrente = itensAgenda.size() - 1;
}

public boolean existe ( ItemAgenda itemAgenda ) {

int pos = itensAgenda.indexOf( itemAgenda );
if ( pos == -1 ) {
return false;
} else {
return true;
}
}

public void procuraAproximadaPorNome ( String nome ) {

posItemCorrente = itensAgenda.size() - 1;
System.out.println( "Nome : " + nome );
for ( int i = 0 ; i < itensAgenda.size() ; i++ ) {
ItemAgenda itemAgenda = ( ItemAgenda ) itensAgenda.get( i );
String nomeAux = itemAgenda.getNome();
if ( nomeAux.toUpperCase().startsWith( nome.toUpperCase() ) ) {
posItemCorrente = i;
break;
}
}
}

public void insere ( ItemAgenda itemAgenda ) {

if ( ! itemAgenda.getNome().equals( "" ) ) {
int pos = itensAgenda.indexOf( itemAgenda );

Java - 114
 if ( pos != -1 ) {
itensAgenda.remove( pos );
}
itensAgenda.addElement( itemAgenda );
Collections.sort( itensAgenda );
posItemCorrente = itensAgenda.indexOf( itemAgenda );
}
}

public void apaga ( ) {

itensAgenda.remove( getItemCorrente() );
anterior();
}

public int quantidade () {

return itensAgenda.size();
}

public String toString () {

return itensAgenda.toString();
}
}

Java - 115
Programa(s) Demonstração swing.agenda.AgendaFrame
/**
* Title: <p> AgendaFrame
* Description: <p> Aplicação swing de Agenda Eletrônica
* @author José Maria Rodrigues Santos Junior / [email protected]
*/

package swing.agenda;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;

public class AgendaFrame extends JFrame {

/*
* Variável indicando se o item atual deve ser inserido ou atualizado.
* Caso o botao Novo tenha sido pressionado o valor será false
* Quando o botao confirma for pressiona volta ao estado padrao : true
*/
private boolean atualizacao = true;

/* Arquivo para salvar os itens da Agenda */

String nomeArquivo = "D:\\MeusDocumentos\\CursoDeJava\\Standard\\Fontes\\" +
"src\\swing\\agenda\\Agenda.dat";
/* Itens da Agenda */
ItensAgenda itensAgenda = new ItensAgenda( nomeArquivo );

/* Componentes swing, criados automaticamente pelo JBuilder */

JPanel jPanel = new JPanel();
JMenuBar jMenuBar = new JMenuBar();
JMenu jMenuArquivo = new JMenu();
JMenuItem jMenuSair = new JMenuItem();
JMenu jMenuAjuda = new JMenu();
JMenuItem jMenuSobre = new JMenuItem();
TitledBorder titledBorder1;
JLabel jLabelNome = new JLabel();
JTextField jTextFieldNome = new JTextField();
JLabel jLabelTelefone = new JLabel();
JTextField jTextFieldTelefone = new JTextField();
JLabel jLabelEmail = new JLabel();
JTextField jTextFieldEmail = new JTextField();
JPanel jPanelBotoes = new JPanel();
JButton jButtonNovo = new JButton();
JButton jButtonConfirmar = new JButton();
JButton jButtonUltimo = new JButton();
JButton jButtonProximo = new JButton();
JButton jButtonAnterior = new JButton();
JButton jButtonPrimeiro = new JButton();
JButton jButtonApagar = new JButton();
JButton jButtonProcurar = new JButton();
JMenu jMenu1 = new JMenu();
/* Agrupando os itens de rádio do menu para a escolha do LookAndFeel*/
ButtonGroup lookAndFeelButtonGroup;
JRadioButtonMenuItem jRadioButtonMenuItemMetal = new JRadioButtonMenuItem();
JRadioButtonMenuItem jRadioButtonMenuItemMotif = new JRadioButtonMenuItem();
JRadioButtonMenuItem jRadioButtonMenuItemWindows = new JRadioButtonMenuItem();

public static void main(String[] args) {

AgendaFrame agenda = new AgendaFrame();
agenda.setSize( 420,250 );
agenda.show();
}

public AgendaFrame() {
/* Inicializando os itens da agenda a partir do arquivo */
try {

Java - 116
 itensAgenda.abrir( nomeArquivo );
ItemAgendaParaJTextFields( itensAgenda.getItemCorrente() );
} catch ( Exception e ) {
JOptionPane.showMessageDialog(null, e.getMessage(), "Aviso",
JOptionPane.WARNING_MESSAGE);
}

try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}

private void jbInit() throws Exception {

titledBorder1 = new TitledBorder("");
jPanel.setLayout(null);
this.setDefaultCloseOperation(3);
this.setJMenuBar(jMenuBar);
this.setResizable(false);
this.setTitle("Agenda");
jMenuArquivo.setText("Arquivo");
jMenuSair.setText("Sair");
jMenuSair.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jMenuSair_actionPerformed(e);
}
});
jMenuAjuda.setText("Ajuda");
jMenuSobre.setText("Sobre");
jPanel.setBorder(BorderFactory.createEtchedBorder());
jLabelNome.setText("Nome");
jLabelNome.setBounds(new Rectangle(7, 16, 41, 17));
jTextFieldNome.setNextFocusableComponent(jTextFieldTelefone);
jTextFieldNome.setToolTipText("Nome");
jTextFieldNome.setBounds(new Rectangle(67, 14, 332, 21));
jLabelTelefone.setText("Telefone");
jLabelTelefone.setBounds(new Rectangle(4, 45, 52, 17));
jTextFieldTelefone.setNextFocusableComponent(jLabelEmail);
jTextFieldTelefone.setToolTipText("Telefone");
jTextFieldTelefone.setBounds(new Rectangle(67, 44, 332, 21));
jLabelEmail.setText("Email");
jLabelEmail.setBounds(new Rectangle(5, 75, 41, 17));
jTextFieldEmail.setNextFocusableComponent(jLabelNome);
jTextFieldEmail.setToolTipText("Email");
jTextFieldEmail.setBounds(new Rectangle(67, 75, 332, 20));
jPanelBotoes.setBorder(BorderFactory.createEtchedBorder());
jPanelBotoes.setBounds(new Rectangle(5, 126, 395, 61));
jPanelBotoes.setLayout(null);
jButtonNovo.setToolTipText("insere novo item");
jButtonNovo.setText("Novo");
jButtonNovo.setBounds(new Rectangle(3, 3, 99, 27));
jButtonNovo.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButtonNovo_actionPerformed(e);
}
});
jButtonConfirmar.setToolTipText("Confirma operação");
jButtonConfirmar.setText("Confirmar");
jButtonConfirmar.setBounds(new Rectangle(100, 3, 99, 27));
jButtonConfirmar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButtonConfirmar_actionPerformed(e);
}
});
jButtonUltimo.setToolTipText("Último");

Java - 117
 jButtonUltimo.setText("Último");
jButtonUltimo.setBounds(new Rectangle(294, 30, 99, 27));
jButtonUltimo.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButtonUltimo_actionPerformed(e);
}
});
jButtonProximo.setToolTipText("Próximo");
jButtonProximo.setText("Próximo");
jButtonProximo.setBounds(new Rectangle(197, 30, 99, 27));
jButtonProximo.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButtonProximo_actionPerformed(e);
}
});
jButtonAnterior.setToolTipText("Anterior");
jButtonAnterior.setText("Anterior");
jButtonAnterior.setBounds(new Rectangle(100, 30, 99, 27));
jButtonAnterior.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButtonAnterior_actionPerformed(e);
}
});
jButtonPrimeiro.setToolTipText("Primeiro");
jButtonPrimeiro.setText("Primeiro");
jButtonPrimeiro.setBounds(new Rectangle(3, 30, 99, 27));
jButtonPrimeiro.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButtonPrimeiro_actionPerformed(e);
}
});
jButtonApagar.setText("Apagar");
jButtonApagar.setBounds(new Rectangle(294, 3, 99, 27));
jButtonApagar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButtonApagar_actionPerformed(e);
}
});
jMenu1.setText("Exibir");
jRadioButtonMenuItemMetal.setSelected(true);
jRadioButtonMenuItemMetal.setText("Metal");
jRadioButtonMenuItemMetal.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jRadioButtonMenuItemMetal_actionPerformed(e);
}
});
jRadioButtonMenuItemMotif.setText("Motif");
jRadioButtonMenuItemMotif.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jRadioButtonMenuItemMotif_actionPerformed(e);
}
});
jRadioButtonMenuItemWindows.setText("Windows");
jRadioButtonMenuItemWindows.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jRadioButtonMenuItemWindows_actionPerformed(e);
}
});
/* Agrupando os rádio buttons do menu */
lookAndFeelButtonGroup = new ButtonGroup();
jButtonProcurar.setText("Procurar");
jButtonProcurar.setBounds(new Rectangle(197, 3, 99, 27));

Java - 118
 jButtonProcurar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButtonProcurar_actionPerformed(e);
}
});
lookAndFeelButtonGroup.add( jRadioButtonMenuItemMetal );
lookAndFeelButtonGroup.add( jRadioButtonMenuItemMotif );
lookAndFeelButtonGroup.add( jRadioButtonMenuItemWindows );

jMenuBar.add(jMenuArquivo);
jMenuBar.add(jMenu1);
jMenuBar.add(jMenuAjuda);
jMenuArquivo.addSeparator();
jMenuArquivo.add(jMenuSair);
jMenuAjuda.add(jMenuSobre);
jMenu1.add(jRadioButtonMenuItemMetal);
jMenu1.add(jRadioButtonMenuItemMotif);
jMenu1.add(jRadioButtonMenuItemWindows);
this.getContentPane().add(jPanel, BorderLayout.CENTER);
jPanel.add(jTextFieldTelefone, null);
jPanel.add(jTextFieldNome, null);
jPanel.add(jLabelNome, null);
jPanel.add(jLabelTelefone, null);
jPanel.add(jLabelEmail, null);
jPanel.add(jTextFieldEmail, null);
jPanel.add(jPanelBotoes, null);
jPanelBotoes.add(jButtonConfirmar, null);
jPanelBotoes.add(jButtonApagar, null);
jPanelBotoes.add(jButtonPrimeiro, null);
jPanelBotoes.add(jButtonNovo, null);
jPanelBotoes.add(jButtonAnterior, null);
jPanelBotoes.add(jButtonProximo, null);
jPanelBotoes.add(jButtonUltimo, null);
jPanelBotoes.add(jButtonProcurar, null);
}

void jMenuSair_actionPerformed(ActionEvent e) {
try {
itensAgenda.salvar();
} catch ( Exception exc ) {
JOptionPane.showMessageDialog(null, exc.getMessage(), "Aviso",
JOptionPane.WARNING_MESSAGE);
}
System.exit( 0 );
}

private void limparJTextFields() {

jTextFieldNome.setText("");
jTextFieldEmail.setText("");
jTextFieldTelefone.setText("");
}

private void jTextFieldsParaItemAgenda( ItemAgenda itemAgenda ) {

if ( itemAgenda != null ) {
if ( ! jTextFieldNome.getText().equals( "" )) {
itemAgenda.setNome( jTextFieldNome.getText() );
}
itemAgenda.setTelefone( jTextFieldTelefone.getText() );
itemAgenda.setEmail( jTextFieldEmail.getText() );
}
}

private void ItemAgendaParaJTextFields( ItemAgenda itemAgenda ) {

if ( itemAgenda != null ) {
jTextFieldNome.setText( itemAgenda.getNome() );
jTextFieldTelefone.setText( itemAgenda.getTelefone() );
jTextFieldEmail.setText( itemAgenda.getEmail() );
}
}

Java - 119
 void jButtonConfirmar_actionPerformed(ActionEvent e) {
jButtonNovo.setEnabled( true );
botoesAcoes( true );
botoesNavegacao( true );
if ( atualizacao ) {
jTextFieldsParaItemAgenda( itensAgenda.getItemCorrente() );
} else {
ItemAgenda itemAgenda = new ItemAgenda();
jTextFieldsParaItemAgenda( itemAgenda );
if ( ! itensAgenda.existe( itemAgenda ) ) {
itensAgenda.insere( itemAgenda );
} else {
String msg = "Item já cadastrado.";
String pergunta = "Deseja substiruir ?";
Object[] opcoes = {"Sim","Não"};
int resp = JOptionPane.showOptionDialog(null, pergunta,
msg,
JOptionPane.YES_NO_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,
opcoes,
opcoes[1]
);
if ( resp == 0 ) {
itensAgenda.insere( itemAgenda );
}
}
}
atualizacao = true ;
this.exibirItemCorrente();
System.out.println( "Agenda = " + itensAgenda);
System.out.println( "Item Corrente = " +
itensAgenda.getItemCorrente() );
}

private void botoesAcoes ( boolean situacao ) {

jButtonApagar.setEnabled( situacao );
jButtonProcurar.setEnabled( situacao );
}

private void botoesNavegacao ( boolean situacao ) {

jButtonPrimeiro.setEnabled( situacao );
jButtonAnterior.setEnabled( situacao );
jButtonProximo.setEnabled( situacao );
jButtonUltimo.setEnabled( situacao );
}

private void exibirItemCorrente () {

if ( itensAgenda.getItemCorrente() == null ) {
this.limparJTextFields();
}
ItemAgendaParaJTextFields( itensAgenda.getItemCorrente() );
}

void jRadioButtonMenuItemMetal_actionPerformed(ActionEvent e) {
lookAndFeel ( 0 );
}

void jRadioButtonMenuItemMotif_actionPerformed(ActionEvent e) {
lookAndFeel ( 1 );
}

void jRadioButtonMenuItemWindows_actionPerformed(ActionEvent e) {
lookAndFeel ( 2 );
}

private void lookAndFeel ( int lf ) {

UIManager.LookAndFeelInfo[] lookAndFeel;
lookAndFeel = UIManager.getInstalledLookAndFeels();

Java - 120
 try {
UIManager.setLookAndFeel(
lookAndFeel[lf].getClassName());
SwingUtilities.updateComponentTreeUI(this);
} catch ( Exception e ) {
System.out.println( "Problemas na alteração do LookAndFeel :" +
e.hashCode() );
}
}

private void escreveAgenda () {

System.out.println( "Agenda = " + itensAgenda);
System.out.println( "Item Corrente = " +
itensAgenda.getItemCorrente() );
}

void jButtonNovo_actionPerformed(ActionEvent e) {
atualizacao = false;
limparJTextFields();
botoesAcoes( false );
botoesNavegacao( false );
jButtonNovo.setEnabled( false );
jTextFieldNome.requestFocus();
}

void jButtonProcurar_actionPerformed(ActionEvent e) {
String nome = JOptionPane.showInputDialog(null,"Nome : ",
"Procura por nome",
JOptionPane.PLAIN_MESSAGE);
if ( nome != null ) {
itensAgenda.procuraAproximadaPorNome( nome );
this.exibirItemCorrente();
}
this.escreveAgenda();
}

void jButtonApagar_actionPerformed(ActionEvent e) {
itensAgenda.apaga( );
exibirItemCorrente();
this.escreveAgenda();
}

void jButtonPrimeiro_actionPerformed(ActionEvent e) {
this.itensAgenda.primeiro();
this.exibirItemCorrente();
this.escreveAgenda();
}

void jButtonAnterior_actionPerformed(ActionEvent e) {
this.itensAgenda.anterior();
this.exibirItemCorrente();
this.escreveAgenda();
}

void jButtonProximo_actionPerformed(ActionEvent e) {
this.itensAgenda.proximo();
this.exibirItemCorrente();
this.escreveAgenda();
}

void jButtonUltimo_actionPerformed(ActionEvent e) {
this.itensAgenda.ultimo();
this.exibirItemCorrente();
this.escreveAgenda();
}
}

Java - 121
java.sql.jdbc
JDBC representa a definição de uma API para acesso, através da linguagem Java, a Sistemas
Gerenciadores de Banco de Dados. Isto permite que através da API JDBC um programa Java
acesse o banco de dados independente do SGBD, desde que exista a implementação do driver
JDBC para o SGBD utilizado. Desta forma, a linguagem Java fornece independência de plataforma e
JDBC fornece independência de SGBD.
JDBC representa uma interface de baixo nível fornecendo mecanismos para executar setenças sql
em bancos de dados relacionais, servindo como base para o desenvolvimento de interfaces de níveis
mais alto.
SQL é uma linguagem padrão, mas nem tanto assim, pois há variações consideráveis entre SGBDs,
a maioria delas, relacionadas aos tipos de dados, dessa forma JDBC defini um conjunto de tipos
genéricos na classe java.sql.Types. Em relação às divergências dos comandos SQLs, JDBC
permite que qualquer setença SQL seja enviada ao SGBD, sendo que caso o SGBD utilizado não
suporte tal setença uma SQLException será lançada.
JDBC fornece também o recurso de obter metadados, através da classe DatabaseMetadata, sobre
o banco de dados em uso, dessa forma é possível que a aplicação faça ajustes em relação a
características do SGBD em uso.
Para que um programa Java acesse um SGBD com JDBC o driver JBDC do SGBD (implementado
pelo fabricante do SGBD) a ser utilizado deve está disponível.

Java - 122
Programa(s) Demonstração jdbc.listaDiscussao.ListaDiscussaoApp
package jdbc.listaDiscussao;

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.Date;
import java.text.SimpleDateFormat;
import java.util.Locale;

public class ListaDiscussaoApp implements DataBaseConstantes {

public static void main(String[] args) {

/* Carregando o driver JDBC para um determinado SGBD*/

try {
/* Instanciando a classe do driver através do seu nome */
Class.forName( DRV );
System.out.println( "Driver JDBC carregado" );
} catch ( ClassNotFoundException cnfe ) {
System.out.println( "Driver JDBC não encontrado : " +
cnfe.getMessage() );
}

/* Criando conexão com o banco de dados */

Connection con = null;
try {
/* Obtendo a conexão com o banco de dados */
con = DriverManager.getConnection( URL, USUARIO, SENHA );
System.out.println( "Conexão com o banco de dados estabelecida." );
} catch ( SQLException sqle ) {
System.out.println( "Erro na conexão ao Bando de Dados : " +
sqle.getMessage() );
}

/* Obtendo objeto para executar comandos sql */

Statement stmt = null;
try {
stmt = con.createStatement();
System.out.println( "Preparação para execução de comandos sql." );
} catch ( SQLException sqle ) {
System.out.println( "Erro no acesso ao Bando de Dados : " +
sqle.getMessage() );
}

/* Executando comandos SQL */

/* criando tabelas */
try {
criaTabelas( stmt );
} catch (Exception e) {
System.out.println(e.getMessage());
}

/* Inserindo dados nas tabelas */

try {
} catch (Exception e) {
System.out.println(e.getMessage());
}

/* Consultando as tabelas */
consultaTabelas( stmt );

/* fechando a conexão com o SGBD */

Java - 123
 try {
con.close();
System.out.println( "Conexão com o banco de dados fechada" );
} catch ( SQLException sqle ) {
System.out.println( "Erro no fechamento da conexão : " );
}
}

public static void criaTabelas ( Statement stmt ) throws SQLException {

/* Comandos sql para criação das tabelas */

final String TB_MEM_MEMBRO =
"CREATE TABLE TB_MEM_MEMBRO (" +
"MEM_CD_MEMBRO VARCHAR(10) NOT NULL," +
"MEM_NM_MEMBRO VARCHAR(50) NOT NULL, " +
"MEM_EMAIL VARCHAR(50) NOT NULL UNIQUE," +
"MEM_SENHA VARCHAR(10) NOT NULL," +
"PRIMARY KEY (MEM_CD_Membro)" +
");";

final String TB_LST_LISTA =

"CREATE TABLE TB_LST_LISTA (" +
"LST_CD_LISTA VARCHAR(10) NOT NULL," +
"LST_NN_LISTA VARCHAR(40) NOT NULL UNIQUE," +
"LST_OBJETIVO VARCHAR(30) NOT NULL," +
"LST_DT_CRIACAO DATETIME NOT NULL," +
"PRIMARY KEY (LST_CD_LISTA)" +
");";

final String TB_ML_MEMBRO_LISTA =

"CREATE TABLE TB_ML_MEMBRO_LISTA (" +
"ML_CD_MEMBRO VARCHAR(10) NOT NULL," +
"ML_CD_LISTA VARCHAR(10) NOT NULL," +
"ML_DT_ENTRADA DATETIME NOT NULL," +
"ML_DT_SAIDA DATETIME," +
"PRIMARY KEY (ML_CD_MEMBRO, ML_CD_LISTA)," +
"FOREIGN KEY (ML_CD_LISTA)" +
"REFERENCES TB_LST_LISTA," +
"FOREIGN KEY (ML_CD_MEMBRO)" +
" REFERENCES TB_MEM_MEMBRO" +
");";

final String TB_MSG_MENSAGEM =

"CREATE TABLE TB_MSG_MENSAGEM (" +
"MSG_CD_MENSAGEM VARCHAR(10) NOT NULL," +
"MSG_CD_LISTA VARCHAR(10) NOT NULL," +
"MSG_TITULO VARCHAR(20) NOT NULL," +
"MSG_DT_MENSAGEM CHAR(18) NOT NULL," +
"MSG_MENSAGEM VARCHAR(400) NOT NULL," +
"PRIMARY KEY (MSG_CD_MENSAGEM)," +
"FOREIGN KEY (MSG_CD_LISTA) REFERENCES TB_LST_LISTA" +
");";
try {
/* Executando comandos sql de atualização */
stmt.executeUpdate( TB_MEM_MEMBRO );
System.out.println( TB_MEM_MEMBRO );

stmt.executeUpdate( TB_LST_LISTA );
System.out.println( TB_LST_LISTA );

stmt.executeUpdate( TB_MSG_MENSAGEM );
System.out.println( TB_MSG_MENSAGEM );

stmt.executeUpdate( TB_ML_MEMBRO_LISTA );
System.out.println( TB_ML_MEMBRO_LISTA );

System.out.println( "<<<<< TABELAS CRIADAS >>>>>" );

} catch ( SQLException sqle ) {
throw new SQLException("Erro na criaçao das tabelas : " +
"getMessage() = " + sqle.getMessage() +

Java - 124
 "\ngetErrorCode() = " + sqle.getErrorCode() );
}
}

public static void insereDadosTabelas ( Statement stmt ) throws SQLException {

try {
String insert;
/* Inserindo na tabela de membros */
insert = "INSERT INTO TB_MEM_MEMBRO VALUES " +
"('1', 'Bill Gates', '[email protected]', 'windows')";
System.out.println( insert );
stmt.executeUpdate(insert);
insert = "INSERT INTO TB_MEM_MEMBRO VALUES " +
"('2', 'Pelé', '[email protected]', 'gol')";
System.out.println( insert );
stmt.executeUpdate(insert);
insert = "INSERT INTO TB_MEM_MEMBRO VALUES " +
"('3', 'Senna', '[email protected]', 'galisteu')";
System.out.println( insert );
stmt.executeUpdate(insert);
System.out.println( "Registros de membros inseridos." );

/* Inserindo na tabela de lista */

/* Obtendo a hora corrente e formatando para o comando insert */
SimpleDateFormat formatter
= new SimpleDateFormat ( "dd-MMM-yyyy", Locale.US );
Date currentTime = new Date( System.currentTimeMillis() );
String data = formatter.format( currentTime );

insert = "INSERT INTO TB_LST_LISTA VALUES " +

"('1', 'Informática', 'Java', '" + data.toUpperCase() +
"')";
stmt.executeUpdate(insert);
System.out.println( insert );
insert = "INSERT INTO TB_LST_LISTA VALUES " +
"('2', 'Futebol', 'Futebol', '" + data.toUpperCase() +
"');";
stmt.executeUpdate(insert);
System.out.println( insert );
insert = "INSERT INTO TB_LST_LISTA VALUES " +
"('3', 'Fórmula 1', 'F1', '" + data.toUpperCase() +
"')";
stmt.executeUpdate(insert);
System.out.println( insert );
System.out.println( "Registros de lista inseridos." );
} catch ( SQLException sqle ) {
throw new SQLException("Erro inserindo registros : \n" +
"getMessage() = " + sqle.getMessage() +
"\ngetErrorCode() = " + sqle.getErrorCode() );
}
}

public static void consultaTabelas( Statement stmt ) {

try {
/* Consultando a tabela de Membros */
String selectTbMembro = "SELECT * FROM TB_MEM_Membro";
System.out.println( selectTbMembro );
/* Executando e obtendo o resultado do comandos sql de consulta */
ResultSet rs = stmt.executeQuery( selectTbMembro );
/* Navegando pelo resultado */
while ( rs.next() ) {
System.out.print( rs.getString( "MEM_NM_Membro" ) );
System.out.print( " - " );
System.out.println( rs.getString( "MEM_Email" ) );
}

/* Consultando a tabela de Listas */

String selectTbLista = "select * from TB_LST_Lista";
System.out.println( selectTbLista );
/* Obtendo o resultado do comando SQL */

Java - 125
 rs = stmt.executeQuery( selectTbLista );
/* Navegando pelo resultado */
while ( rs.next() ) {
System.out.print( rs.getString( 2 ) );
System.out.print( " - " );
System.out.println( rs.getString( 3 ) );
}

} catch ( SQLException sqle ) {

System.out.println( "Erro executando consulta : " +
sqle.getMessage() );
}
}
}

Java - 126
Comandos SQL Preparados
Programa(s) Demonstração jdbc.listaDiscussao.JavaSqlPreparedStatement
package jdbc.listaDiscussao;

import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JavaSqlPreparedStatement implements DataBaseConstantes {

public static void main( String[] args ) {

Connection con = null;
try {
Class.forName( DRV );
System.out.println( "Driver JDBC carregado" );
con = DriverManager.getConnection( URL, USUARIO, SENHA );
System.out.println( "Conexão com o banco de dados estabelecida." );
} catch ( ClassNotFoundException cnfe ) {
System.out.println( "Driver JDBC não encontrado : " +
cnfe.getMessage() );
} catch ( SQLException sqle ) {
System.out.println( "Erro na conexão ao Bando de Dados : " +
sqle.getMessage() );
}

/* Executando comandos sql através do objeto PreparedStatement */

try {
/* Selecionando Lista por código */
String selectLista = "SELECT * FROM TB_LST_LISTA" +
" WHERE LST_CD_LISTA = ?";
/* Criando o comando sql preparado */
PreparedStatement ps = con.prepareStatement( selectLista );
for ( int i = 1; i <= 3 ; i ++ ) {
/* Substituindo parâmetros do comando sql preparado */
ps.setString( 1, Integer.toString( i ) );
/* Executando o comandos sql preparado */
ResultSet rs = ps.executeQuery();
/* Exibindo os resultados */
if ( rs.next() ) {
System.out.println( i + " - " + rs.getString( 2 ) );
}
}
} catch ( SQLException sqle ) {
System.out.println( "Erro efetuando consulta : " +
sqle.getMessage() );

try {
con.close();
System.out.println( "Conexão com o banco de dados fechada" );
} catch ( SQLException sqle ) {
System.out.println( "Erro no fechamento da conexão : " +
sqle.getMessage() );
}
}
}

Java - 127
Procedimentos Armazenados – Stored Procedures
Programa(s) Demonstração jdbc.listaDiscussao.JavaSqlStoredProcedure
package jdbc.listaDiscussao;

import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.CallableStatement;
import java.sql.ResultSet;
import java.sql.Types;

public class JavaSqlStoredProcedure implements DataBaseConstantes {

public static void main ( String[] args ) {

Statement stmt = null;

Connection con = null;
try {
stmt = DataBaseConnection.getStatement( DRV, URL, USUARIO, SENHA );
con = DataBaseConnection.getConnection( DRV, URL, USUARIO, SENHA );
System.out.println("Conexão com o Banco de dados estabelecida");
} catch ( ClassNotFoundException cnfe ) {
System.out.println( cnfe.getMessage() );
} catch ( SQLException sqle ) {
System.out.println( sqle.getMessage() );
}

/* Criando as Stored Procedures */

try {
System.out.println("Criando Stored Procedured 1");
criaStoredProcedure1(stmt);
} catch (Exception e) {
System.out.println(e.getMessage());
}

try {
System.out.println("Criando Stored Procedured 2");
criaStoredProcedure2(stmt);
} catch (Exception e) {
System.out.println(e.getMessage());
}

/* Executando as Stored Procedures */

try {
System.out.println("Executando Stored Procedured 1");
executaStoredProcedure1(con, stmt);
} catch (Exception e) {
System.out.println(e.getMessage());
}
try {
System.out.println("Executando Stored Procedured 2");
executaStoredProcedure2(con, stmt);
} catch (Exception e) {
System.out.println(e.getMessage());
}

/* Fechando a conexão */
try {
con.close();
System.out.println( "Conexão com o banco de dados fechada" );
} catch ( SQLException sqle ) {
System.out.println( "Erro no fechamento da conexão : " +
sqle.getMessage() );
}
}

Java - 128
 private static void criaStoredProcedure1 (Statement stmt) {
/* Comando sql para criação da strored procedure */
String storedProcedure =
"CREATE PROCEDURE INSERE_MEMBRO" +
"(@codigo VARCHAR(10), @nome VARCHAR(50), @email VARCHAR(50), @senha VARCHAR(10))"
+
"AS " +
" INSERT INTO TB_MEM_MEMBRO (MEM_CD_MEMBRO, MEM_NM_MEMBRO, MEM_EMAIL , MEM_SENHA)"
+
" VALUES (@codigo, @nome, @email, @senha)";
try {
/* Executando o comando sql de criação da stored procedure */
stmt.executeUpdate( storedProcedure );
System.out.println( "Stored Procedure criada" );
} catch ( SQLException sqle ) {
System.out.println( "Erro criando a Stored Procedure :" +
sqle.getMessage() );
}

}
private static void criaStoredProcedure2 (Statement stmt) {
/* Exemplo de Stored Procedure que retorna valores */
String storedProcedure =
"CREATE PROCEDURE MEMBRO_LOGIN" +
"(@codigo VARCHAR(10))" +
"AS" +
" SELECT MEM_EMAIL, MEM_SENHA" +
" FROM TB_MEM_MEMBRO " +
" WHERE MEM_CD_MEMBRO = @codigo";

try {
stmt.executeUpdate( storedProcedure );
System.out.println( "Stored Procedure criada" );
} catch ( SQLException sqle ) {
System.out.println("Erro criando a Stored Procedure :" +
sqle.getMessage() +
"ErrorCode: " + sqle.getErrorCode());
}
}

private static void executaStoredProcedure1 (Connection con, Statement stmt) {

/* Excetudando a Stored Procedure */
try {
/* String com a chamada a stored procedure */
String storedProcedureCall = "{call INSERE_MEMBRO(?,?,?,?)}";
/* Preparando chamada à estored procedure */
CallableStatement cstmt = con.prepareCall( storedProcedureCall );
/* Setando os parãmetros da stored procedure */
String codigo = "90";
String nome = "Zagallo";
String email = "[email protected]";
String senha = "4x0";
cstmt.setString(1, codigo);
cstmt.setString(2, nome);
cstmt.setString(3, email);
cstmt.setString(4, senha);
/* Executando a stotred procedure */
cstmt.executeUpdate();
System.out.println("Stored Procedure Executada.");
} catch ( SQLException sqle ) {
System.out.println("Erro executando a Stored Procedure: " +
sqle.getMessage() +
"ErrorCode: " + sqle.getErrorCode());
}
}

private static void executaStoredProcedure2 (Connection con, Statement stmt) {

/* Preparando, excetudando e retornando valores da Stored Procedure */
try {
String storedProcedureCall = "{call MEMBRO_LOGIN(?)}";

Java - 129
 CallableStatement cstmt = con.prepareCall( storedProcedureCall );
String codigo = "90";
cstmt.setString(1, codigo);
// cstmt.execute();
/* Executando a stored procedure e obtendo o seu retorno */
ResultSet rs = cstmt.executeQuery();
if ( rs.next() ) {
String email = rs.getString(1);
String senha = rs.getString(2);
System.out.println("Email : " + email);
System.out.println("Senha : " + senha);
}
System.out.println( "Stored Procedure Executada." );
} catch ( SQLException sqle ) {
System.out.println( "Erro executando a Stored Procedure : " +
sqle.getMessage() +
"ErrorCode: " + sqle.getErrorCode());
}
}
}

Java - 130
Controle de Transações
Programa(s) Demonstração jdbc.listaDiscussao.JavaSqlTransacao
package jdbc.listaDiscussao;

import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.Statement;

public class JavaSqlTransacao implements DataBaseConstantes {

public static void main(String[] args) {

Connection con = null;
Statement stmt = null;
try {
Class.forName( DRV );
System.out.println( "Driver JDBC carregado" );
con = DriverManager.getConnection( URL, USUARIO, SENHA );
System.out.println( "Conexão com o banco de dados estabelecida." );
stmt = con.createStatement();
} catch ( ClassNotFoundException cnfe ) {
System.out.println( "Driver JDBC não encontrado : " +
cnfe.getMessage() );
} catch ( SQLException sqle ) {
System.out.println( "Erro na conexão ao Bando de Dados : " +
sqle.getMessage() );
}

/* Comandos sql da transação */

String comando1 = "INSERT INTO TB_MEM_MEMBRO VALUES " +
"('99', 'Luis Amstrong', '[email protected]', 'music')";
String comando2 = "INSERT INTO TB_LST_LISTA VALUES " +
"('99', 'Música', 'Música', '15-JAN-2000')";
/* Criando a transaçao */
try {
/* Desligando o Commit automático */
con.setAutoCommit( false );
/* Executando o primeiro comando da transação */
stmt.executeUpdate( comando1 );
/* Simulando o acontecimento de uma exceção */
if ( true ) {
throw new SQLException("Erro provocado");
}
/* Executando o segundo comando da transação */
stmt.executeUpdate( comando2 );
/* Efetuando o Commit */
con.commit();
System.out.println( "Transação realizada" );
} catch ( SQLException sqle ) {
/* Desfazendo os comandos */
try {
con.rollback();
System.out.println( "Transação não realizada" );
} catch ( SQLException sqlerb ) {
System.out.println( "Erro na recuperação das transações : " +
sqlerb.getMessage() );
}
} finally {
/* Ligando o Commit automático */
try {
con.setAutoCommit( true );
} catch ( SQLException e ) {
System.out.println( "Erro ligando o AutoCommmit" +
e.getMessage() );
}
}
}

Java - 131
}

Java - 132
Metadados de comandos SQL
Programa(s) Demonstração jdbc.listaDiscussao.JavaSqlResultSetMetaData
package jdbc.listaDiscussao;

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

public class JavaSqlResultSetMetaData implements DataBaseConstantes {

public static void main(String[] args) {

Statement stmt = null;
try {
stmt = DataBaseConnection.getStatement(DRV,URL , USUARIO, SENHA );
} catch ( ClassNotFoundException cnfe ) {
System.out.println( cnfe.getMessage() );
} catch ( SQLException sqle ) {
System.out.println( sqle.getMessage() );
}

try {
/* Comando sql a ser executado */
String query = "SELECT * FROM TB_LST_LISTA";
/* Executando o comando sql */
ResultSet rs = stmt.executeQuery( query );
/* Obtendo objeto com metadados do resultado da execução */
ResultSetMetaData rsmd = rs.getMetaData();
System.out.println( "[ ColumnLabel , ColumnName, " +
"ColumnType , ColumnTypeName ]" );
/* Obtendo metados */
for ( int i = 1 ; i <= rsmd.getColumnCount() ; i++ ) {
System.out.print( rsmd.getColumnLabel( i ) + " , " );
System.out.print( rsmd.getColumnName( i ) + " , " );
System.out.print( rsmd.getColumnType( i ) + " , " );
System.out.println( rsmd.getColumnTypeName( i ) );
}
} catch ( SQLException sqle ) {
System.out.println( "Erro obtendo metadadata :" +
sqle.getMessage() );
}
}
}

Java - 133
Metadados do Banco de Dados
Programa(s) Demonstração jdbc.listaDiscussao.JavaSqlDatabaseMetaData
package jdbc.listaDiscussao;

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

public class JavaSqlDatabaseMetaData implements DataBaseConstantes {

public static void main(String[] args) {

Connection con = null;
try {
con = DataBaseConnection.getConnection( DRV, URL, USUARIO, SENHA );
} catch ( ClassNotFoundException cnfe ) {
System.out.println( cnfe.getMessage() );
} catch ( SQLException sqle ) {
System.out.println( sqle.getMessage() );
}

try {
/* Obtendo objeto com metadados do banco de dados */
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = null;
/* Obtendo metadados do banco de dados */

System.out.println( "DriverName = " + dbmd.getDriverName() );

System.out.println( "DriverVersion = " + dbmd.getDriverVersion() );
/* tipos de tabelas a serem obtidas */
String[] tableTypes = {"TABLE", "VIEW"};
/* Obtendo todas as tabelas dos tipos especificados */
rs = dbmd.getTables(null, null, "%", tableTypes );
System.out.println( "Tabelas do banco : " );
imprimeResultSet( rs );
/* Obtendo as chaves primárias de uma tabela */
rs = dbmd.getPrimaryKeys(null, null, "TB_MEM_MEMBRO");
System.out.println( "Chave primária" );
imprimeResultSet( rs );
/* Obtendo os campos únicos de uma tabela */
rs = dbmd.getIndexInfo(null, null, "TB_MEM_MEMBRO", true, false);
System.out.println("Campos únicos da tabela TB_MEM_MEMBRO");
imprimeResultSet(rs);
} catch ( SQLException sqle ) {
System.out.println( "Erro obtendo metadata." );
}
}

public static void imprimeResultSet ( ResultSet rs ){

try {
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount();
while ( rs.next() ) {
for ( int i = 1 ; i <= columnCount ; i++ ) {
System.out.print( rs.getString( i ) + " ");
}
System.out.println( );
}
} catch ( Exception e ) {
}
}
}

Java - 134
Interface com as contantes para as operações no banco de dados
Programa(s) Demonstração jdbc.listaDiscussao.DataBaseConstantes
package jdbc.listaDiscussao;

public interface DataBaseConstantes {

/* Nomes dos drives JDBC do Interbase, SqlServer e Oracle*/
// public final static String DRV = "interbase.interclient.Driver";
// public final static String DRV = "oracle.jdbc.driver.OracleDriver";
public final static String DRV =
"com.microsoft.jdbc.sqlserver.SQLServerDriver";

/* URLs para o Interbase, SqlServer e Oracle*/

// public final static String URL = "jdbc:interbase://localhost/D:/temp/BD.GDB";
// public final static String URL = "jdbc:oracle:thin:@localhost:1521:ORCL";
public final static String URL = "jdbc:microsoft:sqlserver://localhost:1433";

/* Usuário e senha para conexão */

public final static String USUARIO = "ListaDiscussao";
public final static String SENHA = "ListaDiscussao";
}

Java - 135
Classe utilitária facilitando o acesso e execução de comandos sql
Programa(s) Demonstração jdbc.listaDiscussao.DataBaseConnection
/**
* Classe com métodos estático permitindo a conexão com o banco de dados e
* a obtenção do objeto statement para exexução de comandos sql
*/
package jdbc.listaDiscussao;

import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.Statement;

public class DataBaseConnection {

public static Connection getConnection (String driver, String url,

String usuario, String senha )
throws ClassNotFoundException, SQLException {

Connection con = null;

try {
Class.forName( driver );
System.out.println( "Driver JDBC carregado" );
con = DriverManager.getConnection( url, usuario, senha );
System.out.println( "Conexão com o banco de dados estabelecida." );
} catch ( ClassNotFoundException cnfe ) {
String msg = "Driver JDBC não encontrado : " + cnfe.getMessage();
throw new ClassNotFoundException( msg );
} catch ( SQLException sqle ) {
String msg = "Erro na conexão ao Bando de Dados : " +
sqle.getMessage();
throw new SQLException( msg );
}
return con;
}

public static Statement getStatement (String driver, String urlBD,

String usuario, String senha)
throws ClassNotFoundException, SQLException {

Connection con = null;

try {
con = DataBaseConnection.getConnection( driver, urlBD ,
usuario, senha );
} catch ( ClassNotFoundException cnfe ) {
throw new ClassNotFoundException( cnfe.getMessage() );
} catch ( SQLException sqle ) {
throw new SQLException( sqle.getMessage() );
}
return con.createStatement();
}

Java - 136
Aplicação gráfica para execução de comandos SQL
Programa(s) Demonstração jdbc.ISQL

Java - 137
package jdbc;

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.awt.event.*;

import java.util.Vector;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Types;

public class ISQL extends JFrame {

public final static String INTERBASE_DRV = "interbase.interclient.Driver";
public final static String SQLSERVER_DRV =
"com.microsoft.jdbc.sqlserver.SQLServerDriver";
public final static String ORACLE_DRV = "oracle.jdbc.driver.OracleDriver";

/* URLs para o Interbase, SqlServer e Oracle*/

public final static String INTERBASE_URL =
"jdbc:interbase://localhost/D:/temp/BD.GDB";
public final static String SQLSERVER_URL =
"jdbc:microsoft:sqlserver://localhost:1433";
public final static String ORACLE_URL =
"jdbc:oracle:thin:@localhost:1521:ORCL";

/* Usuário e senha para conexão */

public final static String USUARIO = "ListaDiscussao";
public final static String SENHA = "ListaDiscussao";

JPanel jPanelApp = new JPanel();

JPanel jPanelConfig = new JPanel();
JPanel jPanelQuery = new JPanel();
JScrollPane jScrollPaneQuery = new JScrollPane();
JTable jTableQuery = new JTable();
JLabel jLabel1 = new JLabel();
String[] drivers = {ORACLE_DRV,
INTERBASE_DRV,
SQLSERVER_DRV};
JComboBox jComboBoxDriver = new JComboBox(drivers);
JLabel jLabel2 = new JLabel();
JTextField jTextFieldURL = new JTextField();
JLabel jLabel3 = new JLabel();
JLabel jLabel4 = new JLabel();
JTextField jTextFieldUsuario = new JTextField();
JTextField jTextFieldSenha = new JTextField();
JTextArea jTextAreaQuery = new JTextArea();
JButton jButtonExecutar = new JButton();
JButton jButtonLimpar = new JButton();
JButton jButtonSair = new JButton();
JRadioButton jRadioButtonQuery = new JRadioButton();
JRadioButton jRadioButtonUpdate = new JRadioButton();
ButtonGroup buttonGroup1 = new ButtonGroup();
JTable jTableResultado = new JTable();
BorderLayout borderLayout1 = new BorderLayout();

public ISQL() {
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}

Java - 138
public static void main(String[] args) {
ISQL isql = new ISQL();
isql.setSize(530,450);
isql.show();
}

private void jbInit() throws Exception {

jPanelApp.setLayout(null);
jPanelConfig.setBorder(BorderFactory.createEtchedBorder());
jPanelConfig.setBounds(new Rectangle(5, 5, 518, 145));
jPanelConfig.setLayout(null);
jPanelApp.setBorder(BorderFactory.createLineBorder(Color.black));
jPanelQuery.setBorder(BorderFactory.createEtchedBorder());
jPanelQuery.setBounds(new Rectangle(7, 154, 515, 264));
jPanelQuery.setLayout(borderLayout1);
jScrollPaneQuery.setAutoscrolls(true);
jLabel1.setText("Driver");
jLabel1.setBounds(new Rectangle(4, 5, 41, 17));
jComboBoxDriver.setBounds(new Rectangle(60, 5, 448, 20));
jComboBoxDriver.setSelectedIndex(1);
jComboBoxDriver.addItemListener(new java.awt.event.ItemListener() {
public void itemStateChanged(ItemEvent e) {
jComboBoxDriver_itemStateChanged(e);
}
});
String bd = "";
jTextFieldURL.setText(bd);
jLabel2.setText("URL");
jLabel2.setBounds(new Rectangle(6, 34, 30, 17));
jTextFieldURL.setBounds(new Rectangle(60, 36, 451, 19));
jLabel3.setText("Usuário");
jLabel3.setBounds(new Rectangle(8, 60, 55, 17));
jLabel4.setText("Senha");
jLabel4.setBounds(new Rectangle(8, 86, 41, 17));
jTextFieldUsuario.setBounds(new Rectangle(60, 59, 84, 21));
jTextFieldUsuario.setText("ListaDiscussao");
jTextFieldSenha.setBounds(new Rectangle(60, 83, 84, 21));
jTextFieldSenha.setText("ListaDiscussao");
jTextAreaQuery.setBorder(BorderFactory.createLineBorder(Color.black));
String qry = "SELECT * FROM TB_MEM_MEMBRO ORDER BY MEM_NM_MEMBRO";
jTextAreaQuery.setText( qry );
jTextAreaQuery.setBounds(new Rectangle(150, 56, 360, 54));
jButtonExecutar.setText("Executar");
jButtonExecutar.setBounds(new Rectangle(10, 111, 91, 27));
jButtonExecutar.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(MouseEvent e) {
jButtonExecutar_mouseClicked(e);
}
});
jButtonLimpar.setText("Limpar");
jButtonLimpar.setBounds(new Rectangle(108, 112, 94, 26));
jButtonLimpar.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(MouseEvent e) {
jButtonLimpar_mouseClicked(e);
}
});
jButtonSair.setText("Sair");
jButtonSair.setBounds(new Rectangle(210, 113, 74, 25));
jButtonSair.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
jButtonSair_actionPerformed(e);
}
});
jRadioButtonQuery.setText("Query");
jRadioButtonQuery.setSelected(true);
jRadioButtonQuery.setBounds(new Rectangle(290, 112, 59, 25));
jRadioButtonUpdate.setText("Update");
jRadioButtonUpdate.setBounds(new Rectangle(355, 113, 66, 25));
this.setDefaultCloseOperation(3);
this.setResizable(false);

Java - 139
 this.setTitle("SQL");
buttonGroup1.add(jRadioButtonQuery);
buttonGroup1.add(jRadioButtonUpdate);
this.getContentPane().add(jPanelApp, BorderLayout.CENTER);
jPanelApp.add(jPanelConfig, null);
jPanelConfig.add(jLabel1, null);
jPanelConfig.add(jLabel2, null);
jPanelConfig.add(jLabel3, null);
jPanelConfig.add(jLabel4, null);
jPanelConfig.add(jComboBoxDriver, null);
jPanelConfig.add(jTextFieldURL, null);
jPanelConfig.add(jTextFieldUsuario, null);
jPanelConfig.add(jTextFieldSenha, null);
jPanelConfig.add(jTextAreaQuery, null);
jPanelConfig.add(jButtonExecutar, null);
jPanelConfig.add(jButtonLimpar, null);
jPanelConfig.add(jButtonSair, null);
jPanelConfig.add(jRadioButtonQuery, null);
jPanelConfig.add(jRadioButtonUpdate, null);
jPanelApp.add(jPanelQuery, null);
jPanelQuery.add(jScrollPaneQuery, BorderLayout.CENTER);
}
void jButtonSair_actionPerformed(ActionEvent e) {
System.exit( 0 );
}

void jComboBoxDriver_itemStateChanged(ItemEvent e) {
if ( jComboBoxDriver.getSelectedIndex() == 0 ) {
jTextFieldURL.setText(ORACLE_URL);
} else if (jComboBoxDriver.getSelectedIndex() == 1 ) {
jTextFieldURL.setText(INTERBASE_URL);
} else {
jTextFieldURL.setText(SQLSERVER_URL);
}
}

void jButtonExecutar_mouseClicked(MouseEvent e) {
executarConsulta();
}

private void executarConsulta () {

try {
/* Carregando o driver de banco de dados */
Class.forName(jComboBoxDriver.getSelectedItem().toString());
/* Conectando ao banco de dados */
Connection connection
= DriverManager.getConnection(jTextFieldURL.getText(),
jTextFieldUsuario.getText(),
jTextFieldSenha.getText());
/* Obtendo objeto para execução de comandos sql */
Statement stmt = connection.createStatement();
if (jRadioButtonQuery.isSelected()) {
/* Executando comando sql */
ResultSet rs = stmt.executeQuery(jTextAreaQuery.getText());
/* Obtendo metadada do ResultSet : Colunas */
ResultSetMetaData rsmd = rs.getMetaData();
Vector colunas = colunas (rsmd);
/* Obtendo dados do ResultSet */
Vector linhas = new Vector();
while (rs.next()) {
linhas.addElement(linha(rs,rsmd));
}
/* Inserindo os dados no Objeto jTable */
jTableResultado = new JTable(linhas, colunas);
jScrollPaneQuery.getViewport().add(jTableResultado, null);
} else {
stmt.executeUpdate(jTextAreaQuery.getText());
}
connection.close();
} catch (ClassNotFoundException classEx) {

Java - 140
 String msg = "Erro ao carregar o driver";
JOptionPane.showMessageDialog(null, msg + "\n" +
classEx.getMessage(), "Erro",
JOptionPane.ERROR_MESSAGE);
} catch (SQLException sqlEx) {
String msg = "Erro na conexão ao banco de dados";
JOptionPane.showMessageDialog(null, msg + "\n" +
sqlEx.getMessage(), "Erro",
JOptionPane.ERROR_MESSAGE);
} catch (Exception ex) {
String msg = "Erro Geral" + ex.getMessage();
JOptionPane.showMessageDialog(null, msg + "\n" +
ex.getMessage(), "Erro",
JOptionPane.ERROR_MESSAGE);
}
}

private Vector colunas (ResultSetMetaData rsmd) {

Vector colunas = new Vector();
try {
for (int i = 1 ; i <= rsmd.getColumnCount(); i++ ) {
colunas.addElement(rsmd.getColumnName(i));
}
} catch (SQLException e) {}

return colunas;
}

private Vector linha (ResultSet rs, ResultSetMetaData rsmd)

throws SQLException {
Vector linha = new Vector();
/* Obtendo os valores dos campos e inserindo-os no Vector*/
for ( int i = 1 ; i <= rsmd.getColumnCount(); i++ ) {
/* Verificando no ResultSetMetaData o tipo do campo,
* para utilizar o método ResultSet.getXXXX(int) adequado
*/
switch ( rsmd.getColumnType(i) ) {
case Types.CHAR:
case Types.VARCHAR:
case Types.LONGVARCHAR:
linha.addElement( rs.getString(i) );
break;
case Types.DECIMAL:
case Types.NUMERIC:
linha.addElement( new Float( rs.getFloat(i) ) );
break;
case Types.BIT:
linha.addElement( new Boolean ( rs.getBoolean(i) ) );
break;
case Types.TINYINT:
case Types.SMALLINT:
case Types.INTEGER:
linha.addElement( new Long( rs.getLong(i) ) );
break;
case Types.FLOAT:
case Types.DOUBLE:
linha.addElement( new Double ( rs.getDouble(i) ) );
break;
case Types.DATE:
linha.addElement( rs.getDate(i) );
break;
case Types.TIME:
linha.addElement( rs.getTime(i) );
break;
default :
linha.addElement( " Tipo não Tratado" );
}
}
return linha;
}

Java - 141
 void jButtonLimpar_mouseClicked(MouseEvent e) {
jTextAreaQuery.setText("");
}
}

Java - 142
Bibliografia/
1. DEITEL. "Java - How To Program, Third Edition". Prentice Hall, 1999
2. MUGHAL. Khalid. "A Programmer´s Guide to JAVA Cetification." Addison-Wesley, 1999
3. CAPIONE, Mary. "The Java Tutorial Second Edition. Object-Oriented Programming for the
Internet". Sun Microsystem, 1998.
4. MUGHAL. Khalid. "A Programmer´s Guide to JAVA Cetification." Addison-Wesley, 1999
5. HAMILTON. Graham. "JDBC Database Access with Java". Sun Microsystem, 1997.
6. LEMAY, Laura. "Aprenda Java em 21 dias". Campus, 1999
7. HAEFEL. Richard Monson. "Enterprise JavaBeans". O´Reilly, 2000
8. "Professional Java Server Programming". WROX Press, 1999
9. LEA, Doug. "Concurrent Programming in Java. Design Principles and Patterns". Sun
Microsystem, 1998.

Fontes de Pesquisa
Links Descrição
http://www.javasoft.com/j2se/1.3/download-windows.html Download jdk1.3
http://www.borland.com/jbuilder/foundation/download/windows.html Download JBuilder 3.5 Foundation
http://web2.java.sun.com/docs/books/tutorial/ Tutorial java
http://www.dcc.ufrj.br/~schneide/MSI2_962/grupo4/g41.htm Glossário de orientação a objetos
http://java.sun.com/products/jdk/javadoc/index.html#javadoc1.3documents Tags JavaDoc
http://java.sun.com/docs/codeconv/index.html Code Conventions
http://www.unit.br/zemaria/MaterialDidatico.htm Programando com Qualidade, contendo
Code Conventions em português.
http://www.unit.br/zemaria/MaterialDidatico.htm Threads em Java

Java - 143
Exercícios

Exercício 1: Digitar, compilar e executar no JBuilder o application abaixo.

/**
* Demonstração de um Application Java
*/
/* Definição do pacote */
package introducao;
/* Importando a classe String */
import java.lang.String;
/* Definição da classe */
public class Aplicacao {
/* Método main */
public static void main(String[] args) {
/* Declarando e instanciando um objeto String */
String mensagem = "Application Java";
/* Escrevendo o objeto String na saída padrão */
System.out.print(mensagem);
}
}

Java - 144
Exercício 2: Resolva os problemas abaixo com applications Java
Problema 1: "Leia um valor inteiro representando o valor solicitado para saque num caixa
eletrônico, em seguida, sabendo que o caixa está alimentado com notas de 1, 5, 10, 50 e 100 reais,
calcule e escreva quantas notas de cada valor serão necessárias para atender a solicitação de
saque"

Problema 2: "Leia um salário, atualize e escreva-o de acordo com a tabela abaixo"

Faixa salarial Percentual de aumento
até 1.000,00 30%
acima de 1.000,00 e até 2.000,00 20%
acima de 2.000,00 10%

Problema 3: "Ler três valores float e imprimir se estes podem ou não formar os lados de um
triângulo e qual triangulo seria.
Observação: Para formar os lados de um triângulo cada um dos valores deve ser menor que a
soma dos outros dois. Um triangulo pode ser : eqüilátero (3 lados iguais), isósceles (apenas 2 lados
iguais) e escaleno (3 lados diferentes)"

Problema 4: "Leia o nome, as três notas e o número de faltas de um aluno e calcule e imprima sua
situação ("Aprovado", "Reprovado por Falta" ou "Reprovado por média").
Observação: A média para aprovação é 5,0 (cinco) e o limite de faltas é 18."

Problema 5: "Leia um conjunto de números inteiros, onde o flag será o valor 0 (zero) e em seguida
escreva a média dos números lidos e o maior valor lido"

Problema 6: "Leia (ou inicialize) um vetor com 10 elementos de números inteiros e em seguida leia
um conjunto de números inteiros e para cada número lido informe se o mesmo está ou não
presente no vetor.

Problema 7: "Leia (ou inicialize) uma matriz 5x5 de números inteiros e em seguida escreva cada
valor presente na matriz e quantas vezes o mesmo aparece na matriz"

Java - 145
Exercício 3: Relacione classes, atributos e métodos para os seguintes contextos :
Contexto 1: Carro
Contexto 2: Aquário
Contexto 3: Jogo de futebol
Contexto 4: Banco
Contexto 5: Farmácia
Contexto 6: Supermercado
Contexto 7: Hospital
Contexto 8: "Uma pequena loja deseja manter informações sobre clientes, produtos e pedidos de
produtos feitos pelos clientes, as informações necessárias para atender um pedido são : nome e
endereço do cliente que fez o pedido, relação das descrições e preços dos produtos solicitados e
data e endereço de entrega dos produtos."

Exercício 4:
Implemente uma classe em Java que forneça as seguintes funcionalidades :
1. Armazenar um conjunto de números inteiros (int)
2. Inicializar com um array de números inteiros
3. Instanciar definindo a quantidade máxima de números a serem armazenados
4. inserir um valor
5. Obter a quantidade de valores armazenados
6. Preencher todo o conjunto com um determinado valor a ser fornecido
7. Preencher todo o conjunto com números aleatórios, fornecendo o valor máximo para o
número aleatório
8. Obter o maior valor armazenado
9. Obter o menor valor armazenado
10. Obter a média dos valores armazenados
11. Inverter as posições dos números
12. Obter o número de uma determinada posição a ser fornecida
13. Imprimir todos os valores armazenados
Implemente também um application que demonstre o uso de todos os métodos da classe.

Java - 146
Exercício 5: Implemente uma hierarquia de classes e uma aplicação, que demonstre o seu uso,
para atender as requisições abaixo.
1. Armazenar informações sobre veículos: chassi, placa, marca, modelo, revendedor,
endereço do revendedor e telefone do revendedor. Caso seja um veículo de passeio: a
velocidade máxima e quantidade de passageiros. Caso seja um veículo de carga: a carga
máxima. Observação : O cadastro será de no máximo 10 veículos.
2. Armazenar informações sobre motoristas: Matrícula, nome, correção visual, validade da
habilitação e tipo (A, B ou C). Observação : o cadastro será de no máximo 10 motoristas
3. Registrar movimentações para os veículos, onde em cada movimentação será necessário
registrar: o motorista, a kilometragem inicial e final e a data. Observação : apenas as 5
últimas movimentações devem ser armazenadas.
4. Registrar manutenções realizadas nos veículos, onde para manutenção deverá ser
registrado: uma descrição da manutenção e a data. Observação : apenas as 5 últimas
manutenções devem ser armazenadas.
5. Listar para todos os veículos as últimas movimentações
6. Listar para todos os veículos as últimas manutenções

Java - 147
Exercício 6:
Faça uma aplicação Java utilizando componentes Swing para modelar um aluno com as seguintes
informações : matricula, nome, endereco e telefones. Sendo que, a aplicação deverá permitir o
cadastro e consulta de alunos na tabela "Alunos" do banco de dados
"jdbc:interbase://140.100.0.20/c:/InfoNet//HouseTech.gdb", utilizando o driver
"interbase.interclient.Driver" e usuário "SYSDBA" e senha "masterkey".
Observações:
 A classe Aluno deverá possuir os seguintes métodos para operações de banco de dados :
public void insertInto (String driver, String url, String usuario, String senha)
public void updateFrom (String driver, String url, String usuario, String senha)
public static Aluno selectFrom (String matricula, String driver, String url, String usuario, String senha)
public static void deleteFrom (String matricula, String driver, String url, String usuario, String senha)
 O comando sql para inserir numa tabela é "insert into Alunos values ('00000','José Maria R S
Junior', 'Av. Adélia Franco, 2850. Bloco I, apt. 101', '217-7883/9133-8410')"
 O comando sql para consultar numa tabela é "select * from Alunos where matricula =
'00001'"
 O comando sql para apagar um registro é : "delete from Alunos where matricula = '00000'"
 O comando sql para alterar um registro é : "update Alunos set nome = 'Novo Nome',
endereco = 'Novo Endereco', telefones = 'Novo telefone' where matricula = '00000'
 O Comando de criação da tabela foi o seguinte:
create table Alunos (
matricula char(05) not null primary key,
nome char(50) not null,
endereco char(60),
telefones char(30)
)

Exercício n:

Java - 148