Apostila de Java da NeoGrid

APOSTILA DE JAVA
2
Java ................................................................................................................................ 7
Características da Linguagem .................................................................................... 7
Máquina Virtual Java ................................................................................................. 8
O Ambiente de Execução Java .................................................................................. 9
Carregador de Classes ................................................................................................ 9
Verificador de ByteCode ........................................................................................... 9
Processos do Verificador ........................................................................................... 9
Aplicação Básica Java.............................................................................................. 10
Descrevendo AloMundo .......................................................................................... 10
Introdução a Classes e Pacotes ................................................................................ 11
Usando a Documentação API do Java ..................................................................... 12
Exercício JAVA1 ..................................................................................................... 12
Identificadores, Palavras Chaves e Tipos .................................................................... 12
Ponto-e-vírgulas, Blocos .......................................................................................... 12
Identificadores.......................................................................................................... 13
Palavras-Chave do Java ........................................................................................... 13
Tipos Básicos do Java .............................................................................................. 13
Lógico – boolean...................................................................................................... 13
Texto – char e String ................................................................................................ 13
Inteiros – byte, short, int, and log ............................................................................ 13
Ponto Flutuante – float e double .............................................................................. 14
Variáveis, Declarações, e Instruções ....................................................................... 14
Convenções do Código Java .................................................................................... 14
Expressões e Controle de Fluxo................................................................................... 15
Variáveis .................................................................................................................. 15
Inicializando Variáveis ............................................................................................ 16
Operadores ............................................................................................................... 16
Expressões Lógicas .................................................................................................. 17
Concatenando Strings com + ................................................................................... 17
Casting ..................................................................................................................... 17
Casting de Expressões.............................................................................................. 18
Instruções ................................................................................................................. 18
Instrução if, else ....................................................................................................... 18
Instrução switch ....................................................................................................... 19
Instruções de Loop ................................................................................................... 20
Instrução for ............................................................................................................. 20
Instrução while ......................................................................................................... 20
Instrução do .............................................................................................................. 21
Controles Especiais de Fluxo ................................................................................... 21
Instrução break ......................................................................................................... 21
Instrução continue .................................................................................................... 21
Exercício JAVA2 ..................................................................................................... 22
Exercício JAVA3 ..................................................................................................... 22
Exercício JAVA4 ..................................................................................................... 22
Exercício JAVA5 ..................................................................................................... 22
Exercício JAVA6 ..................................................................................................... 22
Classe e objeto ............................................................................................................. 23
Criando uma classe .................................................................................................. 23
Criando um objeto.................................................................................................... 23
Criando um objeto – Alocação de Memória ............................................................ 24
Tipos de Referência ................................................................................................. 24
3
Exercício JAVA7 ..................................................................................................... 25
Arrays ........................................................................................................................... 25
Declarando Arrays ................................................................................................... 26
Criando Arrays ......................................................................................................... 26
Inicializando Arrays ................................................................................................. 26
Tamanho de um Array ............................................................................................. 27
Redimensionando um Array .................................................................................... 27
Copiando Arrays ...................................................................................................... 28
Ordenando Arrays .................................................................................................... 28
Exercício JAVA8 ..................................................................................................... 28
Exercício JAVA9 ..................................................................................................... 28
Classes e Objetos ......................................................................................................... 29
Princípios dos Objetos ............................................................................................. 29
Classes e Objetos ..................................................................................................... 29
Definindo Métodos .................................................................................................. 31
Passagem por valor .................................................................................................. 32
A Referência this...................................................................................................... 32
Ocultando Dados ...................................................................................................... 33
Encapsulamento ....................................................................................................... 33
Sobrecarregando Métodos ....................................................................................... 34
Exercício JAVA10 .................................................................................................. 34
Exercício JAVA11 .................................................................................................. 34
Exercício JAVA12 .................................................................................................. 35
Construindo e Inicializando Objetos ............................................................................ 35
Construtores ............................................................................................................. 35
Pacotes ..................................................................................................................... 36
A Instrução import ................................................................................................... 36
Diretório de Pacotes ................................................................................................. 37
Exercício JAVA13 ................................................................................................... 37
Exercício JAVA14 ................................................................................................... 37
Exercício JAVA15 ................................................................................................... 37
Herança ........................................................................................................................ 37
O que é Herança? ..................................................................................................... 37
A palavra chave Extends .......................................................................................... 38
Herança Simples ...................................................................................................... 38
Construtores não são Herdados ................................................................................ 39
Polimorfismo............................................................................................................ 39
Coleções Heterogêneas ............................................................................................ 39
Polimorfismo de Argumentos .................................................................................. 40
O Operador instanceof ............................................................................................. 40
Convertendo Objetos ............................................................................................... 40
Sobrescrevendo Métodos ......................................................................................... 41
Regras sobre Métodos Sobrescritos ......................................................................... 42
A Palavra Chave super ............................................................................................. 42
Invocando Construtores da classe Pai ...................................................................... 43
Exercício JAVA16 ................................................................................................... 43
Exercício JAVA17 ................................................................................................... 44
Características da Linguagem ...................................................................................... 44
Variáveis do tipo Static ............................................................................................ 44
Métodos do tipo Static ............................................................................................. 45
Inicializadores do tipo Static.................................................................................... 45
Exercício JAVA18 ................................................................................................... 46
4
Exercício JAVA19 ................................................................................................... 46
Dados e Métodos Orientados a Objetos ....................................................................... 46
Palavra chave final ................................................................................................... 47
Classes final ............................................................................................................. 47
Métodos final ........................................................................................................... 47
Variáveis final .......................................................................................................... 47
Classes Abstratas ..................................................................................................... 47
Exercício JAVA20 ................................................................................................... 48
Interfaces ...................................................................................................................... 48
Exercício JAVA21 ................................................................................................... 49
Exercício JAVA22 ................................................................................................... 49
Controle de Acesso ...................................................................................................... 49
Operador = = versus Método equals( ) .................................................................... 50
Método toString( ).................................................................................................... 51
Classes Internas ........................................................................................................ 51
Classes Wrapper....................................................................................................... 52
Exercício JAVA23 ................................................................................................... 53
Exceções ...................................................................................................................... 53
Instruções try e catch ............................................................................................... 54
Instrução finally ....................................................................................................... 54
Instrução throw ........................................................................................................ 55
Cláusula throws........................................................................................................ 55
Categorias de Exceção ............................................................................................. 55
Tratando ou Declarando Exceções........................................................................... 56
Criando Suas Próprias Exceções .............................................................................. 56
Exercício JAVA24 ................................................................................................... 57
Exercício JAVA25 ................................................................................................... 57
Datas e Calendário ....................................................................................................... 57
Criando Datas e Calendários .................................................................................... 57
Formatando Datas .................................................................................................... 57
Calculando Datas ..................................................................................................... 58
Exercício JAVA26 ................................................................................................... 58
Coleções ....................................................................................................................... 59
Principais classes e interfaces .................................................................................. 59
Ordered e Sorted ...................................................................................................... 60
List ........................................................................................................................... 61
ArrayList .................................................................................................................. 61
Vector ....................................................................................................................... 61
LinkedList ................................................................................................................ 61
Set ............................................................................................................................ 61
HashSet .................................................................................................................... 61
LinkedHashSet ......................................................................................................... 61
TreeSet ..................................................................................................................... 62
Map .......................................................................................................................... 62
HashMap .................................................................................................................. 62
Hashtable.................................................................................................................. 62
LinkedHashMap ....................................................................................................... 62
TreeMap ................................................................................................................... 62
Exercício JAVA27 ................................................................................................... 62
Exercício JAVA28 ................................................................................................... 62
Componentes Gráficos ................................................................................................. 63
AWT ........................................................................................................................ 63
5
Swing ....................................................................................................................... 63
Containers ................................................................................................................ 63
Frames ...................................................................................................................... 63
Panels ....................................................................................................................... 63
Gerenciadores de Layout ......................................................................................... 64
FlowLayout .............................................................................................................. 64
BorderLayout ........................................................................................................... 65
GridLayout ............................................................................................................... 66
CardLayout .............................................................................................................. 67
Classe JComponent .................................................................................................. 68
JLabel ....................................................................................................................... 68
JTextField ................................................................................................................ 69
JButton ..................................................................................................................... 69
JCheckBox ............................................................................................................... 70
JRadioButton............................................................................................................ 70
JMenuBar ................................................................................................................. 71
JMenu....................................................................................................................... 71
JMenuItem ............................................................................................................... 71
JComboBox.............................................................................................................. 72
JList .......................................................................................................................... 72
JTable ....................................................................................................................... 72
JTree......................................................................................................................... 73
Exercício JAVA29 ................................................................................................... 73
Exercício JAVA30 ................................................................................................... 73
Exercício JAVA31 ................................................................................................... 74
Eventos ......................................................................................................................... 74
O que é um Evento? ................................................................................................. 74
Fontes de evento ...................................................................................................... 74
Manipuladores de evento ......................................................................................... 74
Modelo de Delegação .............................................................................................. 74
Comportamento de GUI ........................................................................................... 75
Categorias de Eventos .............................................................................................. 75
Múltiplos listeners .................................................................................................... 77
Adaptadores de Eventos ........................................................................................... 78
Classes anônimas ..................................................................................................... 78
Exercício JAVA32 ................................................................................................... 79
Exercício JAVA33 ................................................................................................... 79
Exercício JAVA34 ................................................................................................... 79
Applets ......................................................................................................................... 79
O que é um Applet? ................................................................................................. 79
Carregando um Applet ............................................................................................. 79
Restrições de Segurança em Applet ......................................................................... 80
Os Métodos de um Applet ....................................................................................... 80
Mostrando um Applet .............................................................................................. 80
O Método init( ) ....................................................................................................... 81
O Método start( ) ...................................................................................................... 81
O Método stop( ) ...................................................................................................... 81
O Método paint( )..................................................................................................... 81
O Método repaint( ) ................................................................................................. 82
O Método update(Graphics g) ................................................................................. 82
Applet Tag ............................................................................................................... 82
Características Adicionais de Applet ....................................................................... 83
6
Lendo Parâmetros .................................................................................................... 83
Applet/Application ................................................................................................... 84
Exercício JAVA35 ................................................................................................... 84
Threads ......................................................................................................................... 85
Criando uma Thread ................................................................................................ 85
Iniciando uma Thread .............................................................................................. 86
Escalonamento de Threads ...................................................................................... 86
Finalizando uma Thread .......................................................................................... 87
Exercício JAVA36 ................................................................................................... 87
Stream I/O e Arquivos ................................................................................................. 87
Stream I/O ................................................................................................................ 87
Entrada de Dados ..................................................................................................... 88
Métodos Básicos de uma SubClasse de InputStream .............................................. 88
Saída de Dados ......................................................................................................... 88
Métodos Básicos de uma SubClasse de OutputStream ........................................... 88
Classes Streams Úteis .............................................................................................. 89
FileInputStream e FileOutputStream ....................................................................... 89
BufferedInputStream e BufferedOutputStream ....................................................... 89
DataInputStream e DataOutputStream .................................................................... 89
Métodos DataInputStream ....................................................................................... 89
Métodos DataOutputStream..................................................................................... 89
PipedInputStream e PipedOutputStream ................................................................. 90
URL Input Streams .................................................................................................. 90
Abrindo um Input Stream ........................................................................................ 90
Readers ..................................................................................................................... 90
Writers...................................................................................................................... 91
Código de Página ..................................................................................................... 91
Files .......................................................................................................................... 92
Criando um novo arquivo/pasta ............................................................................... 92
Funções de Arquivos................................................................................................ 92
Acessando Arquivos Randomicos ........................................................................... 93
Gravando um objeto ................................................................................................. 93
Lendo um objeto ...................................................................................................... 94
Exercício JAVA37 ................................................................................................... 94
Exercício JAVA38 ................................................................................................... 94
Exercício JAVA39 ................................................................................................... 94
Networking .................................................................................................................. 94
Sockets ..................................................................................................................... 94
Estabelecendo a Conexão ........................................................................................ 95
Enviando a Conexão ................................................................................................ 95
Portas TCP/IP........................................................................................................... 95
Servidor de TCP/IP .................................................................................................. 95
Cliente de TCP/IP .................................................................................................... 96
Exercício JAVA40 ................................................................................................... 96
JDBC "Driver" ............................................................................................................. 96
Pacote java.sql.......................................................................................................... 97
Interfaces do JDBC .................................................................................................. 97
Registrando um driver JDBC ................................................................................... 97
Criando uma conexão .............................................................................................. 98
Criando uma instrução SQL..................................................................................... 98
Recebendo dados do banco ...................................................................................... 98
Enviando dados ao banco......................................................................................... 99
7
Datas para SQL ........................................................................................................ 99
Tabela de métodos setXXX ................................................................................... 100
Tabela de métodos getXXX ................................................................................... 100
Exercício JAVA41 ................................................................................................. 100
Java
A plataforma Java é composta de : uma linguagem de programação, um
ambiente de desenvolvimento e um ambiente de aplicação.
A linguagem Java permite criar applets para a World Wide Web e aplicações.
Applet é o termo usado para uma miniaplicação que é executada dentro de uma
página html. Aplicações são programas que não exigem um navegador para executar.
São programas que rodam em qualquer máquina onde o ambiente runtime do Java
está instalado.
Características da Linguagem
Parecida com C, C++
Java tem aparência de C ou de C++, embora a filosofia da linguagem seja diferente.
Java também possui características herdadas de muitas outras linguagens de
programação.
Compilada
Um programa em Java é compilado para o chamado "byte-code", que é próximo as
instruções de máquina, mas não de uma máquina real. O "byte-code" é um código de
uma máquina virtual idealizada pelos criadores da linguagem.
Portável
O "byte-code" gerado pelo compilador para a sua aplicação específica pode ser
transportado entre plataformas distintas que suportam Java. Não é necessário
recompilar um programa para que ele rode numa máquina e sistema diferente, ao
8
contrário do que acontece por exemplo, com programas escritos em C e outras
linguagens.
Orientada a Objetos
Java suporta herança, mas não herança múltipla. A ausência de herança múltipla pode
ser compensada pelo uso de herança e interfaces, onde uma classe herda o
comportamento de sua superclasse além de oferecer uma implementação para uma ou
mais interfaces. Java permite a criação de classes abstratas.
Segurança
A presença de coleta automática de lixo evita erros comuns que os programadores
cometem quando são obrigados a gerenciar diretamente a memória. A eliminação de
ponteiros, em favor do uso de vetores, objetos e outras estruturas traz benefícios em
termos de segurança. A presença de mecanismos de tratamento de exceções torna as
aplicações mais robustas, não permitindo que elas abortem, mesmo quando rodando
sob condições anormais.
Suporta Concorrência
A linguagem permite a criação de maneira fácil, de várias "threads" de execução.
Suporte Programação de Sistemas Distribuídos
Java fornece facilidades para programação com sockets, remote method call, TCP-IP,
etc.
Máquina Virtual Java
Java Virtual Machine é o elemento mais importante da arquitetura do Java. Somente
dentro dele os códigos de Java podem ser executados.
Uma máquina imaginária que é implementada emulando isto em software na
máquina. Códigos para a Máquina Virtual Java é armazenada em arquivos .class
cada qual contêm código para no máximo uma classe pública.
A Especificação da Máquina Virtual Java fornece as especificações de plataforma de
hardware para a qual todo o código Java é compilado. Esta especificação permite ao
Java ser uma plataforma independente, porque a compilação é feita para uma máquina
virtual conhecida como Máquina Virtual Java. (JVM).
Bytecodes são instruções de código de máquina para o JVM. Todo interpretador Java,
tanto uma ferramenta de desenvolvimento ou um navegador possuem implementação
da JVM.
A especificação de JVM provê definições concretas para o implementação do
seguinte:
 Conjunto de instruções (equivale ao de uma CPU)
 Conjunto de registradores
 Formato do código dos bytecodes da classe
 Pilha
 Gerenciamento Automático de memória.

9
Área de memória
O Ambiente de Execução Java
Na execução de um código compilado, a JVM executa três tarefas principais:
Carregar o código – executado pelo carregador de classe
Verificar o código – executado pelo verificador de bytecode
Executar o código–executado por interpretador Java
Carregador de Classes
O carregador de classe carrega todas as classes necessárias para a execução de um
programa sejam elas locais ou da rede. As classes locais sempre serão carregadas
primeiro. Uma vez que todas as classes estiveram carregadas, o código é executado.
Não é permitido acessar endereços de memória sem autorização nas áreas fora da
JVM.
Verificador de ByteCode
O código Java passa em vários testes antes de ser executado em sua máquina. O JVM
põe o código em um verificador de bytecode que testa o formato dos bytecodes e
checa para não permitir violamento de ponteiros, privilégios de acesso em objetos, ou
tentar mudar o tipo do objeto.
Processos do Verificador
10
O verificador de bytecode faz quatro processos de verificação no código de um
programa. Assegura que o código adere às especificações de JVM e não viola
integridade do sistema operacional. Se o verificador completar todos os processos sem
erro, então o seguinte é assegurado:





As classes aderem ao formato de classe da especificação de JVM.
Não há nenhuma violação de acesso a recursos restritos.
O código não causa nenhum estouro de pilha.
São conhecidos os tipos de parâmetros.
Não ocorre nenhuma conversão ilegal de dados.
Aplicação Básica Java
Como qualquer outra linguagem de programação, a linguagem Java é usada para criar
aplicações. Esta aplicação simples exibe o texto Alo Mundo! na tela.
1 // Exemplo de comentario
2 public class AloMundo {
3
public static void main (String args[ ]) {
4
System.out.println("Alo Mundo!");
5
}
6 }
Estas linhas são os componentes mínimos necessários para imprimir Alo Mundo! na
sua tela.
Descrevendo AloMundo
A linha 1 é uma linha de comentário .
1 // Exemplo de comentario
A linha 2 declara a classe AloMundo. O nome de classe especificado cria um arquivo
chamado AloMundo.class no mesmo diretório do código fonte AloMundo.java. O
arquivo AloMundo.class contém o código compilado para a classe pública
AloMundo.
public class AloMundo
A linha 3 é onde começa a execução do programa. Outras linguagens de programação,
como C e C++, também usam a declaração main ( ) como o ponto de partida para
execução. Se o programa receber qualquer argumento em sua linha de comando, estes
são passados no parâmetro args do método main ( ). Neste exemplo, nenhum
argumento é usado.
public static void main (String args)
Esta linha específica o seguinte:
public – é um qualificador do método que indica que este é acessível externamente a
esta classe.
static – é outro qualificador que indica que o método deve ser compartilhado por
todos os objetos que são criados a partir desta classe.
void – é o valor de retorno vazio do método. Quando um método não retorna nenhum
valor, tem que ser especificado com void.
11
String args [ ] – é um vetor de strings que é formado quando são passados ou não
argumentos através da linha de comando.
A linha 4 ilustra a chamada do método println para o atributo out da classe ou objeto
System.
System.out.println ("Alo Mundo!");
Linhas 5-6 fecham o método main ( ) e a classe AloMundo, respectivamente.
Compilando e Executando AloMundo
Compilando
Após ter criado o arquivo AloMundo.java, compile o arquivo digitando a seguinte
instrução
javac AloMundo.java
Se o compilador não retornar nenhuma mensagem, o arquivo AloMundo.class é
criado no mesmo diretório do código fonte.
Executando
Para executar a aplicação AloMundo, utilize o interpretador java, localizado no
diretório bin.
java AloMundo
AloMundo!
Introdução a Classes e Pacotes
Uma classe é um termo genérico para um módulo que possui funcionalidade. O Java
vem com diversas classes padrões, que implementam a maioria dos comportamentos,
como por exemplo, classes para prover funções de matemática básica, strings,
gráficos e networking. Um pacote é um grupo de classes relacionadas.
A biblioteca de classe é organizada em muitos pacotes, cada qual contém várias
classes. Os pacotes seguintes são proeminentes:
java.lang contém classes para String, Math, Integer, e Thread.
java.awt contém classes para Abstract Window Toolkit (AWT).
java.applet contém classes para applets.
java.net contém classes para implementação de processos de Networking.
java.io contém classes de tratamento de I/O.
java.util contém classes de tarefas utéis, como geração de número aleatório e funções
de data e calendário.
12
Usando a Documentação API do Java
É uma coleção de arquivos HTML que documentam as classes e métodos da
linguagem Java. A documentação é hierárquica, de forma que a página inicial lista
todos os pacotes como hyperlinks. Se o link de um pacote é selecionado, são listadas
as classes associadas daquele pacote. Selecionando um link da classe, e apresentado
uma página de informação sobre aquela classe. As seções principais de um
documento de classe são as seguintes:








