Академический Документы
Профессиональный Документы
Культура Документы
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 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
Compilada
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
Suporta Concorrência
Java fornece facilidades para programação com sockets, remote method call, TCP-IP,
etc.
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.
Carregador de Classes
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:
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 4 ilustra a chamada do método println para o atributo out da classe ou objeto
System.
Compilando
javac AloMundo.java
Executando
java AloMundo
AloMundo!
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.
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
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.
Ponto-e-vírgulas, Blocos
totals = a + b + c;
/ / declarando um bloco
{
x = y + 1;
y = x + 1;
}
Palavras-Chave do Java
Lógico – boolean
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.
Os caracteres aparecem entre aspas simples (‘x’). Um caracter é uma única letra,
número, sinal de pontuação ou outro símbolo.
As strings aparecem entre aspas duplas ("oi"). Uma string é um grupo de caracteres.
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.
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;
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 / *... * /.
Variáveis
class ClasseExemplo {
// variável da classe
int i;
16
} //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 0
Short 0
Int 0
Long 0L
Float 0.0F
Double 0.0D
Char ‘\u0000’ (NULL)
boolean false
All reference types null
Operadores
pós-fixados . [ ] ( ) ; ,
Unários ++ -- + - ~ ! (data type)
Multiplicativos * / %
Aditivos + -
deslocamentos << >> >>>
17
relacionais < > <= >= instanceof
igualdade == !=
AND(E) bit a bit &
XOR(ou exclusivo) ^
OR (ou inclusivo) |
AND(E) lógico &&
OR(OU) lógico ||
condicional ?:
atribuição = *= /= %= += -= <<= >>= >>>=
&= ^= |=
Expressões Lógicas
int i = 1;
if (i) i++; // gera um erro de compilação
if (i!=0) i--; // correto
O resultado é:
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.
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.
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.
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)
Instruções
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");
}
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.
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ção for
A sintaxe de for é:
Nota – O java permite o utilizar a vírgula como separador dentro de estrutura for( ).
Por exemplo,
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");
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);
loop:
do {
instrução;
do {
instrução;
instrução;
22
if (boolean expression)
break loop;
} while (boolean expression);
instrução;
} while (boolean expression);
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
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
Exercício JAVA5
Exercício JAVA6
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;
}
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:
int dia;
int mes;
int ano;
Em um código, a declaração.
MinhaData hoje;
hoje ????
hoje ????
dia 0
0
mes
0
ano
MinhaData hoje;
hoje = new MinhaData( );
hoje 0x01abcdef
dia 0
0
mes
0
ano
25
Tipos de Referência
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
"Hello"
t 0x03abefcd
t = "World";
x 0x01abcdef
y 0x02defabc
“Hello”
s 0x03abefcd
“World”
t 0x04cdefab
Exercício JAVA7
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.
26
Arrays
Declarando Arrays
char s [];
Ponto p[]; // Ponto é uma classe
char [] s;
Ponto [] p;
Criando Arrays
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:
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.
int numeros[];
numeros = new int[2];
numeros[0]=34;
numeros[1]=71;
Arrays Multi-Dimensionais
Exemplo:
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.
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.
Redimensionando um Array
28
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:
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);
Ordenando Arrays
Exemplo
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.
29
Exercício JAVA9
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
Classes e Objetos
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.
class EmpregadoInfo {
String nome;
String cargo;
String departamento;
}
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 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;
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( );
Você pode criar uma associação entre o tipo Data e o método mudeParaAmanha( ):
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
31
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.
Definindo Métodos
Exemplos:
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,
A cláusula throws < exception > é declarada para testar qualquer erro durante a
execução do método.
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.
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:
Em outra classe
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.
Em outra classe
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:
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:
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.
35
Exercício JAVA11
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.
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.
36
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.
Pacotes
Você pode indicar que um arquivo fonte pertence a um pacote particular usando a
declaração package. Por exemplo:
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:
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 (Unix)
path\abc\financeiro (Windows)
Exercício JAVA13
Redefina a classe Lampada com um construtor que cria uma lampada no estado aceso
(boleano igual a true).
Exercício JAVA14
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?
38
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.
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.
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.
Herança Simples
39
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.
Embora a subclasse herde todos os métodos e variáveis de uma classe pai, a subclasse
não herda seus construtores.
Polimorfismo
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();
A linguagem Java, permite referênciar um objeto com uma variável que é um dos
tipos da classe pai. Assim você pode dizer:
Coleções Heterogêneas
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
}
O Operador instanceof
Muitas vezes, você pode querer saber se um determinado objeto é de uma outra
classe. Para tal, você utiliza o operador instanceof.
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:
Convertendo Objetos
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.
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.
Na 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.
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.
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 Empregado(String n) {
nome = n;
}
}
Exercício JAVA16
Exercício JAVA17
Características da Linguagem
À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 Carro( ) {
contadorObjetos ++;
serialNumber = contadorObjetos;
}
}
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.
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:
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.
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.
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.
static {
System.out.println("Codigo estatico: i = " + 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.
Por exemplo:
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:
A orientação a objetos é ilustrada pelo fato que ambos os objetos têm dados
separados, embora ambos sejam carros.
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.
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:
Classes Abstratas
48
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.
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.
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.
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.
49
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.
Quando uma classe estende uma interface, esta classe deverá implementar todos os
métodos da interface, ou simplesmente declará-los sem nenhuma implementação.
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:
O exemplo seguinte mostra uma interface simples e uma classe que implementa isto:
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
50
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
sobre quais valores eles irão utilizar ou o que acontecerá quando os valores ou
métodos forem alterados.
Exemplo
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.
Exemplo:
class Ponto {
int x,y;
Resultado:
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.
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 + ")";
}
52
}
Classes Internas
import java.awt.*;
import java.awt.event.*;
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);
}
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.
53
Exemplo:
ou
Exercício JAVA23
Exceções
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.
Sintaxe:
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:
Exemplo
Instrução throw
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.
56
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
A segunda maneira é lançar a exceção para a classe que executou o método, utilizando
para isso a cláusula throws.
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.
Para lançar uma exceção para a classe que você criou, use a sintaxe:
Por exemplo:
Exercício JAVA24
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
Calendar c = Calendar.getInstance();
58
Formatando Datas
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;
try {
Date nascimento = sdf.parse("16/06/1971");
System.out.println("Meu nascimento foi " + nascimento);
} catch (Exception e) {
System.out.println("Data invalida");
}
Exercício JAVA26
Faça uma classe que mostre a data atual menos 7 dias no formato dd-MM-yyyy.
Coleções
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.
Hashcode 1 2 3 4
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).
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());
}
}
}
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());
}
}
}
61
Sabendo a diferença entre ordenado e organizado, vamos ver as interfaces List, Set e
Map.
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.
int t = numerosDaMega.size();
numerosDaMega.add(new Integer(3));
Integer n = numerosDaMega.get(0);
Vector
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).
62
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
que os objetos foram acessados. Isso pode ser útil para montar uma lista de objetos
usados mais recentemente.
TreeSet
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
LinkedHashMap
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.
63
Exercício JAVA28
Componentes Gráficos
AWT
Swing
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:
frame.addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
frame.getContentPane().add(emptyLabel, BorderLayout.CENTER);
64
frame.pack();
frame.setVisible(true);
}
Panels
Exemplo:
Gerenciadores de Layout
FlowLayout
Você pode especificar espaços entre os componentes se você quiser criar um espaço
mínimo maior.
Por exemplo:
setLayout(new FlowLayout(FlowLayout.LEFT));
Ou simplesmente
setLayout(new FlowLayout());
Exemplo de FlowLayout:
getContentPane().setLayout(new FlowLayout());
BorderLayout
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:
A seguinte linha:
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:
GridLayout
Como acontece com BorderLayout, a posição relativa dos componentes não muda
quando a área é redimensionada. Só os tamanhos dos componentes.
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:
A seguinte linha:
A seguinte linha:
Exemplo:
contentPane.setLayout(new GridLayout(0,2));
// o zero determina que não há um número específico de linhas.
CardLayout
Exemplo:
import java.awt.*;
import java.awt.event.*;
pl = new Panel();
p2 = new Panel();
p3 = new Panel();
p4 = new Panel();
p5 = new Panel();
p1.addmouseListener(this);
p2.addMouseListener(this);
p3.addmouseListener(this);
p4.addMouseListener(this);
p5.addMouseListener(this);
f.add(pl, "First");
f.add(p2, "Second");
f.add(p3, "Third");
f.add(p4, "Fourth");
f.add(p5, "Fifth");
myCard.show(f, "First");
f.setSize(200,200);
f.setVisible(true);
}
Classe JComponent
Exemplo:
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:
JButton
Exemplo:
JCheckBox
Exemplo:
one.addItemListener(this);
two.addItemListener(this);
three.addItemListener(this);
JRadioButton
JRadioButton são grupos de botões que, por convenção, só um pode ser selecionado
de cada vez.
Exemplo:
JMenuBar
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
72
Componentes de JMenuItem são os as opções de um JMenu.
JMenuBar menuBar;
JMenu menu;
JMenuItem menuItem;
...
//Create the menu bar.
menuBar = new JMenuBar();
setJMenuBar(menuBar);
JComboBox
Exemplo:
JList
Exemplo:
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.
Exemplo:
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:
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
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
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.
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);
}
}
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:
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:
Exemplo:
import java.awt.*;
import java.awt.event.*;
//Eventos de MouseListener
public void mouseEntered (MouseEvent e) {
String s = "The mouse entered";
tf.setText (s);
}
Múltiplos listeners
Adaptadores de Eventos
mouseClicked (MouseEvent)
mouseEntered (MouseEvent)
mouseExited (MouseEvent)
mousePressed (MouseEvent)
mouseReleased (MouseEvent)
import java.awt.*;
import java.awt.event.*;
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
79
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);
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
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.
80
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.
Applets podem representam algo perigoso, porque são carregados de qualquer lugar
na internet.
Escrevendo um Applet
Para escrever um applet, você tem que criar uma classe da seguinte forma:
import java.applet.*;
public class HelloWorld extends Applet { }
81
A classe do applet deve ser pública. A classe deve ser uma subclasse de
java.applet.Applet.
Os Métodos de um Applet
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.
O Método init( )
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.
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.
O Método paint( )
import java.awt.*;
import java.applet.*;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("HelloWorld", 25, 25);
}
}
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)
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
width = pixels height = pixels – Este atributo requerido atribui valores de altura e
largura para o tamanho da área do applet a ser exibido.
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.
<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.
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:
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.*;
84
import java.applet.*;
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:
Applet/Application
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
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.
Threads
Exemplo:
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
Exemplo:
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:
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
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.
int read()
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.
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.
89
skip(long)
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.
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[ ])
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( )
FileInputStream e FileOutputStream
Exemplo:
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.
90
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)
PipedInputStream e PipedOutputStream
java.net.URL imageSource;
try {
imageSource = new URL("http://mysite.com");
} catch (MalformedURLException e) {return;}
images[0] = getImage(imageSource, "images/Duke/Tl.gif");
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( );
91
}
catch (Exception e) {
//ignora
}
try {
is.read(buffer, 0, buffer.length);
}
catch (IOException el) {
// ignora
}
Readers
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);
}
}
}
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
import java.io.*;
public class EscrevendoArquivo {
92
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
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:
Files
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");
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:
boolean exists( )
93
boolean canWrite( )
boolean canRead( )
boolean isFile( )
boolean isDirectory( )
boolean isAbsolute( )
long lastModified( )
long length( )
boolean delete( )
boolean mkdir( )
String[ ] list( )
Você tem duas opções para abrir um arquivo de acesso randomico. Passando o nome
do arquivo:
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( );
long length( );
Gravando um objeto
import java.io.*;
import java.util.Date;
94
s.close( );
}
catch (IOException e) {
e.printStackTrace( );
}
}
public static void main (String args[ ]) {
new SerializeDate( );
}
}
Lendo um objeto
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
Exercício JAVA38
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
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
Portas TCP/IP
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
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);
96
}
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
}
}
}
}
Cliente de 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
JDBC "Driver"
Pacote java.sql
Interfaces do JDBC
Statement – é o objeto usado para executar uma declaração SQL e obter os resultados
produzido por isto.
ResultSetMetaData – é um objeto que pode ser usado para ter acesso aos tipos e
propriedades das colunas de um ResultSet.
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");
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( ).
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:
Ou
99
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().
Exemplo:
String sql = "SELECT NOME, IDADE FROM CLIENTE WHERE CODIGO = ?"
PreparedStatement instrucao = con.prepareStatement(sql);
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" ));
}
// 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();
//Alterando dados
String sql = "UPDATE FUNCIONARIO SET NOME=?, ENDERECO=?,"BAIRRO=?,
CEP=?, CIDADE=?, ESTADO=? WHERE ID=?";
PreparedStatement instrucao = con.prepareStatement(sql);
100
//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();
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:
Exercício JAVA41