a hierarquia da classe
uma descrição da classe e seu propósito geral
uma lista de variáveis associadas
uma lista de construtores
uma lista de métodos
uma lista detalhada de variáveis, com descrições do propósito e uso de cada
variável
uma lista detalhada de construtores, com descrições
uma lista detalhada de métodos, com descrições
Exercício JAVA1
Compile e execute a classe AloMundo descrita neste capítulo. Use o bloco de notas
para criar o arquivo AloMundo.java. Use os comandos javac e java que se encontram
no diretório <JAVA_HOME>/bin.
Identificadores, Palavras Chaves e Tipos
Ponto-e-vírgulas, Blocos
Na linguagem de programação, uma declaração é uma única linha de código
terminada com um ponto-e-vírgula (;). Por exemplo:
totals = a + b + c;
Um bloco ou uma combinação de declarações é inicializado e finalizado por { }. Essa
sintaxe também é usada para se agrupar declarações que pertencem a uma classe.
Exemplos de declarações de blocos ou agrupamentos:
/ / declarando um bloco
{
x = y + 1;
y = x + 1;
}
// um bloco é usado na definição da classe
public class MinhaData {
int dia;
int mes;
int ano;
}
13
Identificadores
Os identificadores Java, utilizados para nomes de entidades declaradas, devem iniciar
com uma letra, podendo ser incluido um caractere de sublinhado ( _ ) ou um cifrão ( $
), seguidos de letras ou dígitos ou ambos. Quaisquer diferenças nos caracteres, como
acentuação, em um identificador, tornam o identificador único. Letras maiúsculas ou
minúsculas são significativas, pois são considerados identificadores diferentes.
Palavras-Chave do Java
abstract
boolean
break
byte
base
catch
char
class
continue
default
do
double
else
extends
false
final
finally
float
for
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
void
volatile
while
As palavras-chave na linguagem Java não podem ser utilizadas como identificadores.
Embora pareçam palavras-chave, null, true e false são literais. Contudo, você não
pode utilizar essas palavras como identificadores, embora elas possam ser utilizadas
como parte do identificador.
Tipos Básicos do Java
Lógico – boolean
Os literais booleanos são true e false.
boolean verdade = true;
Nota– Não é permitido em Java interpretar valores numéricos como valores lógicos.
Quando um boolean é requerido, só poderão ser utilizados valores do tipo boolean.
Texto – char e String
Os caracteres aparecem entre aspas simples (‘x’). Um caracter é uma única letra,
número, sinal de pontuação ou outro símbolo.
char letra = 'a';
As strings aparecem entre aspas duplas ("oi"). Uma string é um grupo de caracteres.
String texto = "Este é um texto";
Inteiros – byte, short, int, and log
14
Há quatro tipos inteiros na linguagem de programação de Java. Cada tipo é
declarado usando uma palavra chave como byte, short, int e long. Você pode
representar literais de tipo inteiro que usam a forma decimal, octal, ou hexadecimal
como segue:
2 – dois é um valor decimal
077 – o 0 indica um valor octal
0xBAAC – o 0x indica um valor hexadecimal
As literais acima são do tipo int, a menos que explicitamente seguido pela letra "L." O
L indica um valor longo. Em Java, você pode usar L maiúscula ou minúscula, mas
deve-se evitar l minúsculo, pois pode ser confundida com o número 1.
2L - o L indica que o valor decimal dois é representado como um longo
077L – o zero indica um valor octal
0xBAACL - o 0x indicaum valor hexadecimal
Ponto Flutuante – float e double
Números de ponto flutuante são expressões como números decimais, com um
separador decimal opcional, eventualmente seguido por um expoente. O número deve
ser seguido por f ou F para ser uma constante de precisão simples, ou d ou D para
uma constante de precisão dupla. Todas as constantes de ponto flutuante, a menos que
sejam especificadas com f ou F, são do tipo double.
3.14 - um valor de ponto flutuante (um double)
6.02E23 - um valor float com expoente
2.718F - um valor float
123.4E+306D - um valor double com D redundante
Variáveis, Declarações, e Instruções
O código de exemplo ilustra como declarar e nomear valores do tipo int, float,
boolean, double, char e string:
int x,y;
float z = 3.414f;
double w = 3.1415;
boolean truth = true;
char c;
String str;
String str1 = "olá";
c = 'A';
str = "Oi pessoal!";
x = 6;
y = 1000;
Convenções do Código Java
A seguinte convenção é utilizada na linguagem Java:
15
Classes – o nome da classe deve ter a inicial maiúscula e as demais minúsculas.
Quando você utiliza dois nomes, as iniciais devem ser maiúsculas.
class ContaBancaria
class Curso
Interfaces – o nome da interface deve ter a inicial maiúscula.
interface Conta
Métodos – os nomes do métodos devem iniciar com minúsculas e a próxima palavra
dever ter sua inicial maiúscula.
saque( )
adicioneCurso( )
Variáveis – todas as variáveis deveriam ter o primeiro nome em minúsculo. Palavras
são separadas através de letras maiúsculas. Limite o uso de sublinhado, e evite usar o
dólar sinal ($) porque este caráter tem significado especial a classes internas.
clienteAtual
Constantes – constantes primitivas deveriam ser todas em maiúsculas com as palavras
separadas por sublinhado.
DIA_SEMANA
VELOCIDADE_MAXIMA
Estruturas de Controle – use ({ }) ao redor de todas as declarações, até mesmo de
declarações únicas.
if (x != 0) {
y = 100 / x;
} else {
y = 100;
}
Espaçamento – coloque só uma única declaração em qualquer linha, e use dois ou
quatro espaços de identação para tornar seu código legível.
Comentários – use comentários para explicar segmentos de código que não são
óbvios. Use o // como delimitador de comentário para uma única linha. Você pode
comentar seções grandes de código usando / *... * /.
Expressões e Controle de Fluxo
Variáveis
Há dois tipos de variáveis: variáveis de tipo primitivo ou variáveis de referência. Você
pode declarar variáveis em dois lugares: dentro de um método (método é um termo
sinônimo de função, como main ( )) ou fora de um método, mas dentro da definição
de classe.
As variáveis definidas dentro de um método são chamadas de variáveis locais. As
variáveis definidas no escopo da classe podem ser acessadas por todos os métodos da
classe.
class ClasseExemplo {
16
// variável da classe
int i;
public int metodoUm( ) {
// variável local
int j = 0;
// i e j são acessíveis aqui
return 1;
} // fim do metodoUm
public int metodoDois( ) {
// variável local j é diferente do metodoUm( ).
int j = 0;
// este j é limitado ao corpo de metodoDois().
// a variável i (variável da classe)
// e j (variável local deste método) são
// acessíveis aqui
return j;
} // fim de metodoUm
} //fim de classe
Inicializando Variáveis
Nenhuma variável em um programa Java pode ser usada antes de ser inicializada.
Quando um objeto é criado, as variáveis são inicializadas com os seguintes valores:
Byte
Short
Int
Long
Float
Double
Char
boolean
All reference types
0
0
0
0L
0.0F
0.0D
‘\u0000’ (NULL)
false
null
As variáveis locais devem ser iniciliazadas manualmente. O compilador sinaliza um
erro se encontrar uma condição onde uma variável será utilizada antes de ser
inicializada.
public void calcula ( ) {
int x = (int)(Math.random( ) * 100);
int y;
int z;
if (x > 50) {
y = 9;
}
z = y + x; // uso ilegal antes de inicializar y
}
Operadores
pós-fixados
Unários
Multiplicativos
Aditivos
. [ ] ( ) ; ,
++ -- + - ~ !
* / %
+ -
(data type)
17
deslocamentos
relacionais
igualdade
AND(E) bit a bit
XOR(ou exclusivo)
OR (ou inclusivo)
AND(E) lógico
OR(OU) lógico
condicional
atribuição
<< >> >>>
< > <= >= instanceof
== !=
&
^
|
&&
||
?:
= *= /= %= += -= <<=
&= ^= |=
>>=
>>>=
Expressões Lógicas
Operadores lógicos e relacionais sempre devolvem um valor boolean. A linguagem
Java não converte automaticamente estes valores para um int.
int i = 1;
if (i) i++; // gera um erro de compilação
if (i!=0) i--; // correto
Concatenando Strings com +
O operador + executa uma concatenação de objetos de Strings, gerando uma nova
String.
String saudacao = "Dr. ";
String nome = "Pedro " + "Silva";
String titulo = saudacao + nome;
O resultado é:
Dr. Pedro Silva
Você também pode utilizar o operador + para concatenar uma String com a
representação da String de qualquer tipo primitivo ou de um objeto.
public static String texto(String fala) {
return '<' + fala + '>'; // char mais uma String
}
Casting
Quando um tipo não pode ser atribuído a um outro por conversão implícita, ele poderá
ser, em geral, ter sua conversão forçada explicitamente a um outro tipo.. Se os dois
tipos forem compatíveis, o Java executa a conversão automaticamente. Um valor de
int sempre pode ser nomeado a uma variável long.
Onde seriam perdidas informações, o compilador requer que você confirme a tarefa
com um typecast. Por exemplo, isto pode ser feito "espremendo" um valor long em
uma variável int.
18
long valorGrande = 99L;
int reduzido = (int)valorGrande; //pode haver perda de precisão
O tipo desejado é colocado em parênteses e usado como um prefixo para a expressão
que deve ser modificada. Embora não seja necessário, é aconselhável incluir a
expressão inteira a ser modificada em parênteses.
Casting de Expressões
Variáveis podem receber valores automaticamente se o seu tipo for menor que a nova
variável que irá receber o valor, e assim não perderia informação.
long bigval = 6; // 6 is an int type, OK
int smallval = 99L; // 99L is a long, illegal
double z = 12.414F; // 12.414 is float, OK
float z1 = 12.414; // 12.414 is double, illegal
Para o operador +, quando os dois operandos forem de tipos numéricos primitivos, o
resultado é um int.
Por exemplo:
short a, b, c;
a = 1;
b = 1;
c = a + b;
causa um erro porque cada tipo short passa a ser int na operação +. Altere c para int,
ou faça um typecast short:
c = (short)(a + b)
então o resultado estará certo.
Instruções
Declarações condicionais permitem a execução seletiva de partes do programa de
acordo com o valor de algumas expressões.
Instrução if, else
A sintaxe básica de if, else é:
if
( expressão ) {
instrução 1;
}
E if com else é:
if
( expressão ) {
instrução 1;
} else {
instrução 2;
}
Exemplo:
19
int contador;
String resp = JOptionPane.showInputDialog(
"Quantas pessoas vem?");
contador = Integer.parseInt(resp);
if ( contador < 0 ) {
System.out.println("Erro: o valor do contador eh negativo");
contador=0;
} else {
System.out.println( contador + " pessoas vem almoçar hoje");
}
O código JOptionPane.showInputDialog mostra uma caixa de diálogo para o
usuário digitar um valor String. Onde JOptionPane é uma classe e
showInputDialog é um método.
Instrução switch
A sintaxe da instrução switch é:
switch (expressão) {
case valor1:
instrução 1;
break;
case valor2:
instrução 2;
break;
default:
instrução 3;
break;
}
Nota – A expressão deve conter um valor do tipo int, byte, short, ou char. Não são
permitidos pontos flutuantes, expressões do tipo long e referências a classes.
A condição default é usada para especificar o segmento de código a ser executado
quando o valor da variável ou expressão não foi encontrado em nenhum dos valores
declarados. Se não houver nenhuma declaração de break, o programa irá executar
todas as condições abaixo do primeiro case que satisfizer a expressão sem testar
nenhum de seus valores, até encontrar uma declaração break.
Exemplo 1:
int colorNum=0;
switch (colorNum) {
case 0:
setBackground(Color.red);
break;
case 1:
setBackground(Color.green);
break;
default:
setBackground(Color.black);
break;
}
No exemplo 1, se nenhum dos dois casos satisfazerem a condição, a cor é setada para
preto.
20
Exemplo 2:
int colorNum=0;
switch (colorNum) {
case 0:
setBackground(Color.red);
case 1:
setBackground(Color.green);
default:
setBackground(Color.black);
break;
}
No exemplo 2, mesmo que uma das duas condições sejam satisfeitas, o valor será
setado para preto, pois nenhuma das duas condições possui a instrução break. O Java
irá executar todas as condições, e a última sobrescreverá as demais.
Instruções de Loop
Instruções de loop permitem a execução repetida de blocos de instruções.
Instrução for
A sintaxe de for é:
for (int i=0; i < 10; i++) {
System.out.println("Voce jah estah pronta?");
}
System.out.println("Finalmente");
Nota – O java permite o utilizar a vírgula como separador dentro de estrutura for( ).
Por exemplo,
for (i = 0, j = 0; j < 10; i++, j++) {
System.out.println(i+j);
}
é correto, inicializando i e j para 0, e incrementando i e j depois de executar as
intruções.
Instrução while
A sintaxe do while é:
while (boolean) {
instrução ou bloco;
}
Exemplo:
int i = 0;
while (i < 10) {
System.out.println("Voce jah estah pronta?");
i++;
}
System.out.println("Sim");
21
Instrução do
A sintaxe para do é:
do {
instrução ou bloco;
} while (boolean test);
Exemplo:
int i = 0;
do {
System.out.println("Voce jah estah pronta?");
i++;
} while (i < 10);
System.out.println("Sim");
Controles Especiais de Fluxo
Você pode usar as seguintes declarações para controles adicionais:
break [rótulo];
continue [rótulo];
rótulo: instrução; / / indica um bloco de instrução rotulado
Uma instrução break pode ser utilizada para sair de um bloco qualquer. Um break não
rotulado finaliza o switch, for, while ou do mais interno. Caso você queira finalizar
uma instrução mais externa, utilize um rótulo para a instrução.
Uma instrução continue pula para o fim do laço e avalia a expressão booleana que
controla o laço (instruções while, do while e for).
Instrução break
do {
instrução ou bloco;
if (condition is true)
break;
} while (boolean expression);
Instrução continue
do {
instrução ou bloco;
if (boolean expression)
continue;
} while (boolean expression);
A instrução break com um rótulo chamado loop
loop:
do {
instrução;
do {
instrução;
instrução;
22
if (boolean expression)
break loop;
} while (boolean expression);
instrução;
} while (boolean expression);
A instrução continue com um rótulo chamado test
test:
do {
instrução;
do {
instrução;
instrução;
if (condition is true)
continue test;
} while (condition is true)
instrução;
} while (condition is true);
Exercício JAVA2
Crie um aplicação chamada Fatorial que imprima o fatorial de um número informado
pelo usuário.
Exercício JAVA3
Faça um programa que peça um número entre 0 e 1000 ao usuário. Use o código
Integer.parseInt(JOptionPane.showInputDialog("digite um numero"))
para
solicitar um valor. O programa deve dizer se o número é par ou impar. Se o número
for par (se número % 2 é igual a 0), o programa deve mostrar os números pares
menores que o próprio número.
Exercício JAVA4
Faça um programa que peça um número ao usuário e diga se é um número primo.
Números primos são divisíveis apenas por 1 e pelo próprio número.
Exercício JAVA5
Escreva o metodo main da classe Tabuada que imprime os valores multiplos de m
menores que n. O usuario deve informar os valores de m e n. O valor de n deve ser
maior que m. Por exemplo: Quais são os múltiplos de 2 (m) ate 8 (n)? Resposta: 0, 2,
4, 6
Exercício JAVA6
Escreva uma classe chamada AreaDoTrianguloRetangulo. Peça para o usuário digitar
os valores da base e da altura do triângulo e mostre o valor da área e da hipotenusa. A
área do triângulo é igual a base * altura / 2. A hipotenusa é igual raiz quadrada da
soma dos quadrados da base e altura (catetos). Dica: use a função Math.sqrt() para
calcular a raiz.
23
Classe e objeto
Criando uma classe
Considere a seguinte declaração:
int dia
Você aloca um certo espaço para armazenar e interpretar os conteúdos daquele
espaço. Assim, para definir um novo tipo, tem que especificar quanto de
armazenamento é requerido e como interpretar os conteúdos.
Por exemplo, para definir um tipo que representa uma data, você pode precisar de
espaço para armazenar três inteiros.
class MinhaData {
int dia;
int mes;
int ano;
}
Você pode declarar as variáveis nascimento e casamento como sendo do tipo
MinhaData, e o dia, mes, e o ano são incluídos para estas variáveis. Por exemplo:
MinhaData nascimento, casamento;
Criando um objeto
Objetos são criados utilizando-se uma expressão com a palavra chave new. Criar um
objeto a partir de uma definição de classe é também conhecido como instanciação,
sendo dessa forma, também chamados de instâncias.
MinhaData nascimento;
nascimento = new MinhaData( );
Os objetos criados são alocados em uma área da memória. Os objetos em Java são
acessados via uma referência. A referência meuNascimento é uma variável do tipo
MinhaData que aponta para um objeto criado a partir da classe MinhaData. Qualquer
variável que armazena um objeto contém uma referência ao objeto.
Você pode acessar o dia, mês e ano, utilizando o nome da nova variável mais ponto.
nascimento.dia = 16;
nascimento.mes = 6;
nascimento.ano = 1971;
Exemplo Completo:
public class MinhaData {
int dia;
int mes;
int ano;
public static void main(String[] args) {
MinhaData casamento;
casamento = new MinhaData();
casamento.dia = 8;
24
casamento.mes = 5;
casamento.ano = 1999;
System.out.print("Meu casamento foi dia " + casamento.dia);
System.out.print(" do mes " + casamento.mes);
System.out.println(" do ano de " + casamento.ano);
MinhaData nascimento = new MinhaData();
nascimento.dia = 16;
nascimento.mes = 6;
nascimento.ano = 1971;
System.out.print("Meu nascimento eh dia "+nascimento.dia);
System.out.print(" do mes "+nascimento.mes);
System.out.println(" do ano de "+nascimento.ano);
}
}
A execução da classe acima gera o seguinte resultado:
Meu casamento foi dia 8 do mes 5 do ano de 1999
Meu nascimento eh dia 16 do mes 6 do ano de 1971
Criando um objeto – Alocação de Memória
Em um código, a declaração.
MinhaData hoje;
só aloca espaço na memória para a referência hoje.
hoje
????
A palavra chave new cria o espaço de memória para a classe MinhaData.
hoje = new MinhaData( );
hoje
????
dia
0
0
0
mes
ano
A variável de referência hoje corresponde ao objeto criado.
MinhaData hoje;
hoje = new MinhaData( );
hoje
0x01abcdef
dia
mes
ano
Tipos de Referência
0
0
0
25
Considere este fragmento de código:
int x = 7;
int y = x;
String s = "Hello";
String t = s;
São criadas quatro variáveis: duas do tipo int e duas referências do tipo String. O
valor de x é 7, e este valor é copiado em y.
Com as variáveis s e t, só um objeto String existe e contém o texto "Hello". As
variáveis s e t apontam para um único objeto.
x
0x01abcdef
y
0x02defabc
s
0x03abefcd
t
0x03abefcd
"Hello"
Quando a variável t recebe a String "World", t aponta para um novo objeto.
t = "World";
x
0x01abcdef
y
0x02defabc
s
0x03abefcd
t
0x04cdefab
“Hello”
“World”
Exercício JAVA7
Um ponto pode ser caracterizado pelas coordenadas x e y.
a. Defina uma classe chamada Ponto que representa esta idéia. Defina as
coordenadas x e y como variáveis da classe Ponto.
b. Escreva uma classe Main com um método main ( ); declare duas variáveis
para o tipo Ponto. Chame as variáveis de inicio e fim para representar os
pontos inicial e final. Crie os objetos usando new Ponto( ). Atribua o valor 10
para coordenada x e 15 para coordenada y do objeto inicio. Mostre os valores
das coordendas do objeto inicio. Atribua o valor 20 para a variável x do objeto
fim, e o valor 30 para y do objeto fim. Mostre os valores x e y do objeto fim.
Arrays
26
Declarando Arrays
Um array é uma coleção de variáveis, todas do mesmo tipo. Os componentes de um
array são acessados por índices inteiros simples.
Você pode declarar arrays de qualquer tipo, primitivo ou classe:
char s [];
Ponto p[];
// Ponto é uma classe
char [] s;
Ponto [] p;
A declaração não cria o objeto propriamente dito. Ao invés, a declaração de um array
cria uma referência que você pode usar para percorrer um array.
Criando Arrays
Você cria arrays usando a palavra new:
s = new char[20];
p = new Ponto[100];
A primeira linha cria um array de 20 elementos tipo char. A segunda linha cria um
array de 100 variáveis de do tipo Ponto, mas não cria 100 objetos do tipo Ponto. Estes
devem ser criados separadamente como segue:
p[0] = new Ponto();
p[1] = new Ponto();
O índice inicial de um array sempre sera zero, e se você tentar acessar um índice
superior ao tamanho do array –1, irá gerar um erro.
Inicializando Arrays
Quando você cria um array, todo elemento é inicializado. No caso do array de char,
cada valor é inicializado com zero (‘\u0000’ - nulo). No caso do array tipo Ponto,
cada valor é inicializado com null, pois não fazem referência a nenhum objeto.
Você também pode inicializar arrays da seguinte forma:
String nomes[] = {"Georgianna","Jen","Simon"};
Ponto array[] =
{new Ponto(),
new Ponto(),
new Ponto() };
Color palette[] = {Color.blue,
Color.red,
Color.white };
Outras formas de iniciar um array e seus valores:
String nomes[];
nomes = new String[3];
nomes[0] = "Georgianna";
27
nomes[l] = "Jen"
nomes[2] = "Simon";
int numeros[];
numeros = new int[2];
numeros[0]=34;
numeros[1]=71;
Arrays Multi-Dimensionais
O Java não implementa arrays multi-dimensionais como as outras linguagens. Em
Java, o que existe é um array de array.
Exemplo:
int twoDim [] [] = new int [4] [];
twoDim[0] = new int [5] ;
twoDim[l] = new int[5];
O objeto que é criado por new é um array de quatro elementos. Cada elemento possui
uma referência null para um array de int e cada elemento deve ser inicializado
separadamente.
Nota – Você não pode declarar um array de array da seguinte maneira:
int novo [ ] [4]; //está declaração não é correta.
Como o Java trata o caso de arrays multi-dimensionais diferente das outras
linguagens, você pode inicializar cada elemento do array com um número diferente de
elementos, mas não de tipo diferentes.
twoDim[0]
twoDim[1]
twoDim[2]
twoDim[3]
=
=
=
=
new
new
new
new
int
int
int
int
[2] ;
[4] ;
[6] ;
[8];
Se o seu array possuir um tamanho fixo de elementos, você pode inicializar da
seguinte maneira:
int twoDim [ ] [ ] = new int [4] [5];
Tamanho de um Array
Na linguagem Java, todo array começa no índice 0. Se você quiser listar todos os
elementos deste array, você pode utilizar o atributo length para obter o tamanho
deste array. Caso você queira acessar o ultimo elemento deste array, use length – 1.
Com isso, você evita de tentar acessar um índice fora da faixa.
int list[ ] = new int [10]
for (int i = 0; i < list.length; i++) {
System.out.println(list[i]);
}
Redimensionando um Array
Uma vez criado, um array não pode ser redimensionado, mas você pode usar a mesma
variável de referência criar um novo array:
28
int myArray[] = new int[6];
myArray = new int[10];
Se você não salvar uma referência para o primeiro array, as informações contidas
serão perdidas.
Copiando Arrays
Você pode copiar dados de um array para outro array utlizando o método
arraycopy( ), da classe System.
System.arraycopy(Object arrayfonte,
int fonte_position,
Object arraydestino,
int destino_position,
int length)
Exemplo:
int dados[ ] = { 1, 2, 3, 4, 5, 6 };
int contagem[ ] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
System.arraycopy(dados, 0, contagem, 0, dados.length);
O array contagem passa a conter os seguintes dados: 1, 2, 3, 4, 5, 6, 4, 3, 2,1.
Ordenando Arrays
Você pode ordernar um array usando o método sort da classe Arrays:
Exemplo
public class Megasena extends Object {
public static void main(String args[]) {
int[] mega = new int[6];
for (int i=0;i<mega.length;i++) {
String resp = javax.swing.JOptionPane.
showInputDialog("Digite um numero");
mega[i] = Integer.parseInt(resp);
}
java.util.Arrays.sort(mega);
System.out.println("Mega:");
for (int i=0;i<mega.length;i++) {
System.out.println(mega[i]);
}
}
}
Exercício JAVA8
Crie uma classe chamada Media. No método main, declare uma variável chamada
notas do tipo array de int para 5 notas. Após o usuário informar as notas, o programa
deve calcular e mostrar a média.
Exercício JAVA9
29
Faça uma classe para perguntar 5 questões ao usuário. As perguntas devem ser
definidas como um array de String. As respostas devem ser salvas em um array de
Strings também. Ao final das perguntas o programa deve mostrar as perguntas e as
respostas.
Classes e Objetos
Princípios dos Objetos
A programação orientada a objetos inclui as características da programação
estruturada e um mecanismo para organizar variáveis e algoritmos. Existem três
características principais na orientação a objetos: encapsulamento, polimorfismo e
herança. Todas estas características ajudam a definir uma classe.
Classes e Objetos
O elemento fundamental da programação em Java é a classe. Uma classe contém uma
definição para um tipo comum de objetos. As classes também fornecem a estrutura
para os objetos, e os mecanismos para produzir os objetos a partir da definição da
classe . Uma classe é então um modelo para criação de objetos.
A classe define o que é um objeto e a implementação dos métodos que o objeto
responde. Cada objeto é uma instância de uma classe. Para instanciar um objeto, use o
operador new.
Métodos definem as operações que podem ser executadas pelos objetos. Em resumo,
os métodos definem o que a classe faz. Todos os métodos na linguagem Java
pertencem a uma classe.
Considere o seguinte exemplo de uma classe:
class EmpregadoInfo {
String nome;
String cargo;
String departamento;
}
As variáveis (nome, cargo, e departamento) são chamadas atributos da classe
EmpregadoInfo.
Para instanciar um objeto use a função new e atribua valores aos atributos:
// cria a instância
EmpregadoInfo empregado = new EmpregadoInfo( );
// inicializa os atributos
empregado.nome = "Roberto Javaman";
empregado.cargo = "Gerente";
empregado.departamento = "Doceria";
Você pode usar o objeto empregado da classe EmpregadoInfo.
System.out.println(empregado.nome + " é " +
empregado.cargo + " da " +
empregado.departamento);
30
para imprimir o seguinte:
Roberto Javaman é Gerente da Doceria
Você pode definir um método mostra ( ) dentro da classe para imprimir os dados. Esta
é uma característica fundamental de orientação a objetos, onde são encapsulados
dados e código em uma única entidade. O método mostra ( ) pode ser chamado como
se fosse uma função.
class EmpregadoInfo {
String nome;
String cargo;
String departamento;
public void mostra( ) {
System.out.println(nome + " é " +
cargo + " do " + departamento);
}
}
Este método imprime os dados dos atributos da classe quando o objeto foi criado e
instanciado.
// cria a instância
EmpregadoInfo empregado = new EmpregadoInfo( );
// inicializa os atributos
empregado.nome = "Roberto Javaman";
empregado.cargo = "Gerente";
empregado.departamento = "Doceria";
// imprime o resultado
empregado.mostra( );
Considere a classe Data e uma função chamada mudeParaAmanha ( ) que atualiza a
variável dia.
Você pode criar uma associação entre o tipo Data e o método mudeParaAmanha( ):
public class Data {
int dia, mes, ano;
public void mudeParaAmanha ( ) {
dia++; // código para incrementar 1 ao dia
}
}
Data d = new Data( );
d.dia = 16;
d.mudeParaAmanha( );
System.out.println("Amanhã é "+d.dia);
A idéia que métodos compõe um objeto e podem interagir intimamente com seus
dados é um conceito de orientação a objeto. (Isto difere da idéia que métodos são
entidades separadas.) O termo mensagem é usado freqüentemente para instruir um
objeto a fazer algo com os seus próprios dados; os métodos de um objeto definem o
que aquele objeto pode fazer com os seus próprios dados.
31
Definindo Métodos
Os métodos de uma classe geralmente contêm o código que entende e manipula um
estado de objeto. Cada método recebe um número específico de parâmetros. Os
métodos também possuem um tipo específico de retorno. A sintaxe para um método é
a seguinte:
<modificador_acesso> <tipo_retorno> <nome> ([<lista_parâmetros>])
[throws <exception>] { .... }
Exemplos:
public class SalarioEmpregado {
private double salario;
public void aumentaSalario (double valor) {
salario = salario + valor;
}
public double calculaImposto() {
double imposto = 0;
if (salario > 1200) {
imposto = salario * 0.15;
} else if (salario > 2900) {
imposto = salario * 0.27;
}
return imposto;
}
}
O < nome > pode ser qualquer identificador legal, com algumas restrições baseado
nos nomes que já estão em uso.
O < tipo_retorno > indica o tipo de valor retornado pelo método. Se o método não
retornar valor, deve ser declarado como void.
O < modificador_acesso > pode ser declarado como public, protected e private. O
modificador de acesso public indica que o método pode ser chamado por qualquer
outra classe. private indica que um método só pode ser chamado pelos outros métodos
dentro da própria classe.
O < lista_parâmetros > permite que argumentos possam ser passados ao método.
Elementos da lista são separados por vírgulas, enquanto cada elemento consiste em
um tipo e um identificador.
Por exemplo,
public void mostreValores(int a, int b) {
System.out.print( a );
System.out.print( b );
}
32
instrui o bloco do método mostreValores receber dois parâmetros que serão
mostrados.
Ou um método que retorna um valor:
public int retorneDias() {
return dia; // código do método
}
A cláusula throws < exception > é declarada para testar qualquer erro durante a
execução do método.
Passagem por valor
A linguagem de programação de Java só passa argumentos "por valor;" quer dizer, o
argumento não pode ser mudado pelo método chamado. Quando um objeto é passado
como um argumento a um método, o valor do argumento é uma referência ao objeto.
Podem ser mudados os conteúdos do objeto no método chamado, mas a referência de
objeto nunca é alterada.
A Referência this
this é uma palavra chave usada no método como referência para o objeto corrente. Ela
tem o significado de: "o objeto para o qual este trecho de código está sendo
executado". O uso de this também é válido para fazer chamadas de métodos para o
objeto corrente.
public class Data {
int dia, mes, ano;
public void mudeParaAmanha( ) {
this.dia = this.dia + 1;
}
}
O uso de this muitas vezes é redundante em certas circunstâncias. O código seguinte é
equivalente ao código anterior:
public class Data {
int dia, mes, ano;
public void mudeParaAmanha( ) {
dia = dia + 1;
}
}
Há ocasiões em que this não é redundante. Por exemplo, você poderia querer chamar
um método em alguma classe completamente separada e passar a própria referência
do objeto atual como um argumento. Por exemplo:
public class MinhaData {
int dia, mes, ano;
public void convidaAniversario( ) {
Aniversario.envieConvite(this);
}
}
33
Em outra classe
public class Aniversario
{
public static void envieConvite ( MinhaData d ) {
System.out.print( "Convido para meu aniversario " );
System.out.print( " será dia " + d.dia );
System.out.print( " mes " + d.mes );
System.out.print( " ano " + d.ano );
}
}
Para testar as classes acima:
MinhaData festa = new MinhaData();
festa.dia = 1;
festa.mes = 2;
festa.ano = 2008;
festa.convidaAniversario();
Ocultando Dados
Usando a palavra chave private na declaração de dia, mes, e ano na classe de Data faz
com que somente os métodos desta classe tenham acesso a elas. Qualquer instância a
esta classe em uma outra classe não poderá acessá-las.
public class Data {
private int dia, mes, ano;
}
Em outra classe
public class OutraClasse {
public static void main(String args[ ]) {
Data d = new Data( );
d.dia = 21; // illegal!
}
}
Acesso privado para os atributos traz vantagens para qualidade do programa. Com
isso, o único modo para ler ou atribuir valores só pode ser feito por métodos da
própria classe.
Exemplo:
public class Data {
private int dia, mes, ano;
public int getDia( ) {
return dia;
}
}
Encapsulamento
34
Além de proteger os dados de um objeto de modificação imprópria, forçando o
usuário a ter acesso aos dados por um método, assegura que os dados sempre sejam
tratados da mesma forma.
Se os dados forem completamente acessíveis, cada usuário da classe Data poderia
incrementar o valor do dia, testar o número de dias no mês atual e possivelmente o
fim do ano. Forçando o usuário da classe a usar os métodos, você assegura que o
tratamento seja o mesmo toda vez. Isto faz com que o código seja menos propenso a
manutenção.
Sobrecarregando Métodos
Em Java, cada método possui uma assinatura, que é o seu nome juntamente com o
número e tipo de seus parâmetros. Dois métodos podem ter o mesmo nome se suas
assinaturas possuírem diferentes números ou tipos de parâmetros.
Em algumas circunstâncias, você poderá escrever vários métodos com o mesmo nome
na mesma classe que faz o mesmo trabalho, mas com argumentos diferentes. Digamos
que você precisa de um método de impressão diferente para imprimir dados do tipo
int, float, e String. Esses tipos de dados requerem formatações diferentes, e
manipulações provavelmente variadas. Normalmente você criaria três métodos,
chamado printInt ( ), printFloat ( ), e printString ( ).
A linguagem Java permite usar o mesmo nome de método para mais de um método.
Assim, você pode definir os métodos da seguinte maneira:
public void println(int i)
public void println(float f)
public void println( )
Quando você chamar um destes métodos, o método apropriado é escolhido de acordo
com o tipo de argumento ou número de argumentos passados.
Duas regras se aplicam a métodos sobrecarregados:
O argumento tem que diferir para não permitir equívocos do método a ser chamado.
O tipo de retorno dos métodos diferente, não é suficiente para ser a única diferença. O
número de argumentos dos métodos sobrecarregados tem que ser diferentes.
Exercício JAVA10
Crie uma classe chamada Lampada com um atributo boleano para indicar o seu
estado, se ela está acesa ou apagada. Defina um método para ligar, um para apagar a
lâmpada e outro para mostrar o estado da lampada. No método main crie um objeto
para classe Lampada, ligue a lampada e mostre seu estado.
Exercício JAVA11
Crie uma classe chamada ContaBancaria.java que represente atributos e operações
de uma conta bancária. A conta deve ter os atributos cliente (String), número (int),
35
saldo (double) e especial (boolean). A conta deve ter as operações depósito e saque.
A operação depósito só pode aceitar valores positivos. A operação saque só pode
aceitar valores menores que o saldo, mas se a conta for especial ela pode aceitar
valores menores que o saldo mais 1000 reais.
Exercício JAVA12
Crie uma classe chamada Terminal que no método main faça o seguinte: criar um
objeto para classe ContaBancaria, definir valores para seus atributos, depositar 2000
reais, sacar 1200 reais, mostrar o saldo, sacar 1000 reais, definir como conta especial,
sacar 1000 reais novamente e mostrar o saldo.
Construindo e Inicializando Objetos
Para alocar espaço para um novo objeto, você precisa utilizar o operador new, por
exemplo: new Button("Press me")
O que o operador new faz:
1.Aloca espaço para o novo objeto.
2. As variáveis da classe são inicializadas.
3. Um construtor é executado. Os argumentos são passados entre parênteses para o
construtor.
Construtores
Os construtores são como métodos que possuem o mesmo nome que a classe que eles
inicializam. Como métodos, eles levam nenhum ou alguns parâmetros, mas os
construtores não são métodos, e portanto, não possuem tipo de retorno. Os
parâmetros, caso hajam, são fornecidos entre parênteses após o nome da classe
quando o objeto é criado com new.
Toda classe tem pelo menos um constructor. Se você não escrever um construtor, o
Java gera um construtor. Este construtor não leva nenhum parâmetro e o código é
vazio.
36
No exemplo a seguir, você tem a definição de três construtores, dois recebendo
parâmetros e outro não. Assim como os métodos, você também pode sobrecarregar
construtores, recebendo argumentos ou número de argumentos diferentes.
public class Empregado {
private String nome;
private int salario;
public Empregado(String n, int s) {
nome = n;
salario = s;
}
public Empregado(String n) {
this(n, 0);
}
public Empregado( ) {
this("Não definido");
}
}
Como a classe Empregado tem 3 construtores, podemos criar seus objetos de 3
maneiras diferentes:
Empregado objeto1 = new Empregado("Pedro",1500);
Empregado objeto2 = new Empregado("Paulo");
Empregado objeto3 = new Empregado();
Pacotes
A linguagem Java provê o mecanismo de pacote como um modo para se agrupar
classes relacionadas.
Você pode indicar que um arquivo fonte pertence a um pacote particular usando a
declaração package. Por exemplo:
// classe Empregado do Departamento Financeiro da companhia ABC
package abc.financeiro;
public class Empregado {
....
}
A declaração de pacote, deve estar no começo do arquivo fonte. Só uma declaração de
pacote é permitida e vale para o arquivo fonte inteiro.
Nomes de pacote são hierárquicos, separados por pontos. É comum os elementos do
nome de pacote serem completamente minúsculos.
A Instrução import
Quando você quiser usar pacotes, você usa a declaração de importação para "indicar"
ao compilador onde achar as classes. Por exemplo:
37
import abc.financeiro.*;
public class Gerente extends Empregado {
String departamento;
Empregado surbordinados[ ];
}
Quando você usar uma declaração de pacote, você não precisa importar o mesmo
pacote ou qualquer elemento daquele pacote. Lembre-se que a declaração de
importação é usada para trazer classes de outros pacotes.
A declaração de importação especifica a classe para a qual você quer acesso. Se você
quiser acesso a todas as classes de um pacote, use " *." Por exemplo, ter acesso a
todas as classes do pacote java.awt:
import java.awt.*;
Diretório de Pacotes
Pacotes são "armazenados" em uma árvore de diretório que contém uma ramificação
que é o nome do pacote. Por exemplo:
path/abc/financeiro
path\abc\financeiro
(Unix)
(Windows)
A opção -d para o compilador javac especifica a pasta raiz de uma hierarquia de
pacote na qual são gerados os arquivos de classe (.class).
Exercício JAVA13
Redefina a classe Lampada com um construtor que cria uma lampada no estado aceso
(boleano igual a true).
Exercício JAVA14
Redefina a classe Lampada no pacote auto.eletrico.
Exercício JAVA15
Escreva a classe Carro no pacote auto com 2 atributos do tipo Lampada: um chamado
farolEsquerdo e outro farolDireito. Compile a classe Carro. Onde está a classe Carro e
a classe Lâmpada em relação a pasta raiz (classpath)?
Herança
O que é Herança?
O programador cria um modelo de algo (por exemplo, um empregado), e então
precisa de uma versão mais especializada deste modelo. Por exemplo, você precisa
um modelo para um gerente. Um gerente é um empregado, mas é um empregado com
características adicionais.
Considere as declarações de classes:
38
public class Empregado {
String nome;
Date admissao;
Date nascimento;
}
public class Gerente {
String nome;
Date admissao;
Date nascimento;
String cargo;
int nivel;
String departamento;
Empregado surbordinados[ ];
}
Este exemplo ilustra a duplicação de dados entre a classe Gerente e a classe de
Empregado. Adicionalmente, poderia haver vários métodos que seriam aplicáveis a
Empregado e a Gerente. Herança é uma maneira para criar uma classe nova a partir de
uma classe já existente; chamada subclasse.
A palavra chave Extends
Em orientação a objeto, você pode criar uma nova classe com as mesmas
características de uma classe já definida. Para isto, você utiliza a palavra extends.
public class Empregado {
String nome;
Date admissao;
Date nascimento;
}
public class Gerente extends Empregado {
String cargo;
int nivel;
String departamento;
Empregado surbordinados[ ];
}
Neste exemplo, a classe de Gerente é definida para ter todas as variáveis e métodos
que um Empregado tem. São herdados todas as variáveis e os métodos da definição da
classe pai.
Nota - Esta é uma grande melhoria em termos de manutenção e confiança. Se uma
correção é feita na classe Empregado, então a classe Gerente é corrigida
automaticamente sem que o programador tenha que alterar qualquer coisa, basta
somente atualizar a classe Empregado.
Herança Simples
O Java permite estender somente uma classe. Esta restrição é chamada herança
simples. A linguagem Java impõe a restrição de herança simples para fazer o código
resultante menos confuso. Isto não impede de você criar hierarquias em vários níveis.
Por exemplo: a classe Gerente estende a classe Empregado e a classe Empregado
estende a classe Pessoa.
39
Construtores não são Herdados
Embora a subclasse herde todos os métodos e variáveis de uma classe pai, a subclasse
não herda seus construtores.
Polimorfismo
Descrevendo um Gerente como um Empregado não é só um modo conveniente de
descrever a relação entre estas duas classes. Gerente tem todos os atributos, variáveis
e métodos da classe Empregado. Isto significa que qualquer operação que é legítima
em um Empregado também é legítima em um Gerente. Se o Empregado possui
métodos como aumentarSalario( ), desligar( ), então a classe Gerente também tem.
Um objeto tem só uma forma. Porém, uma variável de classe é polimórfica porque
pode referênciar objetos de formas diferentes. Em Java, há uma classe que é a classe
pai para todas as outras, a classe java.lang.Object. Se definirmos uma variável do
tipo Object podemos referênciar qualquer objeto com ela, por exemplo:
Object geral;
geral = new Pessoa();
geral = new Empregado();
Isso é possível, pois Empregado é uma subclasse de Object.
public class Empregado extends Object
public class Gerente extends Empregado
A classe de objeto define vários métodos úteis, incluindo o método toString( ).
A linguagem Java, permite referênciar um objeto com uma variável que é um dos
tipos da classe pai. Assim você pode dizer:
Empregado objeto1 = new Empregado( );
Empregado objeto2 = new Gerente( );
Usando a variável objeto2, você só tem acesso as partes da classe Empregado; as
partes específicas da classe Gerente são escondidas. Então, o seguinte não é
permitido:
objeto2.departamento = "Finanças"; // departamento é uma variável de
Gerente, e não de Empregado
Coleções Heterogêneas
Uma coleção heterogênea é uma coleção de coisas diferentes. Em orientação a objeto,
você pode criar coleções de diferentes objetos. Por exemplo:
Empregado staff[ ] = new Empregado [1024];
staff[0] = new Gerente( );
staff[l] = new Empregado( );
Você pode escrever um método que classifica os empregados em idade ou ordem de
salário, mesmo que alguns sejam gerentes.
40
Nota - Toda classe é uma subclasse da classe object, assim você pode usar um array
de object como um recipiente para qualquer objeto. Os únicos elementos que não
podem ser acrescentados a um array de objetos são variáveis primitivas. Porém, a
classe Vector seria melhor que um array de Object, porque a classe Vector é projetada
para armazenar coleções heterogêneas de objetos.
Polimorfismo de Argumentos
Você pode escrever métodos que aceitam um objeto "genérico", neste caso a classe
Empregado. Você pode escrever um método em uma classe que recebe um
Empregado e compara o valor do salário para determinar a faixa de imposto a ser
retido. Usando o polimorfismo, você pode fazer isto como segue:
// na classe Empregado
public Imposto calculaImposto(Empregado e) {
//calcula e retorna a faixa de imposto
}
// em outro lugar, na classe aplicação
Gerente m = new Gerente( );
Imposto ir = calculaImposto (m); // isto é permitido, pois Gerente é
um tipo de Empregado
O Operador instanceof
Muitas vezes, você pode querer saber se um determinado objeto é de uma outra
classe. Para tal, você utiliza o operador instanceof.
Suponha a seguinte declaração:
public class Empregado
public class Gerente extends Empregado
public class Contratado extends Empregado
Se você receber um objeto que usa uma referência do tipo Empregado, poderá mostrar
se ele é um Gerente ou um Contratado. Você pode testar isto usando instanceof como
segue:
public void method(Empregado emp) {
if (emp instanceof Gerente) {
// traz o salário
}
else if (emp instanceof Contratado) {
// traz o valor da horas
}
else {
// empregado normal
}
}
Convertendo Objetos
41
Em circunstâncias onde você recebeu uma referência da classe pai, e você
determinou que o objeto é de fato uma subclasse usando o operador de instanceof,
você pode restabelecer a funcionalidade completa do objeto convertendo a referência.
public void method(Empregado emp) {
if (emp instanceof Gerente) {
//converte o objeto para ter acesso a Gerente
Gerente objetoGerente = (Gerente) emp;
System.out.println("Este é o gerente do " +
objetoGerente.departamento);
}
// resto do método
}
Se você não converter o objeto emp, uma falha aconteceria ao acessar
emp.departamento, pois departamento só existe na classe Gerente.
Sobrescrevendo Métodos
Além de poder criar uma nova classe baseada em outra somando características
adicionais, você pode modificar o comportamento existente da classe pai.
Se um método está definido em uma nova classe com o mesmo nome, tipo de retorno
e número de argumentos iguais a da classe pai, este novo método irá sobrescrever o
método da classe pai.
Considere estes métodos da classe Empregado e classe Gerente:
public class Empregado {
String nome;
int salario;
public String getDetalhes( ) {
return "Nome: " + nome + "\n" +
"Salario: " + salario;
}
}
Na classe gerente:
public class Gerente extends Empregado {
String departamento;
public String getDetalhes( ) {
return "Nome: " + nome + "\n" +
"Gerente de " + departamento;
}
}
A classe Gerente tem um método getDetalhes ( ) porque herdou da classe Empregado.
Porém, o método original foi substituído pela outra versão na classe Gerente.
Se criarmos dois objetos para as classes Empregado e Gerente:
Empregado objetoEmp = new Empregado( );
Gerente objetoGerente = new Gerente( );
42
Ao executar objetoEmp.getDetalhes( ) e objetoGerente.getDetalhes ( ), eles
executarão, respectivamente, o método getDetalhes( ) da classe Empregado e
getDetalhes ( ) da classe Gerente.
Ao você declarar
:
Empregado objetoEmp = new Gerente( );
objetoEmp. getDetalhes( )
o método a ser chamado será o da classe Gerente, pois você apenas criou uma variável
do tipo Empregado, mas o objeto é um Gerente.
Regras sobre Métodos Sobrescritos
As seguintes regras se aplicam a métodos sobrescritos:
1. O tipo de retorno do método sobrescrito deve ser idêntico ao método que
sobrescreve.
2. Um método sobrescrito não pode ser menos acessível que o método que
sobrescreve.
3. Um método sobrescrito não pode lançar tipos diferentes de exceções que o método
que sobrescreve.
Estas regras são o resultado da natureza de polimorfismo combinada com a
necessidade da linguagem Java ser "typesafe."
public class Pai {
public void metodo ( ) {
}
}
public class Filho extends Pai {
private void metodo ( ) {
}
}
public class Exemplo {
public void executar( ) {
Pai pl = new Pai( );
Pai p2 = new Filho( );
pl. metodo ( );
p2. metodo ( );
}
}
Devido a semântica da linguagem Java, p2.metodo( ) deveria executar o método da
classe Filho. Quando você sobrescreve um método, você só pode dar mais acesso a
este, e não restringi-lo. Neste caso, a classe Pai declara o método como public, e ao
refazer o método na classe Filho, ele é declarado como private, o que causará um erro
de semântica na compilação.
A Palavra Chave super
43
A palavra chave super está disponível em todos os métodos não-estáticos de uma
classe estendida. Para acesso de campos e execução de métodos, super() atua como
uma referência ao objeto corrente pelo modelo de sua superclasse. A execução de
super.método sempre utiliza a implementação da superclasse do método.
Exemplo com super:
public class Empregado {
private String nome;
private int salario;
public String getDetalhes( ) {
return "Nome: " + nome + "\nSalario: " + salario;
}
}
public class Gerente extends Empregado {
private String departamento;
public String getDetalhes( ) {
// chama metodo da superclasse
return super.getDetalhes( ) + " Departamento:
departamento;
}
}
" +
Invocando Construtores da classe Pai
A inicialização de objetos na linguagem Java é estruturada. O Java sempre inicializa
completamente a classe pai antes de executar qualquer coisa na classe filho, ou seja, o
construtor da classe pai é executado antes do construtor da classe filho.
Você pode definir um construtor que leva argumentos e você quer usar esses
argumentos para a construção de uma parte do objeto pelo modelo da classe pai. Você
pode invocar um construtor da classe pai com super() na primeira linha do construtor
da classe filho. Por exemplo:
public class Empregado {
String nome;
public Empregado(String n) {
nome = n;
}
}
public class Gerente extends Empregado {
String departamento;
public Gerente(String s, String d) {
super(s); // chama o construtor de pai com uma String como
argumento
departamento = d;
}
}
Você também pode utilizar super para ter acesso a membros protected da superclasse.
Exercício JAVA16
44
Redefina a abstração de uma conta corrente em duas classes: ContaSimples e
ContaEspecial. A classe ContaSimples tem os atributos cliente, número e saldo. As
operações são: void deposito(double valor), void saque(double
valor), boolean temSaldo(double valor) e void
mostraSaldo(). A classe ContaEspecial, além de ser uma conta simples, tem um
limite que é uma variável do tipo double. A operação temSaldo da ContaEspecial
deve levar em conta este limite.
Exercício JAVA17
Faça uma classe chamada GerenciaConta, e no método main teste as classes
ContaSimples e ContaEspecial.
Características da Linguagem
Variáveis do tipo Static
Às vezes é desejável ter uma variável que seja compartilhada entre todas as instâncias
de uma classe. Por exemplo, isto pode ser usado como uma base para comunicação
entre instâncias ou manter-se a par do número de instâncias que foram criados. Você
pode conseguir isto declarando a variável como static.
public class Carro {
private int serialNumber;
private static int contadorObjetos = 0;
public Carro( ) {
contadorObjetos ++;
serialNumber = contadorObjetos;
}
}
Neste exemplo, a variável contadorObjetos é compartilhada entre todas as
instâncias. Assim quando o construtor de um objeto incrementar o contador, o
próximo objeto a ser criado recebe o valor incrementado.
Uma variável estática é semelhante a uma variável global em outras linguagens. Java
não possui variáveis globais, mas uma variável estática é uma variável acessível em
qualquer instância da classe.
Se uma variável estática não for declarada como private, você pode ter acesso fora da
classe. Para fazer isto, você não precisa instanciar a classe, e sim acessar pelo nome
de classe. Geralmente as variáveis deste tipo também são declaradas como constantes,
somente para leitura com o uso do final.
public class CEP {
public static final int R_XV = 89200;
public static final int R_AMERICA = 89201;
}
public class Correio {
public void metodo( ) {
int x = CEP.R_XV;
}
}
45
Métodos do tipo Static
Muitas vezes você precisa ter acesso a um método de uma classe que não está
instanciada. Para isso, você pode declarar o método como static e acessá-lo em outra
classe apenas passando o nome da classe e o método, sem precisar ter uma referência.
Por exemplo:
public class Quadrado {
public static int calculaArea( int x, int y ) {
return x * y;
}
}
public class Grafico {
public static void main( String a[] ) {
int a = 9;
int b = 10;
int c = Quadrado.calculaArea(a, b);
System.out.println("Area é igual a " + c);
}
}
Um método declarado como static não possue acesso a váriaveis não estáticas. Um
método estático só acessa variáveis que são do seu próprio escopo ou seus
argumentos. Para ter acesso a essas variáveis não estáticas, você teve criar um objeto
para a classe.
Exemplo de acesso a variável não estática no método estático:
public class Ponto {
int x;
public static void main(String args[ ]) {
x = 9; // Aqui dá erro de compilação
}
}
Pontos importantes sobre métodos estáticos:
Método main ( ) é static porque deve ser executado antes de criar qualquer instância.
Quando o método main ( ) é executado, nenhum objeto é criado, assim se você tiver
variáveis de classe (atributos), você tem que criar um objeto para acessá-los.
Um método estático não pode ser sobrescrito para ser não-estático.
Inicializadores do tipo Static
Uma classe permite criar códigos "em bloco static" que não exista dentro de um corpo
de um método. Os códigos do bloco static executam somente uma vez, quando a
classe é carregada na memória pela JVM. Os blocos estáticos diferentes dentro de
uma classe são executados na ordem que estão na classe.
46
public class ExemploEstatico {
static int i = 5;
static {
System.out.println("Codigo estatico: i = " + i++ );
}
}
public class Test {
public static void main(String args[ ]) {
System.out.printin("Codigo de main: i= " + ExemploEstatico.i);
}
}
O resultado será:
Codigo estatico: i = 5
Codigo de main: i = 6
Exercício JAVA18
Defina uma classe chamada Matemática com dois métodos estáticos: um método
chamado maior(int x, int y) que retorna o valor do maior parâmetro e outro método
chamado menor(int x, int y).
Exercício JAVA19
Crie uma classe ComparaValor onde o usuário informa dois valores e o programa
mostra o valor maior e o menor usando os métodos definidos na classe Matemática do
exercício anterior.
Dados e Métodos Orientados a Objetos
Um sistema orientado a objetos consiste em objetos. Os objetos criados a partir um
modelo chamado classe. Os atributos são definidos por variáveis e os comportamentos
são definidos por métodos. Apesar de todos os objetos da mesma classe herdarem as
mesmas características, cada objeto é diferente.
Por exemplo:
public class Carro {
String cor;
String modelo;
public Carro (String c, String m) {
this.cor = c;
this.modelo = m;
}
public void mostra( ) {
System.out.println ("Este carro é um " + modelo + cor + ".");
}
}
47
Todos os objetos de carro criados nesta classe têm uma cor e um modelo, mas cada
objeto de carro está separado dos outros e pode ter uma cor ou modelo diferente que
os outros. Suponha dois objetos de carro:
Carro vectra = new Carro("Branco","Vectra");
Carro corsa = new Carro("Prata","Corsa");
A orientação a objetos é ilustrada pelo fato que ambos os objetos têm dados
separados, embora ambos sejam carros.
Objetos possuem métodos que, embora consistam no mesmo código, se comportam
diferentemente porque os dados com que eles operam são diferentes para os objetos.
Por exemplo,
vectra.mostra( ) imprimirá "Iste carro é um Vectra Branco."
corsa.mostra( ) imprimirá "Iste carro é um Corsa Prata."
Palavra chave final
Classes final
Uma classe definida como final não pode ser extendida (ou especializada) por
nenhuma outra classe, e todos os métodos de uma classe final são implicitamente
final. Se uma classe é final, você não pode declarar uma subclasse dela, e portanto,
não pode violar seu contrato.
Métodos final
Definir um método como final significa que nenhuma classe estendida poderá
sobrepor o método para mudar seu comportamento.
Existem duas razões para se declarar um método como final. A primeira é a
segurança. Qualquer um que utilize a classe pode estar seguro de que o
comportamento não mudará. A segunda razão é que final simplifica otimizações.
Variáveis final
Se uma variável for declarada como final, você está declarando que ela será uma
constante. Qualquer tentativa para mudar o valor, causará um erro. O exemplo mostra
uma variável final corretamente definida:
public final int MAX_ARRAY_SIZE = 25;
Classes Abstratas
Utilizando classes abstratas, você pode declarar classes que definam apenas parte de
uma implementação, deixando que as subclasses forneçam a implementação
específica de alguns ou de todos os métodos.
Uma classe, como a classe PecaXadrez que declara a existência de métodos mas não
os implementa, também passa a ser uma classe abstrata.
48
Você pode declarar uma classe abstrata declarando-a abstract. Métodos que são
declarados mas não são implementados, também deve ser declarados como abstract.
public abstract class PecaXadrez {
int x;
int y;
public abstract boolean movimentoValido(int x, int y);
public void move(int x, int y) {
if (movimentoValido(x,y)) {
this.x = x;
this.y = y;
} else {
System.out.println("Movimento inválido")
}
}
}
Você não pode instanciar uma classe abstrata. Porém, você pode criar uma variável
cujo tipo é uma classe abstrata. Você não pode ter construtores abstratos nem métodos
estáticos abstratos.
Subclasses de classes abstratas têm que implementar todos os métodos abstratos
declarados na classe pai. Caso contrário elas também serão classes abstratas.
public class Rainha extends PecaXadrez {
public boolean movimentoValido(int x, int
// faz consistência do movimento para a
}
}
public class Rei extends PecaXadrez {
public boolean movimentoValido(int x, int
// faz consistência do movimento para o
}
}
y){
Rainha
y){
Rei
public class Tabuleiro {
Rainha rainhaBranca = new Rainha( );
Rei reiBranco = new Rei();
…
public void movePeca(PecaXadrez pc, int x, int y) {
pc.move(x,y);
}
…
}
Exercício JAVA20
Defina uma classe Conta com os métodos saque e deposito (iguais ao da classe Conta
Simples) e um método abstrato chamado boolean temSaldo(double valor). Redefina a
classe ContaSimples com relacionamento de herança com a classe Conta. Implemente
o código do método temSaldo na classe ContaSimples.
Interfaces
Uma interface é uma variação da idéia de uma classe abstrata. Em uma interface
todos os métodos são abstratos; nenhum deles possuem implementação. Uma
interface só pode definir variáveis do tipo static final.
49
Quando uma classe estende uma interface, esta classe deverá implementar todos os
métodos da interface, ou simplesmente declará-los sem nenhuma implementação.
Interfaces são definidas com a palavra chave interface como segue:
public interface Cor {
public int getCor( );
public void setCor(int cor);
}
Enquanto um classe só pode estender uma única classe, uma classe pode implementar
quantas interfaces forem necessárias. Interfaces implementadas por uma classe
aparecem separadas por virgulas, como mostrado abaixo:
public class MyApplet extends Applet implements Runnable,
MouseListener {
" ……… "
}
O exemplo seguinte mostra uma interface simples e uma classe que implementa isto:
public interface ObjetoSeguro {
public void abre(int segredo );
}
public class Cofre implements ObjetoSeguro {
public void abre(int segredo ) {
if (segredo == 1234) {
System.out.println("Cofre Aberto");
}
}
}
Exercício JAVA21
Defina uma interface chamada Bancaria, tendo três métodos: deposito, saque e
mostraSaldo.
Exercício JAVA22
Redefina a classe, Conta.java, usando a interface Bancaria para definir tipos de contas
diferentes.
Controle de Acesso
As variáveis e os métodos podem estar em um desses quatro níveis de acesso: public,
protected, default, ou private. As classes podem estar no nível public ou default.
Mesmo que uma aplicação não exija que os campos sejam somente para leitura, tornar
os campos privados e adicionar métodos para estabelecer seus valores e extraí-los,
permite-lhe adicionar ações que possam ser necessárias no futuro. Se as pessoas
tiverem acesso aos campos ou métodos da classe diretamente, você não terá controle
50
sobre quais valores eles irão utilizar ou o que acontecerá quando os valores ou
métodos forem alterados.
Abaixo, uma tabela que possui os níveis de acesso por modificadores.
Modificadores
Public
Protected
Default
Private
Mesma Classe
sim
sim
sim
sim
Mesmo Pacote
sim
sim
sim
SubClasses
sim
sim
Universal
sim
Exemplo
Operador = = versus Método equals( )
O operador = = compara dois tipos equivalentes, ou seja, verifica, por exemplo se x é
igual a y. Diferente de outras linguagens, ao se utilizar apenas =, você está
informando que a variável irá receber um determinado valor, e não está fazendo uma
comparação.
O método equals serve para fazer comparações entre objetos. Geralmente é utilizado
na comparação de Strings, mas você pode sobrescrever este método.
Por exemplo, o métodos equa1s ( ) da classe Ponto, compara se o valor das
coordenadas são iguais.
Exemplo:
class Ponto {
int x,y;
public boolean equals(Object obj) {
boolean iguais = false;
51
if (obj instanceof Ponto) {
Ponto outro = (Ponto) obj;
iguais = (this.x == outro.x && this.y == outro.y );
}
return iguais;
}
public static void main (String args[ ]) {
Ponto a = new Ponto();
a.x = 1;
a.y = 2;
Ponto b = new Ponto();
b.x = 1;
b.y = 2;
if (a == b) {
System.out.println("As referencias dos objetos são iguais");
}
if (a.equals(b)) {
System.out.println("As coordenadas dos objetos são iguais");
}
}
}
Resultado:
As coordenadas dos objetos são iguais
Método toString( )
Como toda classe, devido a semântica do Java, herda os métodos da classe Object,
você pode subscrever este método para retornar a representação de texto da sua classe.
O método toString ( ) é usado para converter um objeto em uma representação de
String.
Date hoje = new Date( );
System.out.println(hoje);
poderia ser traduzido como:
System.out.println(hoje.toString( ));
onde o método toString( ) na classe Date, teria sido subscrito para retornar Strings.
Você pode redefinir o método toString em qualquer classe:
class Ponto {
int x, y;
public String toString() {
return "Ponto(" + x + "," + y + ")";
}
}
Classes Internas
Classes internas permitem colocar a definição de uma classe dentro da definição de
outra classe. Classes internas são utéis quando permitem agrupar classes que
logicamente só existem dentro de outra classe.
52
Exemplo de uma classe interna
import java.awt.*;
import java.awt.event.*;
public class Formulario extends Frame {
private Button myButton;
private TextArea myTextArea;
private int count;
public Formulario( ) {
super("Exemplo de classe interna");
myButton = new Button("Pressione");
myTextArea = new TextArea( );
add(myButton, BorderLayout.CENTER);
add(myTextArea, BorderLayout.NORTH);
ButtonListener blist = new ButtonListener( );
myButton.addActionListener(bList);
}
class ButtonListener implements ActionListener {
public void actionPerfomed (ActionEvent e) {
count++;
myTextArea.setText("O botão foi clicado " + count + " vezes.");
}
}
public static void main (String args[ ]) {
Formulario f = new Formulario( );
f.setSize(300,300);
f.setVisible(true);
}
}
Ao compilar, você verá no seu diretório dois arquivos .java. Um com o nome de
Formulario.java e outro Formulario$ButtonListener.java, representado a classe
interna.
Classes Wrapper
As classes Wrapper servem como "envelopes" para os tipos primitivos serem tratados
como objetos. Cada tipo primitivo possui sua classe Wrapper. Um exemplo de sua
utililidade, é que quando você quer adicionar um tipo primitivo em um Vector, você
precisa utilizar um Wrapper para que este tipo primitivo seja tratado como um objeto,
pois um Vector só consegue adicionar objetos.
Observação: a partir do Java 1.5 isso foi alterado e o Java converte os tipos primitivos
para seu wrapper automaticamente.
Tipo Primitivo
Boolean
Byte
Char
Short
Int
Long
Float
Classe Wrapper
Boolean
Byte
Character
Short
Integer
Long
Float
53
Double
Double
Exemplo:
int pInt = 500;
Integer wInt = new Integer(pInt);
int p2 = wInt.IntValue( );
Este exemplo mostra o tratamento de uma String para um tipo int.
int x = Integer.valueOf (str).intvalue( );
ou
int x = Integer.parseInt (str);
Exercício JAVA23
Crie uma classe chamada SistemaSolar. No SistemaSolar crie a classe interna
chamada Planeta com os atributos nome e distanciaDoSol. Defina um array de Planeta
para o SistemaSolar. No construtor de SistemaSolar defina objetos para o array. Crie
o método mostrePlanetas para o SistemaSolar. No método main crie um objeto da
classe SistemaSolar e chame o método mostrePlanetas.
Exceções
As exceções oferecem uma maneira "limpa" de tratar os erros durante a execução do
programa. Uma exceção é causada quando uma condição de erro inesperada é
encontrada. A exceção é capturada na pilha de execução dos métodos. Se a exceção
não for capturada, o manipulador de exceções padrão é executado, imprimindo
informações úteis sobre em que linha de código a exceção foi lançada.
Por exemplo, exceções podem acontecer quando:
1. O arquivo que você tenta abrir não existe
2. A conexão de rede é interrompida
3. Operandos manipulados estão fora das faixas prescritas
4. O arquivo de classe quer você está carregando não é encontrado
Exemplo
public class Semaforo {
public static void main (String args[ ]) {
int i = 0;
String semaforo [ ] = {"Verde", "Amarelo","Vermelho"};
while (i < 4) {
System.out.println (sinais[i]);
i++;
}
}
54
}
Normalmente, um programa termina com uma mensagem de erro quando uma
exceção é lançada, como mostrado depois que o while executa quatro vezes.
java Semaforo
Verde
Amarelo
Vermelho
java.lang.ArrayIndexOutOfBoundsException: 3
at Semaforo.main(Semaforo.java:12)
Você pode tratar este erro testando a exceção lançada e redefinindo o fluxo do
programa para outro ponto ou parando sua execução.
Instruções try e catch
As exceções são capturadas vinculando o código a um bloco try. O bloco try é
executado até uma exceção ser lançada ou finalizar com sucesso. Se uma exceção for
lançada, as cláusulas catch serão verificadas visando localizar uma para a exceção
daquela classe ou uma das superclasses da exceção. Se nenhum catch apropriado for
localizado, a exceção passará fora da instrução try em qualquer try mais externo que
possa manipulá-la. Se não houver nenhuma cláusula catch no método para capturar a
exceção, ela será lançada para o código que chamou este método.
Sintaxe:
Conta c = new Conta();
try {
c.saque(100);
} catch (EstouroSaqueException e) {
System.out.println("Erro: " + e.getMessage() );
}
c.mostraSaldo();
Instrução finally
A instrução finally define um bloco de código que sempre será executado, mesmo que
uma exceção seja lançada ou não:
Conta credito = new Conta( );
Conta debito = new Conta( );
boolean transacaoOk = false;
try {
abreTransacao( );
debito.saque ( valor );
credito.deposito( valor );
transacaoOk = true;
} finally {
if ( transacaoOk )
fechaTransacao( );
else
desfazTransacao( );
}
55
No exemplo acima, o código tenta fazer a transferência dentro do bloco try.
Independente se a transferência foi com sucesso ou com erro, o bloco finally será
executado para fechar ou desfazer a transação. O bloco finally só não será executado
se o método System.exit ( ) que termina o programa for executado dentro de try. Caso
o bloco try possuir algum return que modifique o fluxo do programa, a instrução
finally será executada, para só depois o return ser executado.
Exemplo
public class Semaforo {
public static void main (String args[ ]) {
int i = 0;
String sinais [ ] = {"Verde","Amarelo","Vermelho"};
while (i < 4) {
try {
System.out.println (sinais[i]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Reiniciar valor do indice.");
i = -1;
} finally {
System.out.println("Isto é sempre impresso!");
}
i++;
}
}
}
Instrução throw
As exceções são lançadas utilizando-se a instrução throw, seguido de um objeto como
seu parâmetro.
public void deposito(double valor) throws DepositoInvalidoException {
if (valor > 0) {
saldo = saldo + valor;
} else {
throw new DepositoInvalidoException("Este valor é invalido para
depósito: " + valor);
}
}
O método deposito verifica o valor é válido para depósto. Se não for, ele irá criar e
lançar um objeto DepositoInvalidoException, passando ao construtor deste objeto os
argumentos necessários.
Cláusula throws
As exceções que um método pode lançar são declaradas na cláusula throws, com uma
lista de tipos de exceções separadas por vírgula. O contrato definido pela cláusula
throws é rigorosamente observado. Você pode lançar apenas os tipos de exceção que
tenham sido declarados na cláusula throws.
Categorias de Exceção
56
Há três categorias de exceções na linguagem de programação Java. A classe
java.lang.Throwable atua como a classe pai para todos os objetos que podem ser
lançados e podem ser capturados usando os mecanismos de manipulação de exceções.
Métodos definidos na classe de Throwable retornam a mensagem de erro associada
com a exceção e imprimem onde a exceção aconteceu. Há três subdivisões dessa
classe: Error, RuntimeException, e Exception.
Descrição de propósitos de algumas exceções:
Error - indica um problema sério do qual a recuperação é difícil, se não impossível.
RuntimeException - indica um problema de implementação ou arquitetura.
Outras exceções indicam uma dificuldade de execução que normalmente é causado
pelo ambiente e pode ser controlado. Exemplos incluem um arquivo não encontrado
ou exceções de URL inválidas.
Tratando ou Declarando Exceções
As exceções podem ser tratadas da seguinte maneira:
A primeira maneira é tratar a exceção dentro do próprio método onde ocorreu a
exceção, usando para isso try, catch e finally.
A segunda maneira é lançar a exceção para a classe que executou o método,
utilizando para isso a cláusula throws.
public void leArquivo( ) throws IOException
Criando Suas Próprias Exceções
Exceções definidas pelo usuário são criadas estendendo a classe Exception. Classes de
exceção podem conter qualquer coisa que uma classe normal.
public class DepositoInvalidoException extends Exception {
public DepositoInvalidoException (String motivo) {
super(motivo); // chama construtor da classe pai
}
}
Para lançar uma exceção para a classe que você criou, use a sintaxe:
throw new DepositoInvalidoException ("Valor inválido");
Para capturar sua exceção, use a instrução try:
public static void main( String[] args ) {
Conta c = new Conta();
try {
c.deposito (10);
}
catch (DepositoInvalidoException e) {
System.out.println("Erro: " + e.getMessage());
}
57
}
Você também pode processar parcialmente uma exceção e então relança-la.
Por exemplo:
public static void main( String[] args ) throws Exception {
Conta c = new Conta();
try {
c.deposito (10);
}
catch (DepositoInvalidoException e) {
System.out.println("Erro: " + e.getMessage());
throw e;
}
}
Exercício JAVA24
Crie as seguintes exceções no pacote erros:
a. EstouroSaqueException - Acontece quando é feita uma tentativa de
tirar mais dinheiro do que a conta possui.
b. DepositoInvalidoException–Acontece quando uma quantia inválida de
dinheiro (quantia < zero) é depositada.
Exercício JAVA25
Rescreva a classe Conta com as operações de saque e depósito para lançar estas
exceções.
Datas e Calendário
Criando Datas e Calendários
A classe java.util.Date representa uma data e a classe java.util.Calendar representa um
calendário para trabalhar com as datas.
Date hoje = new Date();
Calendar c = Calendar.getInstance();
Formatando Datas
Para formatar datas em java use a classe java.text.SimpleDateFormat. Esta classe
possui dois métodos básicos: parse(String) para converter um texto em uma data e
format(Date) para formatar a data em um texto. Por exemplo:
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm");
String texto = sdf.format(new Date());
Date dia = sdf.parse("16/06/1971 23:00");
58
Você também pode usar a classe DateFormat.
Calculando Datas
A classe Calendar permite a definição de data com o método set e o cálculo de datas
com o método add(int, int). Por exemplo:
import java.util.Date;
import java.util.Calendar;
import java.text.DateFormat;
public class Calendario {
public static void main(String[] args) {
Date hoje = new Date();
System.out.println("Hoje é " + hoje);
DateFormat sdf = DateFormat.getDateInstance();
System.out.println(sdf.format(hoje));
try {
Date nascimento = sdf.parse("16/06/1971");
System.out.println("Meu nascimento foi " + nascimento);
} catch (Exception e) {
System.out.println("Data invalida");
}
Calendar cal = Calendar.getInstance();
System.out.println("Data é "+cal.getTime());
cal.set(1990,0,1);
System.out.println("Data é "+cal.getTime());
cal.set(2000,0,1,0,0,0);
System.out.println("Data é "+cal.getTime());
cal.add(Calendar.DATE, 30);
System.out.println("Data é "+cal.getTime());
cal.add(Calendar.MONTH, 2);
System.out.println("Data é "+cal.getTime());
}
}
O resultado da execução do programa acima é
Hoje é Tue Nov 28 23:07:31 BRST 2006
28/11/2006
Meu nascimento foi Wed Jun 16 00:00:00 BRT 1971
Data é Tue Nov 28 23:07:31 BRST 2006
Data é Mon Jan 01 23:07:31 BRST 1990
Data é Sat Jan 01 00:00:00 BRST 2000
Data é Mon Jan 31 00:00:00 BRST 2000
Data é Fri Mar 31 00:00:00 BRT 2000
Exercício JAVA26
Faça uma classe que mostre a data atual menos 7 dias no formato dd-MM-yyyy.
59
Coleções
O java tem um framework de coleções que inclui listas, conjuntos e mapas. As
operações básicas ao usar as coleções são:
- adicionar objetos
- remover objetos
- verificar se existe um objeto
- recuperar um objeto
- percorrer os objetos um a um
Principais classes e interfaces
As principais interfaces da API de coleção são: List, Set e Map
A tabela a seguir apresenta as principais classes que implementam as interfaces
acima:
Implementações de Map Implementações de Set
Implementações de List
HashMap
HashSet
ArrayList
Hashtable
LinkedHashSet
Vector
TreeMap
TreeSet
LinkedList
Vale aqui ressaltar que no java existe uma interface chamada Collection, que é a
interface pai das interfaces Set e List. No java também existe a classe
java.util.Collections que tem diversos métodos estáticos para uso em coleções.
As coleções se dividem em três categorias básicas:
Listas Listas de objetos
Set
Conjuntos de objetos únicos
Maps
Objetos com uma identificação única
Por exemplo:
List: uma lista com o itinerário do vendedor
Indice
0
1
2
Valor
Centro
América
Costa e
Silva
3
Glória
4
América
Set: um conjunto de bairros que o vendedor atende
Centro
América
Costa e Silva
Glória
HashMap: categoria de produtos e os produtos do vendedor
Hashcode
1
2
3
4
5
Centro
60
Valor
Creme
Sabonete
Escova
Revista
Ordered e Sorted
No java uma coleção pode ser um conjunto ordenado (mantém a ordem de inclusão)
de objetos (Ordered collection) ou uma coleção organizada na ordem alfabética ou
numérica (Sorted collection).
Vamos analisar estes exemplos que destacam as diferenças de coleções Ordered e
Sorted:
import java.util.*;
public class Ordered {
public static void main(String[] args) {
LinkedHashSet lhs = new LinkedHashSet();
lhs.add ("Chicago");
lhs.add ("Detroit");
lhs.add ("Atlanta");
lhs.add ("Denver");
Iterator it = lhs.iterator();
while (it.hasNext()) {
System.out.println("cidade "+it.next());
}
}
}
O código acima da classe Ordered gera o resultado:
cidade Chicago
cidade Detroit
cidade Atlanta
cidade Denver
import java.util.*;
public class Sorted {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add ("Chicago");
ts.add ("Detroit");
ts.add ("Atlanta");
ts.add ("Denver");
Iterator it = ts.iterator();
while (it.hasNext()) {
System.out.println("cidade "+it.next());
}
}
}
O código acima da classe Sorted gera o resultado abaixo:
cidade Atlanta
cidade Chicago
cidade Denver
cidade Detroit
Sabendo a diferença entre ordenado e organizado, vamos ver as interfaces List, Set e
Map.
61
List
As listas se preocupam com os índices. As listas tem métodos para lidar com os
índices: get (int index) , indexOf( ) , add(int index, Object obj) e add(Object). Vamos
ver 3 implementações da interface List.
ArrayList
É um array dinâmico com acesso rápido. Para criar um ArrayList basta instanciar um
objeto.
ArrayList numerosDaMega = new ArrayList();
O tamanho do ArrayList é dado pelo método size().
int t = numerosDaMega.size();
Para adicionar um objeto ao ArrayList usamos o método add(Object):
numerosDaMega.add(new Integer(3));
Recuperamos um objeto do ArrayList com o método get(int):
Integer n = numerosDaMega.get(0);
Vector
É basicamente a mesma coisa que um ArrayList, mas os métodos do Vector são
sincronizados para acesso concorrente. Prefira um ArrayList se você não precisa se
preocupar com acesso concorrente, ou seja, várias threads acessando a mesma
coleção.
LinkedList
É uma lista ordenada pelos índices, como um ArrayList, mas com uma ligação dupla
entre os objetos. É mais indicada quando você precisa fazer muitas inserções ou
remoções da lista.
Set
São conjuntos que se preocupam com unicidade. Set não permite objetos duplicados.
Os principais métodos são: add(Object) e contains(Object).
HashSet
É um conjunto não ordenado e não organizado. Usa o método hashcode() para inserir
o objeto. Use quando você quer guardar objetos não duplicados e não ordenados.
LinkedHashSet
É uma versão ordenada do HashSet que mantém uma ligação dupla entre os objetos.
Você pode construir um LinkedHashSet que mantém a ordem de inserção ou a ordem
62
que os objetos foram acessados. Isso pode ser útil para montar uma lista de objetos
usados mais recentemente.
TreeSet
É uma versão organizada de coleção. Os objetos ficam em uma ordem ascendente, de
acordo com a ordem natural dos objetos.
Map
São coleções que se preocupam com identificadores únicos para os objetos. Você
mapeia uma chave única (o ID) com um valor específico, tanto a chave quanto o valor
são objetos. Os principais métodos são: put(Object key, Object value) e get(Object
key)
HashMap
O HashMap cria uma coleção não ordenada. Permite um valor null na chave e vários
valores null na coleção.
Hashtable
É parecida com um HashMap. O Hashtable é sincronizado e não permite valores
nulos. Prefira um HashMap, se você não precisa se preocupar com acesso de várias
threads.
LinkedHashMap
É uma coleção que mantém a ordem de inserção (ou opcionalmente a ordem de
acesso) dos objetos. O acesso aos objetos é mais rápido que na HashMap.
TreeMap
É uma coleção que mantém os objetos em uma ordem natural dos objetos
Exercício JAVA27
Crie uma classe chamada Agenda que guarde o nome e o telefone de pessoas como
objetos String em um HashMap, adicione 5 nomes e telefones e depois mostre o
telefone de uma das pessoas.
Exercício JAVA28
Cria uma classe chamada Equipes para armazenar nomes de equipes em um
ArrayList. O programa deve pedir para o usuário digitar os nomes das equipes até o
usuário digitar "fim". O programa então mostra os nomes das equipes digitados pelo
usuário.
63
Componentes Gráficos
AWT
Os componentes de AWT estão no pacote de java.awt. Este pacote contém todas
as classes para criação de interfaces com o usuário e para desenho de gráficos e
imagens.
Swing
Os componentes de Swing estão no pacote de javax.swing. Este pacote fornece
também classes para criação de interfaces com o usuário. São um conjunto de
componentes que tem como objetivo prover o mesmo comportamento independente
da plataforma do sistema operacional.
Containers
Containers são espaços criados para conter outros objetos. As classes JFrame e JPanel
são containers do pacote javax.swing.
Frames
Uma frame, implementada como uma instãncia da classe JFrame, é uma janela que
tem decorações como uma borda, um título, e botões para fechar e iconificar a janela.
Exemplo:
public static void main(String s[]) {
JFrame frame = new JFrame("FrameDemo");
frame.addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
frame.getContentPane().add(emptyLabel, BorderLayout.CENTER);
frame.pack();
frame.setVisible(true);
}
Panels
Panels são painéis. A classe JPanel é um container para componentes.
64
Exemplo:
JPanel aPanel = new JPanel();
aPanel.setLayout(new BorderLayout());
Também pode ser declarado assim:
JPanel aPanel = new JPanel(new BorderLayout());
aPanel.add(aComponent);
aPanel.add(anotherComponent);
Gerenciadores de Layout
Gerenciadores de layouts são objetos que controlam a disposição e a dimensão dos
componentes em um container.
FlowLayout
Diferente de outros gerenciadores de layout, o FlowLayout não restringe o tamanho
dos componentes que administra, mas lhes permite ter o tamanho desejado.
O construtor de FlowLayout permitem alinhar os componentes à esquerda ou à
direita.
Você pode especificar espaços entre os componentes se você quiser criar um espaço
mínimo maior.
setLayout(new FlowLayout(int align,int hgap,int vgap));
O valor de align pode ser: FlowLayout.LEFT, FlowLayout.RIGHT, or FlowLayout.
CENTER.
Por exemplo:
setLayout(new FlowLayout(FlowLayout.RIGHT, 20, 40));
Ou
setLayout(new FlowLayout(FlowLayout.LEFT));
Ou simplesmente
setLayout(new FlowLayout());
Exemplo de FlowLayout:
65
getContentPane().setLayout(new FlowLayout());
getContentPane().add(new
getContentPane().add(new
getContentPane().add(new
getContentPane().add(new
getContentPane().add(new
JButton("Button 1"));
JButton("2"));
JButton("Button 3"));
JButton("Long-Named Button 4"));
JButton("Button 5"));
BorderLayout
O gerenciador BorderLayout provê um esquema mais complexo para colocar seus
componentes dentro de um container. BorderLayout contém cinco áreas distintas:
NORTH, SOUTH, EAST, WEST, e CENTER, indicados por BorderLayout.NORTH,
e assim por diante.
NORTH ocupa o topo de uma frame, EAST ocupa o lado direito, e assim por diante.
Quando a janela é redimensionada verticalmente, as regiões EAST, WEST e
CENTER são redimensionados, e quando a janela é redimensionada horizontalmente,
as regiões NORTH, SOUTH e CENTER são redimensionadas.
A seguinte linha:
setLayout(new BorderLayout( ));
constrói e estabelece um BorderLayout novo sem espaços entre os componentes.
A seguinte linha:
setLayout(new BorderLayout(int hgap, int vgap);
constrói e estabelece um BorderLayout com os espaços entre os components
especificados por hgap e vgap.
Você tem que acrescentar componentes as regiões nomeadas no gerenciador
BorderLayout; caso contrário, eles não serão visíveis.
Você pode acrescentar só um único componente a cada uma das cinco regiões de
BorderLayout. Se você tentar acrescentar mais que um, só o último será visível.
Exemplo:
contentPane.add(new JButton("Button 1 (NORTH)"),
BorderLayout.NORTH);
contentPane.add(new JButton("2 (CENTER)"),
66
BorderLayout.CENTER);
contentPane.add(new JButton("Button 3 (WEST)"),
BorderLayout.WEST);
contentPane.add(new JButton("Long-Named Button 4 (SOUTH)"),
BorderLayout.SOUTH);
contentPane.add(new JButton("Button 5 (EAST)"),
BorderLayout.EAST);
GridLayout
O gerenciador GridLayout provê flexibilidade para colocar componentes. Você cria o
gerenciador com vários linhas e colunas.
Como acontece com BorderLayout, a posição relativa dos componentes não muda
quando a área é redimensionada. Só os tamanhos dos componentes.
GridLayout sempre ignora o tamanho dos componentes. A largura de todas as células
é idêntica e é determinado dividindo a largura disponível pelo número de colunas.
Semelhantemente, a altura de todas as células é determinada dividindo a altura
disponível pelo número de linhas.
A ordem na qual são acrescentados componentes ao grid determinam a célula que eles
ocupam. Sempre começam na primeira linha e coluna, até completar as células a
direita. Quando completadas, passa para a segunda linha.
A seguinte linha:
setLayout(new GridLayout( ));
cria e estabelece um GridLayout com apenas uma linha e coluna.
A seguinte linha:
setLayout(new GridLayout(int rows, int cols);
cria e estabelece um GridLayout com um número especifico de linhas e colunas.
A seguinte linha:
setLayout(new GridLayout(int rows, int cols, int hgap, int vgap);
crie e estabelece um GridLayout com um número especifico de linhas e colunas, mas
com espaços horizntais e verticais entre as células determinados por hgap e vgap.
Exemplo:
contentPane.setLayout(new GridLayout(0,2));
// o zero determina que não há um número específico de linhas.
67
contentPane.add(new
contentPane.add(new
contentPane.add(new
contentPane.add(new
contentPane.add(new
JButton("Button 1"));
JButton("2"));
JButton("Button 3"));
JButton("Long-Named Button 4"));
JButton("Button 5"));
CardLayout
O gerenciador CardLayout permite tratar a interface como uma série de cartões, os
quais você pode ver um por vez. Você pode usar o método add( ) para acrescentar
cartões a um CardLayout. O método add( ) recebe um panel e uma String como
argumento que identifica o panel. O método show( ) mostra o cartão que foi
solicitado.
Exemplo:
import java.awt.*;
import java.awt.event.*;
public class CardTest implements MouseListener {
private Panel pl, p2, p3, p4, p5;
private Label lbl, lb2, lb3, lb4, lb5;
private CardLayout mycard;
private Frame f;
public void go( ) {
f = new Frame ("Card Test");
myCard = new CardLayout( );
f.setLayout(myCard);
pl
p2
p3
p4
p5
=
=
=
=
=
new
new
new
new
new
Panel();
Panel();
Panel();
Panel();
Panel();
lbl = new Label("This is the first Panel");
pl.setBackground(Color.yellow);
pl.add(lb1);
lb2 = new Label("This is the second Panel");
p2.setBackground(Color.green);
p2.add(lb2);
lb3 = new Label("This is the third Panel,');
p3.setBackground(Color.magenta);
p3.add(lb3);
lb4 = new Label("This is the fourth Panel");
p4.setBackground(Color.white);
p4.add(lb4);
lb5 = new Label("This is the fifth Panel");
p5.setBackground(Color.cyan);
68
p5.add(lb5);
p1.addmouseListener(this);
p2.addMouseListener(this);
p3.addmouseListener(this);
p4.addMouseListener(this);
p5.addMouseListener(this);
f.add(pl,
f.add(p2,
f.add(p3,
f.add(p4,
f.add(p5,
"First");
"Second");
"Third");
"Fourth");
"Fifth");
myCard.show(f, "First");
f.setSize(200,200);
f.setVisible(true);
}
public void mousePressed(MouseEvent e) {
myCard.next(f);
}
public void mouseReleased(MouseEvent e) { }
public void mouseClicked(MouseEvent e) { }
public void mouseEntered(MouseEvent e) { }
public void mouseExited(MouseEvent e) { }
public static void main (String args[ ]) {
CardTest ct = new CardTest( );
ct.go( );
}
}
Classe JComponent
Com a exceção de containers top-level, todos os componentes de Swing, cujos nomes
começam com "J" descendem da classe de JComponent. Por exemplo, JPanel,
JScrollPane, JButton, e JTable são herdados de JComponent, porém, JFrame não,
porque implementa um container top-level.
A classe JComponent estende a classe Container que estende Component.
JLabel
Com a classe JLabel, você pode exibir textos e imagens.
Exemplo:
69
ImageIcon icon = new ImageIcon("images/middle.gif");
. . .
label1 = new JLabel("Image and Text",icon,JLabel.CENTER);
//Set the position of the text, relative to the icon:
label1.setVerticalTextPosition(JLabel.BOTTOM);
label1.setHorizontalTextPosition(JLabel.CENTER);
label2 = new JLabel("Text-Only Label");
label3 = new JLabel(icon);
//Add labels to the JPanel.
add(label1);
add(label2);
add(label3);
JTextField
Um campo de texto é um controle de texto básico que permite o usuário entrar com
dados. Quando o usuário indica que aquela entrada de texto está completa (teclando
ENTER), o campo de texto gera um evento de ação. Geralmente você usa o
JTextField para prover campos de texto. Se você precisa um campo de senha, ou seja,
um campo de texto que não mostra os caracteres para o usuário, utiliza-se o
JPasswordField.
Exemplo:
textField = new JTextField(20);
textField.addActionListener(this);
...
contentPane.add(textField);
Para ler/alterar o conteúdo de um JTextField use os métodos getText() e
setText(String). Por exemplo, o comando abaixo limpa a caixa de texto:
textField.setText("");
JButton
Provê um mecanismo básico para executar qualquer ação de interface de usuário.
Exemplo:
f = new JFrame("Sample Button");
b = new JButton("Sample");
b.addActionListener(this);
f.add(b);
70
JCheckBox
O componente JCheckbox provê um simples "on/off", colocando um rótulo de texto
ao lado.
Exemplo:
f = new JFrame("Sample Checkbox");
one = new JCheckbox("One", true);
two = new JCheckbox("Two", false);
three = new JCheckbox("Three", false);
one.addItemListener(this);
two.addItemListener(this);
three.addItemListener(this);
f.setLayout(new FlowLayout( ));
f.getContentPane().add(one);
f.getContentPane().add(two);
f.getContentPane().add(three);
JRadioButton
JRadioButton são grupos de botões que, por convenção, só um pode ser selecionado
de cada vez.
Exemplo:
JRadioButton birdButton = new JRadioButton(birdString);
birdButton.setMnemonic(KeyEvent.VK_B);
birdButton.setActionCommand(birdString);
birdButton.setSelected(true);
JRadioButton catButton = new JRadioButton(catString);
catButton.setMnemonic(KeyEvent.VK_C);
catButton.setActionCommand(catString);
JRadioButton dogButton = new JRadioButton(dogString);
dogButton.setMnemonic(KeyEvent.VK_D);
dogButton.setActionCommand(dogString);
JRadioButton rabbitButton = new JRadioButton(rabbitString);
rabbitButton.setMnemonic(KeyEvent.VK_R);
rabbitButton.setActionCommand(rabbitString);
JRadioButton pigButton = new JRadioButton(pigString);
pigButton.setMnemonic(KeyEvent.VK_P);
pigButton.setActionCommand(pigString);
// Group the radio buttons.
ButtonGroup group = new ButtonGroup();
group.add(birdButton);
group.add(catButton);
group.add(dogButton);
group.add(rabbitButton);
group.add(pigButton);
// Register a listener for the radio buttons.
RadioListener myListener = new RadioListener();
71
birdButton.addActionListener(myListener);
catButton.addActionListener(myListener);
dogButton.addActionListener(myListener);
rabbitButton.addActionListener(myListener);
pigButton.addActionListener(myListener);
...
class RadioListener implements ActionListener ... {
public void actionPerformed(ActionEvent e) {
picture.setIcon(new ImageIcon("images/"
+ e.getActionCommand()
+ ".gif"));
}
}
JMenuBar
Um componente JMenuBar é um menu horizontal. Você só pode acrescentar isto a
um objeto JFrame, que sera a base de todos os menus.
JMenu
O componente JMenu provê um menu que lista as suas opções. Você só pode
acrescentar em um JMenuBar ou em outro JMenu.
JMenuItem
Componentes de JMenuItem são os as opções de um JMenu.
Exemplo envolvendo as três definições:
JMenuBar menuBar;
JMenu menu;
JMenuItem menuItem;
...
//Create the menu bar.
menuBar = new JMenuBar();
setJMenuBar(menuBar);
//Build the first menu.
menu = new JMenu("A Menu");
menu.setMnemonic(KeyEvent.VK_A);
menuBar.add(menu);
72
//a group of JMenuItems
menuItem = new JMenuItem("A text-only menu item"
, KeyEvent.VK_T);
menu.add(menuItem);
JComboBox
JComboBox apresenta uma lista de opções para determinada situação.
Exemplo:
String[] weekStrings = { "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday" };
// Create the combo box, select item at index 0.
JComboBox weekList = new JComboBox(weekStrings);
weekList.setSelectedIndex(0);
...
JList
Um JList apresenta ao usuário um grupo de itens, exibidos em uma coluna.
Exemplo:
String[] data = {"one", "two", "free", "four"};
JList dataList = new JList(data);
JList não suporta diretamente scroll. Para isso, faça da seguinte maneira
JScrollPane scrollPane = new JScrollPane(dataList);
JTable
Com a classe JTable você pode exibir tabelas de dados, podendo permiter ao usuário
editar os dados. JTable não contém os dados armazenados; simplesmente é uma visão
de seus dados.
73
Exemplo:
Object [] linha1 = {"Mary", "Campione", "Snowboarding", new
Integer(5), new Boolean(false)};
Object [] linha2 = {"Alison", "Huml", "Rowing", new Integer(3), new
Boolean(true)};
Object [] linha3 = {"Kathy", "Walrath", "Chasing toddlers", new
Integer(2), new Boolean(false)};
Object [] linha4 = {"Mark", "Andrews", "Speed reading", new
Integer(20), new Boolean(true)};
Object [] linha5 = {"Angela", "Lih","Teaching high school", new
Integer(4), new Boolean(false)};
Object[][] data = {linha1,linha2,linha3,linha4,linha5};
String[] columnNames = {"First Name","Last Name","Sport",
"# of Years","Vegetarian"};
final JTable table = new JTable(data, columnNames);
JTree
Com a classe JTree, você pode exibir dados hierárquicos. Um objeto JTree não
contém seus dados de fato; provê uma visão dos dados simplesmente.
Exemplo:
DefaultMutableTreeNode top = new DefaultMutableTreeNode("The Java
Series");
createNodes(top);
final JTree tree = new JTree(top);
...
JScrollPane treeView = new JScrollPane(tree);
Exercício JAVA29
Crie uma calculadora. Defina uma interface GUI com os componentes de uma
calculadora de operações básicas: soma, subtração, multiplicação e divisão.
Exercício JAVA30
Implemente o código java para criar a tela abaixo:
74
Exercício JAVA31
Crie um programa para ser um editor de texto. Use um JTextArea para ser a área de
edição do texto. Crie uma barra de menu com as opções de menu Arquivo e Ajuda.
No menu Arquivo inclua os itens de menu Salvar e Sair. No menu Ajuda inclua o
item Sobre o Editor.
Eventos
O que é um Evento?
Quando o usuário executa uma ação (clica com o mouse ou pressiona uma tecla), isto
causa um evento. Eventos são objetos que descrevem uma ação que aconteceu. Tipos
diferentes de classes de evento existem para descrever categorias diferentes de ações
de usuário.
Fontes de evento
Uma fonte de evento é o gerador de um evento. Por exemplo, ao clicar com o mouse
em um componente Button, isto gera um ActionEvent.
Manipuladores de evento
Um manipulador de evento é um método que recebe um objeto de evento, decifra isto,
e processa a interação do usuário.
Modelo de Delegação
Com o modelo de delegação, os eventos são enviados ao componente, mas cada
componente registra um manipulador de eventos para tratá-los. Os manipuladores de
eventos são chamados Listeners. Listeners podem receber e processar o evento. Deste
modo, o manipulador de evento pode estar em um objeto separado do componente.
Listeners são classes que implementam a interface de EventListener.
Todo evento tem uma interface de listeners correspondentes que define métodos em
uma classe designada a receber aquele tipo de evento. A classe que implementa a
interface define esses métodos, e pode ser registrada como um listener.
75
Não são propagados eventos de componentes que não possui nenhum listener
registrado.
Por exemplo:
import javax.swing.*;
public class ExemploBotao {
public static void main(String args[ ]) {
JFrame f = new JFrame("Teste");
JButton b = new JButton("Pressione Botão!");
b.addActionListener(new ManipuladorBotao( ));
f.add(b,BorderLayout.CENTER);
f.pack( );
f.setVisible(true);
}
}
A classe ManipuladorBotao é a classe manipuladora para qual o evento é delegado.
import java.awt.event.*;
public class ManipuladorBotao implements ActionListener {
public void actionPerfomed(ActionEvent e) {
System.out.println("Ação ocorreu");
System.out.println("Nome do botão: " + e.getActionCommand( ));
}
}
Características do exemplo:
A classe JButton tem um método addActionListener (ActionListener).
A interface de ActionListener define um único método, actionPerfomed que recebe
um ActionEvent.
Quando um objeto de JButton é criado, um objeto pode ser registrado como um
listener para ActionEvent pelo método addActionListener ( ). O listener é instanciado
de uma classe que implementa a interface ActionListener.
Quando o objeto JButton é clicado com o mouse, um ActionEvent é enviado. O
ActionEvent é recebido pelo método actionPerformed( ) de qualquer ActionListener
que é registrado no button pelo seu método de addActionListener.
O método getActionCommand( ) da classe ActionEvent retorna o nome do comando
associado com a ação.
Comportamento de GUI
Categorias de Eventos
Para cada categoria de eventos, há uma interface que tem que ser implementada pela
classe de objetos que recebe os eventos. Essa interface exige que seus métodos sejam
definidos. Esses métodos são chamados quando eventos particulares surgirem.
Abaixo, uma tabela contendo essas interfaces e seus métodos:
76
Categoria
Action
Item
Mouse motion
Nome da Interface
ActionListener
ItemListener
MouseMotionListener
Mouse button
MouseListener
Key
KeyListener
Focus
FocusListener
Adjustment
Component
AdjustmentListener
ComponentListener
Window
WindowListener
Container
ContainerListener
Text
TextListener
Métodos
actionPerformed(ActionEvent)
itemStateChanged(ItemEvent)
mouseDragged(MouseEvent)
mouseMoved(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mouseClicked(MouseEvent)
keyPressed(KeyEvent)
keyReleased(KeyEvent)
keyTyped(KeyEvent)
focusGained(FocusEvent)
focusLost(FocusEvent)
adjustmentValueChanged(AdjustEvent)
componentMoved(ComponentEvent)
componentHidden(ComponentEvent)
componentResized(ComponentEvent)
componentShown(ComponentEvent)
windowClosing(WindowEvent)
windowOpened(WindowEvent)
windowIconified(WindowEvent)
windowDeiconified(WindowEvent)
windowClosed(WindowEvent)
windowActivated(WindowEvent)
windowDeactivated(WindowEvent)
componentAdded(ContainerEvent)
componentRemoved(ContainerEvent)
textValueChanged(TextEvent)
O exemplo abaixo mostra alguns exemplos de interface. Mostra o movimento do
mouse quando é clicado o botão do mouse (mouse dragging).
Os eventos causados pela movimentação do mouse quando um botão é pressionado ou
não, pode ser apanhado por objetos de uma classe que implementam a interface
MouseMotionListener. Esta interface requer dois métodos, mouseDragged ( ) e
mouseMoved ( ). Mesmo que você não irá utilizar o método mouseMoved( ), você
deve declara-lo sem implementar nenhuma instrução.
Para você capturar outros eventos, como o clique do mouse, você tem que utilizar a
interface MouseListener. Esta interface inclui vários métodos como mouseEntered,
mouseExited, mousePressed, mouseReleased, e mouseClicked.
Exemplo:
import java.awt.*;
import java.awt.event.*;
public class Manipuladores implements MouseMotionListener,
MouseListener {
private Frame f;
private TextField tf;
public void go( ) {
77
f = new Frame("Two listeners example");
f.add(new Label ("Click and drag the mouse"),
BorderLayout.NORTH);
tf = new TextField (30);
f.add (tf, BorderLayout.SOUTH);
f.addMouseMotionListener(this);
f.addMouseListener (this);
f.setSize(300, 200);
f.setVisible(true);
}
//Eventos de MouseMotionListener
public void mouseDragged (MouseEvent e) {
String s = "Mouse dragging: X = " + e.getX( ) +
" Y = " + e.getY( );
tf.setText (s);
}
public void mouseMoved (MouseEvent e) { }
//Eventos de MouseListener
public void mouseEntered (MouseEvent e) {
String s = "The mouse entered";
tf.setText (s);
}
public void mouseExited (MouseEvent e) {
String s = "The mouse has left the building";
tf.setText (s);
}
public void mousePressed (MouseEvent e) { }
public void mouseClicked (MouseEvent e) { }
public void mouseReleased (MouseEvent e) { }
public static void main(String args[ ]) {
Manipuladores man = new Manipuladores( );
man.go( );
}
}
Você pode declarar interfaces múltiplas separando-as com vírgula.
Quando você faz chamadas dos seguintes métodos:
f.addMouseListener(this);
f.addMouseMotionListener(this);
ambos os tipos de eventos podem ser chamados na classe Manipuladores. Um objeto
pode escutar tantas fontes de evento quanto exigido; sua classe só precisa
implementar os eventos necessários.
Múltiplos listeners
O modelo de delegação permite que múltiplos listeners possam ser adicionados ao
mesmo componente.
O mecanismo listener permite chamar um método de addXXXListener quantas vezes
forem necessárias, e você pode especificar tantos listeners diferentes quanto precisar.
Todos os listeners registrados têm seus métodos chamados quando o evento
acontecer.
78
Adaptadores de Eventos
É muito trabalhoso implementar todos os métodos de cada interface, principalmentte
da MouseListener e WindowListener.
Por exemplo, a interface MouseListener declara os seguintes métodos:
mouseClicked (MouseEvent)
mouseEntered (MouseEvent)
mouseExited (MouseEvent)
mousePressed (MouseEvent)
mouseReleased (MouseEvent)
Por conveniência, a linguagem Java possui classes de adaptadores que implementam
cada interface que contenha mais de um método. Os métodos nestes classes de
adaptadores estão vazias. Você pode estender uma classe de adaptadores e declarar
somente o(s) método(s) necessários. Exemplo
import java.awt.*;
import java.awt.event.*;
public class MouseClickHandler extends MouseAdapter {
// Só é declarado o método necessário
public void mouseClicked (MouseEvent e) {
//instruções
}
}
Nota – Como MouseAdapter é uma classe, e não uma interface, você só pode estender
uma classe. Como os listeners são interfaces, você pode extender múltiplas interfaces.
Classes anônimas
Você pode incluir uma definição de classe inteira dentro da extensão de uma
expressão. Esta definição é chamada de classe anônima e cria uma instância. Por
exemplo:
import java.awt.*;
import java.awt.event.*;
public class AnonimaExemplo {
private Frame f;
private TextField tf;
public void go( ) {
f = new Frame("Exemplo de classe anonima");
f.add(new Label("Click e arraste o mouse:"),
BorderLayout.NORTH);
tf = new TextField (30);
f.add (tf, BorderLayout.SOUTH);
f.addMouseMotionListener( new MouseMotionAdapter( ) {
public void mouseDragged (MouseEvent e) {
79
String s = "Mouse dragging: X = " + e.getx( ) +
"Y = " + e.getY( );
tf.setText (s);
}
}
); // fechando o parênteses
f.addMouseListener (new MouseClickHandler( ));
f.setSize(300, 200);
f.setVisible(true);
}
public static void main(String args[ ]) {
AnonimaExemplo obj = new AnonimaExemplo ( );
obj.go( );
}
}
Exercício JAVA32
Usando o código da tela criado no exercício JAVA29, escreva o código para tratar os
eventos que façam a calculadora funcionar de acordo com a interface do usuário.
Adicione também o código para tratar o evento de fechar a janela.
Exercício JAVA33
Defina os eventos para a interface da tela Calcula Temperatura do exercício JAVA30.
A fórmula para converter a temperatura é:
Celcius para Fahrenheit
Fahrenheit para Celcius
tempC = (tempF - 32) * 1.8
tempF = (tempC * 1.8) + 32
Exercício JAVA34
Defina os eventos para fechar o editor de texto criado no exercício JAVA31. O evento
para o menu Sobre o Editor deve mostrar uma caixa de dialogo com o seu nome e
email.
Applets
O que é um Applet?
Um applet é uma classe do Java que você pode incluir em uma página de HTML.
Diferente de uma aplicação, que é iniciada quando seu método main ( ) é chamado, o
ciclo de vida de um applet é mais complexo.
Carregando um Applet
Um applet é executado pela JVM do browser quando a página HTML que tem o
applet é carregada. Um arquivo HTML tem que diz ao browser qual classe carregar.
Você então indica ao browser a URL que especifica o arquivo HTML.
http://algumSite/arquivo.html
Browser carrega URL
<HTML>
Browser carrega documento HTML
80
<APPLET CODE = …>
</APPLET>
Applet Classes
Browser carrega classe applet
Browser executa applet
Restrições de Segurança em Applet
Applets podem representam algo perigoso, porque são carregados de qualquer lugar
na internet.
O nível de segurança é controlado e implementado pelo browser (assinatura de
applets, java policies). Por padrão a maioria dos browsers previne o seguinte:
*Execução de runtime de outro programa
*Arquivo I/O
*Chamadas para métodos nativos
*Tentativas para abrir um socket para qualquer sistema, exceto o sistema que proveu
o applet.
Estas restrições impedem um applet de violar a privacidade ou danificar um sistema
remoto, restringindo o acesso do applet aos arquivos do sistema de origem.
Prevenindo a execução de outro programa e desaprovando chamadas a métodos
nativos restringem o applet executar um código que ainda não foi verificado pela
JVM. A restrição em sockets previne comunicação com outro programa armazenado
em um servidor não confiável. Mas estas restrições podem ser modificadas pelo
usuário (java policies).
Escrevendo um Applet
Para escrever um applet, você tem que criar uma classe da seguinte forma:
import java.applet.*;
public class HelloWorld extends Applet { }
A classe do applet deve ser pública. A classe deve ser uma subclasse de
java.applet.Applet.
Os Métodos de um Applet
Em uma aplicação, um programa é iniciado quando o método main( ) é chamado.
Porém, em um applet, este não é o caso. Depois que o construtor completar sua tarefa,
o browser chama o método init ( ) e executa a inicialização básica do applet. Depois
do método init ( ) completar sua tarefa, o browser chama o método start( ).
Mostrando um Applet
Applets são essencialmente gráficos. Assim, embora possa emitir chamadas do tipo
System.out.println( ), você cria sua exibição em um ambiente gráfico.
Você pode utilizar o painel de um applet criando um método paint( ). O método
paint() do applet recebe um objeto que representa a areá gráfica do applet no browser.
81
O browser chama o método paint( ) sempre que a exibição do applet precisa ser
atualizada.
O Método init( )
Esta função é chamada quando o applet é criado e carregado em um browser capaz de
apoiar tecnologia Java. O applet pode usar este método para inicializar valores de
dados. O método init ( ) é executado antes do método start( ) ser chamado.
public void init( ) {
// set up GUI
}
O Método start( )
Uma vez que o método init( ) é completado, o método start( ) é executado. Também é
executado sempre que o applet fica visível, como quando o browser é restabelecido
depois de ser iconificado ou quando o browser volta à página que contém o applet
depois de se mudar para outro URL.
public void start( ) {
musicClip.play( );
}
O Método stop( )
O método stop( ) é chamado quando o applet fica invisível. Isto acontece quando o
browser for iconificado ou segue uma ligação a outro URL. O applet usa este método
para parar qualquer funcionalidade que não deveria ocupar a CPU quando este não
estiver na página do browser atual.
public void stop( ) {
musicClip.stop( );
}
Os métodos start( ) e stop( ) efetivamente formam um par. Tipicamente start( ) ativa
um comportamento em um applet e stop( ) desativa o comportamento.
O Método paint( )
O métod paint( ) leva um argumento que é uma instância da classe java.awt.Graphics.
O argumento sempre é o contexto de gráficos do painel que compõe o applet. Você
pode usar este contexto para trazer ou escrever o seu applet. Exemplo:
import java.awt.*;
import java.applet.*;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("HelloWorld", 25, 25);
}
}
Nota – Os argumentos numéricos no método drawString são coordenadas para o
começo do texto.
82
O Método repaint( )
Uma chamada para o método repaint( ) notifica o sistema que você quer atualizar a
exibição.
O Método update(Graphics g)
O método repaint( ), na verdade causa a chamada o outro método. O métod update( )
normalmente limpa a exibição atual e chama o método paint( ).
Applet Tag
A sintaxe completa para applet Tag é:
<applet
[archive = archiveList]
code = appletFile.class
width = pixels height = pixels
[codebase = codebaseURL]
[alt = alternateText]
[name = appletInstanceName]
[align = alignment]
[vspace = pixels] [hspace = pixels]
>
[<param name = appletAttribute1 value = value>]
[<param name = appletAttribute2 value = value>]
…….
[alternateHTML]
</applet>
Onde
archive = archiveList – Este atributo opcional descreve um ou mais arquivos que
contêm classes e outros recursos que são pré-lidos. As classes são carregadas usando
uma instância de um AppletClassLoader com o codebase. Os arquivos em archiveList
são separados por uma vírgula (,).
code = appletFile.class – Este atributo requerido dá o nome do arquivo que contém a
subclasse Applet compilada. Também pode estar no formato package.appletFile.class.
width = pixels height = pixels – Este atributo requerido atribui valores de altura e
largura para o tamanho da área do applet a ser exibido.
codebase = codebaseURL – Este atributo opcional especifica a URL básico do applet.
O diretório que contém o código do applet. Se este atributo não é especificado, então
a URL do documento é usado.
alt = alternateText – Este atributo opcional especifica qual texto exibir se o browser
pode ler o applet tag, mas não pode executar applets de Java.
name = appletInstanceName – Este atributo opcional especifica um nome para a
intância do applet, que torna possível para applets na mesma página achar um ao
outro.
83
align = alignment – Este atributo opcional especifica o alinhamento do applet. Os
possíveis valores deste atributo são: left, right, top, texttop, middle, absmiddle,
baseline, bottom, e absbottom.
vspace = pixels hspace = pixels – Estes atributos opcionais especificam o número de
pixels acima e abaixo do applet (vspace) e em cada lateral do applet (hspace).
<param name = appletAttribute1 value = value> - Esta tag proporciona para um applet
um valor especifico, servindo com o mesmo propósito de argumentos passados na
linha de comando.
Características Adicionais de Applet
A classe java.net.URL descreve URLs que podem ser usadas para conexão entre elas.
Dois métodos Applet determinam o valor de URLs:
getDocumentBase( ) – retorna um objeto URL que descreve o diretório da página de
browser atual (onde o arquivo HTML com applet tag está gravado).
getCodeBase( ) – retorna um objeto URL que descreve o diretório fonte do próprio
arquivo de classe applet. Freqüentemente é o mesmo do HTML
Lendo Parâmetros
Em um arquivo HTML, a tag < param > em um contexto < applet > pode passar
informação de configuração ao applet. Por exemplo:
<html>
<applet code = DrawAny.class width = 200 height = 200>
<param name = image values = "graphics/duke.gif">
</applet>
</html>
Dentro do applet, você pode usar o método getParameter( ) para ler os valores.
import java.awt.*;
import java.applet.*;
public class DrawAny extends Applet {
Image im;
public void init( ) {
String imageName = getParameter("image");
if (imageName != null) {
im = getImage(getDocumentBase( ), imageName);
}
else {
System.out.println("Error: Cannot find image");
}
}
public void paint(Graphics g) {
if (im != null) {
g.drawImage(im, 0, 0, this);
}
}
}
84
O método getParameter( ) procura pelo nome, e retorna o valor associado como
uma String.
Se o nome do parâmetro não for encontrado em qualquer tag < param > dentro do
contexto < applet></applet >, então getParameter( ) retorna nulo.
O tipo do parâmetro sempre é uma String. Se você precisa isto em outros tipos, você
terá que converter esta String. Exemplo:
int speed = Integer.parseInt(getParameter("speed"));
Applet/Application
import
import
import
import
java.applet.Applet;
java.awt.*;
java.awt.event.*;
java.util.*;
public class AppletApp extends Applet {
Date date;
public void init( ) {
date = new Date( );
}
public void paint (Graphics g) {
g.drawString("This Java program started at ", 25, 25);
g.drawString(date.toString( ), 25, 60);
}
public static void main (String args[ ]) {
Frame frame = new Frame("Application");
AppletApp app = new AppletApp( );
frame.add(app, BorderLayout.CENTER);
frame.setSize(250, 150);
frame.addWindowListener(new WindowAdapter( ) {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
app.init( );
app.start( );
frame.setVisible(true);
}
}
Exemplos
http://java.sun.com/docs/books/tutorial/listofapplets.html
Exercício JAVA35
Faça um applet para calcular a temperatura da mesma forma que foi feito nos
exercícios JAVA30 e JAVA32.
85
Threads
Threads são linhas de execução que rodam durante um processo (aplicação).
Normalmente as threads compartilham regiões de memória. Threads permitem que
sua aplicação execute mais de um método ao mesmo tempo.
Uma Thread possui três partes principais:
*Uma CPU virtual
*O código que a CPU está executando
*Os dados que os códigos estão manipulando
Criando uma Thread
Crie um objeto Thread passando no construtor um argumento que é uma instância de
uma classe que implementa a interface Runnable.
Exemplo:
public class ExemploThread {
int acoes;
public static void main(String args[]) throws Exception {
ExemploThread t = new ExemploThread();
t.executar();
}
void executar() throws Exception {
Monitor m = new Monitor("Pedro",100);
Thread t = new Thread(m);
t.start();
acoes = 50;
while (acoes!=0) {
String v =
javax.swing.JOptionPane.showInputDialog("Valor");
try {
acoes = Integer.parseInt(v);
}catch(NumberFormatException nfe) {
acoes=0;
}
}
System.out.println("Fim");
}
class Monitor implements Runnable {
String nome;
int valor;
public Monitor(String n, int v) {
nome = n;
valor = v;
}
public void run() {
while (acoes!=0) {
if (acoes > valor) {
System.out.println(nome+" está vendendo acoes
por:"+acoes);
acoes--;
} else {
System.out.println(nome+" está comprando acoes
por:"+acoes);
acoes++;
}
86
try {
Thread.sleep(2000);
}catch(InterruptedException ie) {}
}
}
}
}
Primeiro, o método executar( ) gera uma instância m da classe Monitor. O método
start() da Thread começa a executar o método run() da classe que implementa
Runnable. Paralelamente o método executar() continua a sua linha de execução e
entra em um loop while pedindo o valor das ações. O valor das ações está sendo
monitorado pelo outro processo definido no método run() do objeto Monitor.
Iniciando uma Thread
Quando uma thread está pronta para ser executada, você chama seu método start( ). O
método start( ) inicia a thread e então retorna ao processo principal. O método start( )
chama o método run( ) da thread, tornando-a ativa.
Escalonamento de Threads
Java pode rodar em máquinas com multiprocessador ou com um único processador,
com múltiplas threads ou com uma única thread. As threads com prioridade máxima
serão executadas primeiro, e todas as threads com a mesma prioridade obterão algum
tempo do processador. Threads de baixa prioridade também serão executadas.
Uma thread é bloqueada se ela estiver adormecida ou executando qualquer outro
sistema ou função de uma thread que esteja bloqueada. Quando uma thread é
bloqueada, Java escolhe a thread com prioridade máxima em condições de ser
executada.
A prioridade padrão de uma thread é NORM_PRIORITY. Se você atribuir a uma
thread uma prioridade mais baixa que a atual, o sistema poderá permitir que uma
outra thread seja executada. Uma thread só pode implementar uma nova thread de
mesma prioridade ou menor.
Vários métodos estáticos da classe Thread controlam o escalonamento de uma thread
corrente:
sleep(long millis) – deixa a thread, em execução no momento, inativa, por, no
mínimo, o número especificado de milisegundos. Isto não significa que exista garantia
de a thread fique inativa exatamente aquele tempo específico. Outro escalonamento de
thread pode interferir, da mesma forma que o intervalo mínimo e a precisão do relógio
do sistema.
Exemplo:
class Monitor implements Runnable {
String nome;
int valor;
public Monitor(String n, int v) {
87
nome = n;
valor = v;
}
public void run() {
while (acoes!=0) {
if (acoes > valor) {
System.out.println(nome+" está vendendo acoes
por:"+acoes);
acoes--;
} else {
System.out.println(nome+" está comprando acoes
por:"+acoes);
acoes++;
}
try {
Thread.sleep(2000);
}catch(InterruptedException ie) {}
}
}
}
yield( ) – cede a vez da thread em execução no momento, de forma que qualquer
thread em condições de ser executada possa ser executada. O escalonador escolhe a
thread a ser executada.
Finalizando uma Thread
Você pode parar a execução de uma thread usando um flag que indica ao método
run() que ele deve parar. Na classe Monitor quando valor de acoes é igual a zero o
metodo run() para.
Dentro do código, você pode obter uma referência à thread atual usando o método
currentThread. Por exemplo:
public class Exemplo implements Runnable {
public void run( ) {
while(true) {
System.out.println("Thread " + Thread.currentThread( ).
getName( ) + " completed");
}
}
}
Exercício JAVA36
Crie um thread no editor de texto para contar o numero de carateres do texto e atualize
o valor em um campo no rodapé da tela.
Stream I/O e Arquivos
Stream I/O
O I/O no Java é feito em termos de streams. Streams são sequências ordenadas de
dados que possuem uma fonte ou destino .
88
O pacote java.io define classes abstratas para streams de entrada e saída básicos. Estas
classes abstratas são então estendidas para fornecer vários tipos de streams úteis.
Entrada de Dados
Todas as operações de entrada de dados são realizadas por subclasses derivadas das
classes abstratas InputStream e Reader. A classe InputStream faz leitura orientada a
bytes. A classe Reader faz leitura orientada a caracteres.
Métodos Básicos de uma SubClasse de InputStream
int read()
Lê um único byte de dados e retorna o byte que foi lido.
int read(byte[ ])
Lê para um array de bytes. Este método bloqueia até a entrada estar disponível e então
preenche o array com tantos bytes quantos foram lidos.
int read(byte[ ], int ini, int tam)
Lê um subarray de bytes. Preenche o array, começando da posição ini, com o tamanho
tam de bytes, ou até chegar ao final.
Nota – Todos estes três métodos retornam –1 indicando fim de arquivo.
void close( )
Você utiliza este método para encerrar uma leitura ou um fluxo de bytes.
int available( )
Este método informa o número de bytes que estão disponíveis para leitura.
skip(long)
Este método descarta um número especifico de bytes.
Saída de Dados
As operações de saída de dados são realizadas por subclasses derivadas das classes
OutputStream e Writer. A classe OutputStream faz a escrita orientada a bytes e a
classe Writer é orientada a caracteres.
Métodos Básicos de uma SubClasse de OutputStream
void write(int a)
Grava a como um byte. O byte é passado como um int porque ele é muitas vezes o
resultado de uma operação aritmética.
void write(byte[ ])
89
Grava um array de bytes.
void write(byte[ ], int ini, int tam)
Grava parte de um array de bytes, começando em ini e gravando até tam bytes,
parando no final do array se esse for encontrado primeiro.
void close( )
Você utiliza este método para encerrar uma gravação ou um fluxo de bytes.
void flush( )
Descarrega o stream, de forma que quaisquer bytes armazenados em um buffer sejam
lançados para fora do stream ao seu destino.
Classes Streams Úteis
FileInputStream e FileOutputStream
Muitas entradas e saídas em aplicações lêem e gravam dados de arquivos. Os 2
streams que lidam com E/S de arquivo são: FileInputStream e FileOutputStream.
Exemplo:
FileInputStream infile = new FileInputStream("myfile.dat");
FileOutputStream outfile = new FileOutputStream("results.dat");
BufferedInputStream e BufferedOutputStream
Estas classes são frequentemente utilizadas em conjunção com os streams files, para
ajudar a reduzir acessos ao arquivo. Elas "bufferizam" os dados para gravar ou ler
blocos maiores.
DataInputStream e DataOutputStream
Essas interfaces definem métodos para transmitir tipos primitivos Java por meio de
um stream.
Métodos DataInputStream
byte readByte( )
long readLong( )
double readDouble( )
Métodos DataOutputStream
void writeByte(byte)
void writeLong(long)
void writeDouble(double)
90
PipedInputStream e PipedOutputStream
Os piped streams sãp utilizados como pares de entrada/saída. Os bytes gravados em
streams de entrada de um par são aqueles lidos na saída. Os piped streams provêm
uma forma segura de transferência de dados entre 2 threads. Em pares um stream é
para leitura e outro é para gravação.
PipedInputStream inp = new PipedInputStream( );
PipedOutputStream out = new PipedOutputStream( );
URL Input Streams
Além de acesso de arquivo básico, o Java proporciona meios de acessos a objetos na
rede. Você usa um objeto de URL implicitamente ao ter acesso a arquivos de
texto,sons e imagens. Um objeto URL pode ser acessado pelo método
getDocumentBase( ) de um Applet.
String imagefile = new String ("images/Duke/Tl.gif");
images[0] = getImage(getDocumentBase( ), imagefile);
Ou criar a URL direto como um objeto:
java.net.URL imageSource;
try {
imageSource = new URL("http://mysite.com");
} catch (MalformedURLException e) {return;}
images[0] = getImage(imageSource, "images/Duke/Tl.gif");
Abrindo um Input Stream
Você pode abrir um input stream de um objeto URL para ler arquivos do servidor a
partir do documento base (caminho root do webserver).
InputStream is = null;
String datafile = new String("remote/data.txt");
byte buffer[ ] = new byte[24];
try {
is = (new URL(getDocumentBase( ),datafile)).openStream( );
}
catch (Exception e) {
//ignora
}
// O método openStream() do objeto URL retorna o objeto stream para
// ler informação, da mesma maneira que com um objeto
// FileInputStream.
try {
is.read(buffer, 0, buffer.length);
}
catch (IOException el) {
// ignora
}
Readers
91
Lendo uma string do teclado. O objeto InputStreamReader é usado no exemplo e
mostra como ler uma informação do teclado a partir do stream padrão System.in:
import java.io.*;
public class LendoTeclado {
public static void main(String args[ ]) throws IOException {
String s;
InputStreamReader ir;
ir = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(ir);
while ((s = in.readLine( )) != null) {
System.out.println("Read: " + s);
}
}
}
Lendo linhas de um arquivo texto. Use as classes BufferedReader e FileReader para
ler e abrir um arquivo.
import java.io.*;
public class LendoArquivo {
public static void main(String[] args) throws IOException {
FileReader fr;
fr = new FileReader("c:/agenda.txt");
BufferedReader br = new BufferedReader(fr);
String linha = br.readLine();
while (linha != null) {
System.out.println(linha);
linha = br.readLine();
}
br.close();
fr.close();
}
}
Writers
Escrevendo linhas em um arquivo texto. Use as classes FileWriter e PrintWriter para
abrir e escrever um arquivo texto.
import java.io.*;
public class EscrevendoArquivo {
public static void main(String[] args) throws IOException {
FileWriter fw;
fw = new FileWriter("c:/disciplinas/pp/megasena.txt",false);
PrintWriter pw = new PrintWriter(fw);
pw.println("numeros gerados");
for (int i=0; i<6; i++){
long numero = Math.round(Math.random()*60);
System.out.println(String.valueOf(numero));
pw.println(numero);
}
pw.close();
fw.close();
}
}
Código de Página
92
Se você precisa ler um caráter de uma conexão de rede com um tipo diferente de
máquina, você pode construir o InputStreamReader com um código de página
definido:
ir = new InputStreamReader(System.in, "ISO8859-1")
Files
Criando um novo arquivo/pasta
A classe File provê várias utilidades para lidar com arquivos e obter informações
básicas sobre eles.
File myfile;
myfile = new File("mymotd");
myfile = new File("/","mymotd");
File mydir = new File("/");
myfile = new File(myDir, "mymotd");
Nota - Você pode usar um objeto File como argumento no construtor para
FileInputStream e FileOutputStream no lugar de uma String.
Funções de Arquivos
Uma vez você criou um objeto File, você pode usar quaisquer dos métodos seguintes
para colher informação sobre o arquivo:
Os seguintes métodos devolvem informações sobre nome e localização do arquivo:
String getName( )
String getPath( )
String getAbsolutePath( )
String getParent( )
boolean renameTo(File newname)
Os seguintes métodos devolvem informações sobre os atributos do arquivo:
boolean
boolean
boolean
boolean
boolean
boolean
exists( )
canWrite( )
canRead( )
isFile( )
isDirectory( )
isAbsolute( )
Os seguintes métodos devolvem informações gerais do arquivo:
long lastModified( )
long length( )
boolean delete( )
Os seguintes métodos criam e lêem diretórios:
boolean mkdir( )
String[ ] list( )
93
Acessando Arquivos Randomicos
Você tem duas opções para abrir um arquivo de acesso randomico. Passando o nome
do arquivo:
myRAFile = new RandomAccessFile(String name, String mode);
Ou com um objeto File:
myRAFile = new RandomAccessFile(File file, String mode);
O argumento mode determina se você tem acesso somente de leitura ("r") ou acesso
read/write ("rw") para este arquivo. Exemplo:
RandomAccessFile myRAFile;
myFAFile = new RandomAccessFile("db/stock.dbf","rw");
Acessando Informações
long getFilePointer( );
Retorna a localização corrente do ponteiro do arquivo (em bytes) em relação ao início
do arquivo.
void seek(long pos);
Ajusta o ponteiro do arquivo em um posição específica em número de bytes em
relação ao início do arquivo.
long length( );
Retorna o comprimento do arquivo.
Gravando um objeto
Abaixo, um exemplo de como gravar um objeto com um stream:
import java.io.*;
import java.util.Date;
public class SerializeDate {
public SerializeDate( ) {
Date d = new Date( );
try {
FileOutputStream f = new FileOutputStream ("date.ser");
ObjectOutputStream s = new ObjectOutputStream (f);
s.writeObject (d);
s.close( );
}
catch (IOException e) {
e.printStackTrace( );
}
}
public static void main (String args[ ]) {
new SerializeDate( );
}
94
}
Lendo um objeto
Abaixo, um exemplo de como ler um objeto Stream:
import java.io.*;
import java.util.Date;
public class UnSerializeDate {
public UnSerializeDate( ) {
Date d = null;
try {
FileInputStream f = new FileInputStream ("date.ser");
ObjectInputStream s = new ObjectInputStream (f);
d = (Date) s.readObject( );
s.close ( );
}
catch (Exception e) {
e.printStackTrace;
}
System.out.println("Unserialized Date object from date.ser");
System.out.println("Date: " + d);
}
public static void main (String args[ ]) {
new UnSerializeDate( );
}
}
Exercício JAVA37
1. Crie uma aplicação chamada MostraArquivo.java que abra, leia e mostre o
conteúdo de qualquer arquivo texto. Exiba uma mensagem de erro apropriada
quando não puder exibir um arquivo, incluindo as exceções apropriadas.
Exercício JAVA38
2. Crie uma classe que escreve a tabuada de 1 a 10 no arquivo tabuada.txt
conforme layout abaixo:
1x1=1
2x1=2
...
10x1=10
1x2=2
2x2=4
...
10X2=20
...
...
...
...
1X10=10
2X10=20
...
10X10=100
Exercício JAVA39
Inclua a opção para Salvar o conteúdo no editor de texto criado nos exercícios
anteriores
Networking
Sockets
Socket é o nome dado ao ponto final de uma ligação de comunicação entre processos.
Para comunicação entre processos em uma rede, o Java usa os streams. Um socket
deve tratar dois streams: um input stream (fluxo de entrada) e um output stream (fluxo
95
de saída). Um processo envia dados a outro processo pela rede escrevendo no
output stream associado ao socket. Um processo lê os dados de outro processo lendo
do input stream associado ao socket.
Estabelecendo a Conexão
Para estabelecer uma conexão, um processo espera pela conexão de outro processo.
Enviando a Conexão
Ao fazer uma conexão de rede, você precisa saber o endereço IP ou o nome da
máquina remota e o número da porta TCP para a conexão.
Portas TCP/IP
O número de portas do TCP/IP varia de 0-65535. Na prática, números abaixo de 1024
são reservados para serviços pré-definidos, e você não os deveria usar, a menos que
você queira comunicar com um desses serviços como Telnet, Protocolo de Transporte
de Correio Simples (SMTP), ftp, e assim por diante.
Cliente e servidor têm que concordar com antecedência em que porta irão se
comunicar. Se os números de portas usadas pelas duas partes do sistema não
concordarem, nenhuma comunicação será efetivada.
Servidor de TCP/IP
Abaixo, um exemplo de um servidor para comunicação TCP/IP:
import java.net.*;
import java.io.*;
public class SimpleServer {
public static void main(String args[ ]) {
ServerSocket servidor = null;
Socket conexao;
OutputStream out;
DataOutputStream dos;
//Registra a porta 5432
try {
servidor = new ServerSocket(5432);
}
catch (IOException e) {
//ignora
}
while (true) {
try {
conexao=servidor.accept( );
out = conexao.getOutputStream( )
dos = new DataOutputStream (out);
dos.writeUTF("Hello Net World!");
dos.close( );
out.close( );
conexao.close( );
}
catch (IOException e) {
//ignora
}
}
}
96
}
Cliente de TCP/IP
Abaixo, um exemplo de um aplicação cliente para comunicação TCP/IP:
import java.net.*,
import java.io.*;
public class SimpleClient {
public static void main(String args[ ])
throws IOException {
Socket conexao;
InputStream in;
DataInputStream dis;
conexao = new Socket ("127.0.0.1", 5432)
in = conexao.getInputStream( );
dis = new DataInputStream(in);
String st = new String (dis.readUTF( ));
System.out.println(st);
dis.close( );
in.close( );
conexao.close( );
}
}
Exercício JAVA40
1. Desenvolva uma aplicação que permita o servidor receber o nome de um arquivo
do cliente, tentar abrí-lo e retorná-lo ao cliente através de um socket. O programa
cliente pede o nome do arquivo ao usuário e envia ao servidor, e então espera o
servidor enviar uma mensagem de erro ou o próprio arquivo.
JDBC "Driver"
Um JDBC "Driver" é uma coleção de classes que implementam as interfaces de JDBC
exigidas para conectar um programa Java com um banco de dados. Cada driver de
banco de dados tem que prover uma classe que implementa a interface
java.sql.Driver. Esta classe é então registrada pela classe java.sql.DriverManager para
se conectar a um banco de dados.
Os drivers JDBC possuem quatro categorias:
JDBC-ODBC - provê acesso por um driver ODBC.
Native-API - converte chamadas JDBC em chamadas no programa cliente para
Oracle, Sybase, Informix, DB2, ou outro DBMS. Requer que algum código binário
esteja instalado na máquina do cliente.
Net-Protocol - traduz chamadas JDBC para um protocolo DBMS independente, que é
traduzido então para um protocolo de DBMS específico.
Native-Protocol – As chamadas JDBC acessam o banco de dados direto como um
cliente .
97
Pacote java.sql
Interfaces do JDBC
Driver - interface que toda classe de driver tem que implementar.
Connection – é uma conexão com um banco de dados específico. Dentro do contexto
de uma conexão, são executadas declarações SQL e devolvidos resultados
Statement – é o objeto usado para executar uma declaração SQL e obter os resultados
produzido por isto.
PreparedStatement – é um objeto que representa uma declaração precompilada de
SQL.
CallableStatement – é uma interface que executa procedimentos SQL.
ResultSet - um ResultSet provê acesso a um conjunto de dados. Um objeto ResultSet
normalmente é gerado executando uma Statement.
ResultSetMetaData – é um objeto que pode ser usado para ter acesso aos tipos e
propriedades das colunas de um ResultSet.
DatabaseMetaData – retorna informações sobre o banco de dados como um todo.
Estas interfaces permitem ao programador abrir conexões com o banco de dados,
executar instruções SQL e processar os resultados.
Uma String URL é passada ao método getConnection ( ) do DriverManager, que
devolve um driver para a conexão.
Com o driver, você obtem uma conexão.
Com a conexão, você pode criar um Statement ou PreparedStatement.
Quando uma Statement é executada com um método executeQuery ( ), um ResultSet é
devolvido.
Registrando um driver JDBC
Quando a JVM carrega uma classe de um driver JDBC, o próprio driver se registra na
classe DriverManager. Abaixo temos exemplos de dois drivers, um para acesso
ODBC e outro para acesso ao banco FireBird ou InterBase.
// acesso ODBC
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// acesso Firebird
Class.forName("org.firebirdsql.jdbc.FBDriver");
98
Nota – Ao se tentar registrar um driver, isto pode retornar um exceção
(ClassNotFoundException). Para isso, sempre utilize blocos try e catch para capturar
esta exceção
Criando uma conexão
Após você ter registrado um driver para a classe DriverManager, você precisa criar
uma conexão utilizando este drive. Para isso, utiliza-se o método getConnection( ).
Connection con = DriverManager.getConnection(URL, username,
password);
Exemplo 1: Acessando o link ODBC chamado Empresa
String url = "jdbc:odbc:Empresa";
Connection con = DriverManager.getConnection(url,"sa","sa");
Exemplo 2: Acessando o banco CAMPEONATO.GDB do FireBird na máquina local
String url = "jdbc:firebirdsql:localhost/3050:C:/CAMPEONATO.GDB";
Connection con = DriverManager.getConnection(
url,"sysdba","masterkey");
Criando uma instrução SQL
Para poder executar qualquer instrução SQL no banco, pode-se utilizar duas
interfaces: Statement ou PreparedStatement. Para a interface Statement, você utiliza o
método createStatement, enquanto para a interface PreparedStatement, utiliza-se o
método prepareStatement. A diferença entre as duas é que com a segunda interface
você pode utilizar instruções em SQL dinâmico.
Exemplo:
String sql = "SELECT NOME FROM CLIENTE WHERE CODIGO = 999";
Statement instrucao = con.createStatement();
ResultSet resultado = instrucao.executeQuery(sql);
Ou
String sql = "SELECT NOME FROM CLIENTE WHERE CODIGO = ?";
PreparedStatement instrucao = con.prepareStatement(sql);
instrucao.setInt(1,999); // susbtitui o ? pelo valor 999
ResultSet resultado = instrucao.executeQuery();
Quando uma instrução SQL for retornar dados, você utiliza o método executeQuery().
Para atualizar dados no banco de dados, você utiliza o método executeUpdate().
Recebendo dados do banco
O método executeQuery( ) gera um ResulSet. O ResultSet é o resultado que possui a
linha ou as linhas retornadas pela instrução SQL. Abaixo, um exemplo de como
manipular o ResultSet e mostrar os dados retornados.
Exemplo:
99
String sql = "SELECT NOME, IDADE FROM CLIENTE WHERE CODIGO = ?"
PreparedStatement instrucao = con.prepareStatement(sql);
// O comando setInt substitui o ? pelo valor 998. Como o valor é
// um int, utiliza-se setInt.
instrucao.setInt(1, 998);
//Recebe os dados
ResultSet resultado = instrucao.executeQuery( );
while(resultado.next( )) {
//Para acessar os dados do ResulSet, use os métodos getXXX
System.out.println("Nome: " + resultado.getString("NOME" ));
System.out.println("Idade: " + resultado.getInt("IDADE" ));
}
Enviando dados ao banco
Para enviar dados ou atualizar informações em um banco, utiliza-se o método
executeUpdate( ). Para enviar dados:
//Salvando novos dados
String sql = "INSERT INTO FUNCIONARIO VALUES (?,?,?,?,?,?,?,?,?)";
PreparedStatement instrucao = con.prepareStatement(sql);
// Passando os valores
instrucao.setInt(1,id);
instrucao.setString(2,nome);
instrucao.setString(3,endereco);
instrucao.setString(4,bairro);
instrucao.setString(5,cep);
instrucao.setString(6,cidade);
instrucao.setString(7,estado);
instrucao.executeUpdate();
Para atualizar informações:
//Alterando dados
String sql = "UPDATE FUNCIONARIO SET NOME=?, ENDERECO=?,"BAIRRO=?,
CEP=?, CIDADE=?, ESTADO=? WHERE ID=?";
PreparedStatement instrucao = con.prepareStatement(sql);
//Passando os valores
instrucao.setString(1,nome);
instrucao.setString(2,endereco);
instrucao.setString(3,bairro);
instrucao.setString(4,cep);
instrucao.setString(5,cidade);
instrucao.setString(6,estado);
instrucao.setInt(7,id);
instrucao.executeUpdate();
Datas para SQL
Existem duas classes Date no java uma no pacote java.util e outra no pacote java.sql.
Para converter um objeto Date para gravar no banco use o código exemplo abaixo:
java.util.Date hoje = new java.util.Date();
100
java.sql.Date hojeSQL = new java.sql.Date(hoje.getTime());
Tabela de métodos setXXX
Método
setASCIIStream
setBigDecimal
setBinaryStream
setBoolean
setByte
setBytes
setDate
setDouble
setFloat
setInt
setLong
setNull
setObject
setShort
setString
setTime
setTimestamp
setUnicodeStream
SQL Types
Uses an ASCII stream to produce a
LONGVARCHAR
NUMERIC
LONGVARBINARY
BIT
TINYINT
VARBINARY or LONGVARBINARY
DATE
DOUBLE
FLOAT
INTEGER
BIGINT
NULL
The given Java object is converted to the
target SQLType before being sent
SMALLINT
VARCHAR or LONGVARCHAR
TIME
TIMESTAMP
UNICODE
Tabela de métodos getXXX
Method
getASCIIStream
getBigDecimal
getBinaryStream
getBoolean
getByte
getBytes
getDate
getDouble
getFloat
getInt
getLong
getObject
getShort
getString
getTime
getTimestamp
getUnicodeStream
Exercício JAVA41
Java Type Returned
java.io.InputStream
java.math.BigDecimal
java.io.InputStream
boolean
byte
byte[ ]
java.sql.Date
double
float
int
long
Object
short
java.lang.String
java.sql.Time
java.sql.Timestamp
java.io.InputStream
101
1.Faça um programa para ler a tabela AGENDAFONE . O usuário informa um
nome e a classe mostra os números dos telefones. Use o script abaixo para criar a
tabela no banco do Firebird
CREATE TABLE AGENDAFONE (
CODIGO
INTEGER NOT NULL,
NOME
VARCHAR(100) NOT NULL,
FONE1
VARCHAR(20) NOT NULL,
FONE2
VARCHAR(20),
FONE3
VARCHAR(20),
ULTATUALIZACAO DATE
);
ALTER TABLE AGENDAFONE ADD CONSTRAINT PK_AGENDAFONE PRIMARY KEY (CODIGO);
CREATE UNIQUE INDEX AGENDAFONE_IDX1 ON AGENDAFONE (NOME);