Programação Orientada a A Disciplina

Objetos Utilizando Java

! Apresentação de conceitos e teorias
! Exemplos práticos
! Programação em sala de aula
Pedro de Alcântara dos Santos Neto ! Tarefas de casa
e-mail: [email protected] ! Pontualidade

1 2

Avaliação Relevância e Motivação

! Trabalhos práticos ! Técnicas a serem utilizadas na prática

» Alguns trabalhos individuais ! Desenvolver software de qualidade
» Um trabalho sobre conceitos básicos de ! Impacto econômico e social
POO
» Um trabalho sobre POO e BD
! Prova final com tema prático sobre Java

4 5

1
 Objetivos Qualidade do Software
! Discutir aspectos de qualidade e
modularidade de software
! Impacto Econômico e Social
» Segurança de pessoas
! Introduzir conceitos de POO e Java
» Disponibilidade de serviços essenciais
! Indicar como programas em Java podem
» Competitividade: produtores/consumidores
ser adequadamente escritos e
estruturados » Melhores produtos a um menor custo
! Utilizar ambientes de programação em
Java
! Desenvolver uma aplicação de médio
porte

6 7

Programação Programação Orientada a Objetos

record Pessoa
nome : string; ! Foco nos dados (objetos) do sistema,
idade : integer;
end não nas funções
procedure aniversario ! Estruturação do programa é baseada
begin nos dados, não nas funções
.....
! As funções mudam mais do que os
dados
nome idade nascimento
abstração
Pedro 25 14/11/1974 formalização

8 9

2
 Objeto Conta Bancária
Estados do Objeto Conta

Crédito
Crédito
Crédito Crédito(20) Crédito
Crédito

Saldo Número Saldo Número

Saldo Número Saldo Número Saldo Número
875,32 21.342-7 895,32 21.342-7
875,32 21.342-7 875,32 21.342-7
875,32 21.342-7

Débito Débito
Débito Débito

Débito

10 11

Histórico de JAVA Uma Linguagem Moderna

! Iniciou como uma linguagem de ! Java

programação para equipamentos » “Java é uma linguagem simples, orientada
eletrônicos (microondas, PDA´s, ...) a objetos, distribuída, interpretada,
! Inicialmente denominada OAK robusta, segura, independente de
arquitetura, portável, de alto
» Pequena, confiável e portável
desempenho, suportando multithreads e
! Ideal para a Internet ! dinâmica.”
! Sua afirmação se deu com o Sun Microsystems, 1995
surgimento do HotJava

12 13

3
 Java é Simples Java Eliminou...

! Sintaxe familiar a vários programadores ! Variáveis e funções globais

(baseada em C e C++) ! Ponteiros
! Elimina várias redundâncias de C++ ! goto, struct e union
! Simples para algumas aplicações, ! Número variável de argumentos
desde que se conheça alguns pacotes ! Tipos fracos
! Simples dado tudo que a linguagem ! Remoção de objetos
oferece
! Classes parametrizadas!

14 15

Java é Orientada a Objetos Implementações de Java

! Objetos e Classes ! Interpretada

! Encapsulamento de dados e operações » Bytecodes da JVM
! Subtipos e Herança » Independente de plataforma
! Polimorfismo ! Compilada
! Ligações dinâmicas (dynamic binding) » Código nativo em C ou C++
! Alta performance?
! Criação e remoção dinâmica de objetos

16 17

4
 Java é Portável Java é Distribuída

! Em tese, redução de custos com ! Oferece suporte de alto nível para

migração, instalação, treinamento, etc. acesso a Internet / WWW (pacote
! Na prática, ainda é necessário depurar java.net)
programas antes de migrar para outra ! Objetos distribuídos com RMI e CORBA
plataforma ! Suporte para acesso a arquivos
remotos, banco de dados, etc.

18 19

Java é Robusta Programa em Java

! Ausência de ponteiros ! Formado por 3 elementos

! Fortemente tipada » Declaração de Pacotes
» Utilização de “imports”
! Coleta de lixo automática » Definições de classes
! Exceções tipadas ! O Programa HelloWorld
! Acesso a arrays é verificado class HelloWorld {
public static void main (String args[]){
! Variáveis são inicializadas
System.out.println(“Hello World!”);
automaticamente }

20 21

5
 Compilando e Executando Compilando e Executando

! Compilação: ! Use uma IDE

» javac NomedaClasse.java » Eclipse (recomendado)
» Geração de um arquivo .class » NetBeans
! Execução:
» java NomedaClasse Argumentos
! Execução de um Applet:
» appletviewer ArquivoHtml.html

22 23

Palavras Chaves Identificadores

abstract, boolean, break, byte, case, catch, ! Nomear variáveis, métodos, classes e
char, class, const, continue, defalt, do , labels.
double, else, extends, false, final, finally, float,
for, goto, if, implements, import, intanceof, int, ! Não pode ser palavra reservada e deve
interface, long, native, new, null, package, iniciar com letra, $ ou _.
private, protected, public, return, short, static, » louco // válido
super, switch, syncronized, this, throw, » intGrande // válido
throws, transient, true, try, void, volatile, while
» $valor1 // válido
» 3_variavel // inválido
» !verdade // inválido

24 25

6
 Tipos de Dados Primitivos Tipos de Dados Primitivos

! Tipos Numéricos: ! Caracteres e Cadeias (strings)

» byte bt = 100; // -128..+127 » char ch = “a”; // caracter
» short st = -4; // -32768..+32767 » char ch1 = 48 // caracter “a”
» int it = 10; // -231..+231-1 » Integer val = “a”; // caracter com int
» long lg = 300L; // -263..+263-1 » String st = “Tipo”; // cadeia de carac.
» float ft = 2.5; // 32bit » char hx = 0xA; // valor hexadec 10
» double db = 6.5e10; // 64bit » String b = “Hello Java!\n”; // ?
» String c = “Falaram \”Hello Java!\””; // ?

26 27

Tipos de Dados Primitivos Tipos de Dados Primitivos

! Códigos de escape para caracteres ! Tipo boolean
» \b backspace » boolean souGrande=true;
» \f formfeed
» boolean verdadefalsa=false;
» \n newline
» \r car return ! Matrizes
» \t tab » Declaração (int inteiros[]; double d[];)
» \\ \ » Construção (inteiros=new int[5];)
» \’ ‘ » Inicialização
» \” “ • inteiros[1]=1; inteiros[2]=2;
» \xhh hexadecimal

28 29

7
 Operadores Matemáticos Operadores Comparativos
»+ a=a+1 adição » == if (a==3) {...} Igual
»- b=b-1 subtração » != if (a!=5) {...} não igual
»* c=c*2 multiplicação »< t = a < b; menor
»/ d=d/4 divisão »> x = a > b; maior
»% e=e%2 resto » <= if (a<=b) {...} menor igual
»- f=-f negação » >= j = ~a >= b; maior igual
» ++ a++ incremento » && if (a=0 && b=2) AND
» -- b-- decremento » || if (a<3 || c>=5) OR

30 31

Exercício em Sala Operadores Binários

»~ a=~a; complemento binário
! Crie um pequeno programa em Java
»& a=a&0x22; AND
para testar as expressões anteriores,
»| a=a|b; OR
utilizando as variáveis a e b, com
»^ a=a^b; XOR
valores 3 e 6, respectivamente. » << a=<<a; deslocamento esquerda
» >> a=a<<2; deslocamento direita
! Exercício em Sala
» Faça um pequeno programa em Java para
testar o funcionamento dos operadores
binários

32 33

8
 O Operador Ternário (?) Fluxo de Controle (if .. else)
! O Operador Ternário (?) class TernarioComIf {
» a = x ? b : c; public static void main(String args[]) {
class Ternario { short v1 = 10, short v2 = 5, menor=0;
public static void main(String args[]) { if(v1<v2)
short v1 = 10; menor=v1;
short v2 = 5; else
short menor; menor=v2;
menor = (v1 < v2)? v1 : v2;
System.out.println(menor);
System.out.println(menor);
}
}
} }

34 35

Switch (teste de múltipla escolha) Enquanto (While)

class SwitchApp { class Whileapp {
public static void main(String args[]) throws Exception{ public static void main(String args[]) throws Exception{
System.out.println(“Tecle opcao”); System.out.println(“Tecle um númeral:”);
char opt = (char)System.in.read();
char nu = (char)System.in.read();
switch (opt) {
while (nu != ‘5’) {
case ‘1’: System.out.println(“Nada...”); break;
case ‘s’: case ‘S’: System.out.println(“Tente novamente”);
System.out.println(“Sim”); break; System.out.println(“Tecle númeral:”);
case ‘n’: case ‘N’: nu = (char)System.in.read();
System.out.println(“Não”); break; }
default: System.out.println(“Erro”); break; System.out.println(“Acertou!!!!”);
} }
}
} }

36 37

9
 Faça .. Enquanto (Do .. While) Para (For)
class DoWhileApp {
public static void main(String args[]) class testeArgs {
throws Exception { public static void main(String args[]) {
char lt; int i;
do {
System.out.println(args.length);
System.out.println(“Tecle uma letra:”);
lt = (char)System.in.read(); for(i=0;i<args.length;i++)
} while ( c != ‘f’); System.out.println(args[i]);
System.out.println(“Acertou!!!!”); }
}
} }

38 39

Para (For) Classes e Objetos

class ForLoopApp {
public static void main(String args[]) { ! Objetos
for (int i = 0; i < 10; i++) {
if (i == 7) continue; // retorna ao for 1
» métodos + atributos
System.out.println(“for 1: i=“ + i); » estado encapsulado
}
System.out.println(“for 1 final i=“ + i); ! Classes
for (i = 10; i > 0; i--) { » Agrupamento de objetos do mesmo tipo
if (i == 3) break; // sai do for 2
System.out.println(“for 2: i=“ + i);
}
System.out.println(“for 2 final: i=“ + i);
}
}

40 41

10
 Classe de Contas Classe de Contas: Assinaturas
class Conta {
Crédito
void credito (double valor) {}
Crédito
void debito (double valor) {}
Saldo
Saldo
Número
Número
875,32 21.342-7
String numero() {}
875,32 21.342-7
double saldo() {}
Débito Conta (int n) {}
Débito
}

42 43

Classe de Contas: Descrição Criação Dinâmica de Objetos

class Conta {
! ...
private int numero;
private double saldo; ! Conta conta1;
void credito (double valor) ! conta1 = new Conta(21342);
{saldo = saldo + valor;}
void debito (double valor) ! conta1.credito(500.87);
{saldo = saldo - valor;} ! conta1.debito(45.00);
String numero() {return numero;} ! System.out.println(conta1.saldo());
double saldo() {return saldo;}
Conta (int n) {numero = n; saldo = 0;} ! ....
}

44 45

11
 Descrições de Classes Encapsulamento

! Componentes abertos e fechados ! Como fazer para implementarmos

! Podem ser facilmente estendidos, um extrato para uma conta?
sem alterar os sistemas ! Devemos garantir que todas as
! Podem ser prontamente utilizados operações de crédito e débito sejam
para construir sistemas realizadas sempre passando por um
local com registro de operações.

46 47

Encapsulamento Encapsulamento
public class Conta { void credito(double val) {
private int numero; saldo = saldo + val;
private double saldo; extrato = extrato + "\n Credito: " + val +
private String extrato = ""; ". Saldo: " + saldo;}

void debito(double val) {

public int getNumero() {return numero;}
saldo = saldo - val;
public String getExtrato() return extrato;} extrato = extrato + "\n Debito: " + val
+ ". Saldo: " + saldo;}

48 49

12
 Encapsulamento Modelando o mundo real

! Componentes abertos (visíveis a ! Como incluir informação de pessoa

todos) e fechados (visíveis apenas vinculada a uma conta?
onde foi definido). ! Alternativa 1:
! Criação de pontos de acesso aos
componentes.
! Definição de regras de uso.
! OBS: Não trás segurança, mas
disciplina o acesso!

50 51

Modelando o mundo real Modelando o mundo real

! Como incluir informação de pessoa ! Como incluir informação de pessoa

vinculada a uma conta? vinculada a uma conta?
! Alternativa 1: ! Alternativa 2:
» Será que uma conta tem cpf?
» Será que uma conta tem nome?
» Faz sentido fazer desta forma?

52 53

13
 Modelando o mundo real Tarefa de Casa

! Como incluir informação de pessoa ! Crie uma classe Produto,

vinculada a uma conta? representando itens que podem estar
! Alternativa 2: a venda, por exemplo, em
» Maior reflexão sobre o mundo real supermercados.
» Criação de uma entidade adicional com ! Produtos devem ter código,
potencial de reuso. descrição, preço de compra, preço
de venda, quantidade, estoque
mínimo.

54 55

Tarefa de Casa Tarefa de Casa

! Produtos são fornecidos por ! Produtos devem ter o método

Fornecedores, que tem CNPJ, nome “double venda(int quant)”, que
e relação de produtos fornecidos. decrementa a quantidade do item e
! Produtos devem ter o método “void retorna o valor da venda, utilizando o
compra(int quant, double val)”, que atributo preço de venda.
incrementa a quantidade e atualiza o
atributo preço de compra.

56 57

14
 Classe de Bancos: Assinatura Classe de Bancos: Descrição

class Banco { class Banco {

void cadastro(Conta c) {} private Conta[] contas;
void deposito(int num, double val) {} private int indice = 0;
void saque(int num, double val) {}
double saldo(int num) {} void cadastro(Conta c) {
void transfere(int d, int p, double v) {} contas[indice] = c;
Banco () {} indice = indice + 1;
} }

58 59

Classe de Bancos: Descrição Classe de Bancos: Descrição

! Refatoração
» é o processo de modificar um sistema
de software para melhorar a estrutura
interna do código sem alterar seu
comportamento externo.
» No Eclipse existe um menu para ajudar
em refatorações.
! Algo estranho?
» No caso de Banco, devemos extrair um
» Repetição da busca.
método de pesquisa para contas!
» Como resolver?

60 61

15
 Classe de Bancos: Descrição Classe de Bancos: Descrição

62 63

Classe de Bancos: Construtor Mais Sobre Construtores

! Banco( ) ? ! Múltiplos Construtores

» Construtor da Classe » Overloading (Sobrecarga)
» Inicialização de um objeto da classe
» Caso não sejam declarados construtores, public class Circulo {
utiliza-se o construtor default double x, y, r;
Circulo(double x, double y, double r) {
this.x=x; this.y=y; this.r=r; }
Banco( ) {
Circulo(double r) {x=0.0; y=0.0; this.r=r;}
contas=new Conta[50]; Circulo(Circulo c) {x=c.x; y=c.y; this.r=c.r;}
} Circulo() {x=0.0; y=0.0; r=0.0;}
}

64 65

16
 Tarefa de Casa Tarefa de Casa

! Crie a classe Estoque. Ela deve ter ! A venda deve ser feita pelo preço de
uma estrutura de dados de Produtos. venda, retornando o valor e
! As operações em Estoque devem decrementando a quantidade de
prever compra e venda de itens. A itens do produto.
compra incrementa a quantidade de ! Deve ser possível criar produtos no
itens do produto e atualiza o preço Estoque, passando seus dados:
de compra. código, descrição, preço de compra,
preço de venda, estoque mínimo.

66 67

Testes Automatizados Testes Automatizados

! Como automatizar a geração de ! No Eclipse pode-se criar um JUnit

programas que verifiquem se outros Test Case.
programas estão corretos? » Nesse caso será criada uma classe
» Conceito de Testes Automatizados. vazia com um método de teste,
caracterizado pela anotação @Test

68 69

17
 Testes Automatizados Testes Automatizados

! Um teste é caracterizado pela

execução de algo e uma verificação
do resultado
! Essa verificação pode ser feito por
asserções (asserts) ou por indicação
de falhas (fail).

70 71

Testes Automatizados Testes Automatizados

! Um teste deve ser autocontido ! Um teste deve ter um nome

» Todos os dados para sua execução representativo
devem ser criados dentro do próprio » Os nomes dos métodos de testes
testes, para não depender de outros! devem representar o que está sendo
! Um teste deve ser focado testado.
» O teste deve focar em um aspecto ! Uma classe de teste pode ter vários
específico da regra de negócio. testes
» Devem ser criados outros testes para » Cada método com a anotação @Test
demais aspectos. indica um caso de teste

72 73

18
 Testes Automatizados Testes Automatizados

! Teste o caminho “feliz” ! Um auxílio à criação de testes.

» Deve haver testes para o uso planejado
de um método. O caminho normal e
para o qual foi pensado.
! Teste os caminhos alternativos
» Teste as demais opções consideradas
excepcionais, como tentativa de
depósito em conta inexistente, saque
em conta sem saldo, etc.

74 75

Testes Automatizados Testes Automatizados

! Um auxílio à criação de testes.

» Indica linhas de código não exercitadas
nos testes ou exercitadas parcialmente.

76 77

19
 Tarefa de Casa Lista de Contas
! Crie um método adicional para a
classe Estoque:
» O método
listarProdutosAbaixoDoMinimo(), que
devolve uma estrutura de dados de
produtos cujo quantidade está abaixo
do estoque mínimo para o produto.
» Crie testes para esse método e para os
outros métodos da classe.
» Meta: cobertura de 100% das linhas!

78 79

Lista de Contas Lista de Contas

Inicio
conta c20 prox no2
inicio conta C7 prox no1

conta C21 prox no3

novo
conta c10

conta C40 prox no4

50
conta c30

conta c50 prox no5

40

80 81

20
 Lista de Contas Lista de Contas: Assinatura
No lista = new No() -> 9854;
Conta c1 = new Conta(1); ! Quais são os métodos necessários?
lista.inserir(c1);
Conta c2 = new Conta(2);
lista.inserir(c2); Class No
prox Conta c;
No prox;
class ListaDeContas {
C1 1256
c Void Inserir(Conta c)
void inserir (Conta c) {}
prox
1256 c2 8567
void retirar (Conta c) {}
Conta Pesquisar (int num)
c Conta procurar (String num) {}
8567 null null }
c

82 83

Listas de Contas: Descrição Listas de Contas: Descrição

class ListaDeContas { void retirar (Conta c) {
private Conta conta; if (conta != null) {
private ListaDeContas prox;
void inserir (Conta c) { if (conta == c) {
if (this.conta == null) { this.conta = prox.conta;
this.conta = c; this.prox = prox.prox;
prox = new ListaDeContas(); } else prox.retirar(c);
} else prox.inserir(c); }
}
}

84 85

21
 Listas de Contas: Descrição Banco: Descrição Modular

Conta procurar (String num) { class BancoModular {

private ListaDeContas contas;
if (conta == null) return null; void cadastro(Conta c) {contas.inserir(c);}
else { void debito(String num, double val) {
Conta c;
if (conta.numero() == num)
c = contas.procurar(num);
return conta; if (c != null)
else return prox.procurar(num) c.debito(val);
else
} System.out.println("Conta inexistente!");
} }

86 87

Exercício em Sala Dever de Casa

! Completar a implementação da classe

BancoModular com os métodos
transfere e saldo.
! Compare as duas implementações de
bancos: Banco e BancoModular. Quais
as vantagens e desvantagens de cada
abordagem?

88 89

22
 Dever de Casa 1 Dever de Casa 2
! Desenvolva um sistema simples para ! Defina em Java uma classe Pilha, de
controle de estoque, contendo pelo menos as pilhas de inteiros, tendo métodos para
classes Produto e Estoque, e as seguintes realizar as seguintes operações:
operações: alterar as propriedades dos
produtos (nome, preço, quantidade em » push, insere um dado elemento no topo da
pilha;
estoque, quantidade mínima), comprar e
vender produtos do estoque, e verificar que » top, dá como resultado o elemento que
produtos precisam ser repostos (quantidade está no topo da pilha;
menor que a mínima). » pop, retira o elemento que está no topo da
pilha..

90 91

Tipos de Módulos em Java Pacotes e Diretórios

! Classes
! Cada pacote é associado a um diretório do
» agrupam definições de métodos, atributos,
inicializadores, etc. sistema operacional
» definem tipos ! Os arquivos neste diretório têm o mesmo
! Pacotes cabeçalho:
» agrupam definições de classes package nome_do_pacote;
relacionadas ! Cada arquivo define uma ou mais classes
» estruturam sistemas de grande porte, que fazem parte do pacote
facilitando a localização das classes ! Subdiretórios não correspondem a
» oferece um maior nível de abstração: há “subpacotes”
mais classes do que pacotes

92 93

23
 Nomeando Pacotes Modificadores de Acesso

! O nome de um pacote deve ser parte ! public

do nome do seu diretório associado: » atributos, métodos, inicializadores e
» o pacote exemplos.banco, deve estar no classes
diretório /home/pasn/java/exemplos/banco, » declaração pode ser utilizada (é visível)
assumindo que o compilador Java foi em qualquer lugar
informado para procurar pacotes em ! private
/home/pasn/java
» atributos, métodos e inicializadores
» declaração só pode ser utilizada na classe
onde ela é introduzida

94 95

Modificadores de Acesso Importação de Pacotes

! Protected ! Importando definição de tipo específica:
» atributos, métodos e inicializadores » package segundo.pacote;
» declaração só pode ser utilizada no pacote » import primeiro.pacote.NomeDoTipo;
onde ela é introduzida, ou nas subclasses
da classe onde ela é introduzida ! Importando todas definições públicas:
! default » package segundo.pacote;
» atributos, métodos, inicializadores e » import primeiro.pacote.*;
classes
» declaração só pode ser utilizada no pacote
onde ela é introduzida

96 97

24
 Importação de Pacotes: Detalhes Pacotes da Biblioteca Java

! Tanto “NomeDoTipo” quanto ! Acesso a Internet e WWW (java.net)

“primeiro.pacote.NomeDoTipo” podem ! Definição de interfaces gráficas
ser usados no corpo de (java.awt)
“segundo.pacote” ! Suporte a objetos distribuídos (java.rmi)
! Interface com Banco de Dados
! “segundo.pacote” não pode definir um (java.sql)
tipo com nome “NomeDoTipo” ! Básicos: threads e manipulação de
! Importação de pacotes não é transitiva strings (java.lang), arquivos (java.io),
nem distribui sobre os arquivos de um utilitários de propósito geral (java.util)
pacote ! Muitos outros...

98 99

Outros Modificadores de Acesso Outros Modificadores de Acesso

! Final ! Static
» Classes, Métodos e Variáveis » Métodos e Variáveis
» Construções Finais não podem ser » Construções Estáticas são associadas a
mudadas uma classe e não a instâncias da classe
• Variáveis: Constantes
• Classes: Não podem ser estendidas
class Estatica {
• Métodos: Não podem ser redefinidos static int x=0;
Estatica() { x++;}
}

100 101

25
 Outros Modificadores de Acesso Outros Modificadores de Acesso

! Static ! Static
» Variáveis estáticas podem ser » Toda aplicação deve conter um método
referenciadas através de qualquer estático.
instância da classe ou através do nome • Métodos estáticos só podem acessar
da classe. Ex: variáveis estáticas e outros métodos
1. Estatica e1 = new Estatica(); estáticos.
2. Estatica e2 = new Estatica(); • Para acessar variáveis não estáticas ou
3. e1.x = 100; métodos não estáticos deve-se instanciar
4. e2.x = 200; uma classe.
5. Int OutroX = Estatica.x;

102 103

Coleções Coleções

! Estruturas de dados empacotadas, com ! Arrays

interfaces e algoritmos » Método estático para manipular arrays
» Arrays.fill ( matriz, valor) – preenche a matriz com o valor
» Transparência para programadores indicado

! Tipos em Java » Arrays.sort ( matriz ) – ordena matriz ascendente

» Arrays.binarySearch ( matriz, elemento)
» Collection
» Set
» List
» Map
» Queue

104 105

26
 Coleções Coleções

! Collection ! ArrayList
» Interface raiz de SET, Queue e LIST » Implementação muito utilizada em problemas práticos
» Implementa polimorfismo durante a disciplina
» Métodos da Interface » Classe genérica, que permite uma especialização
• Add
• Size
• Get
• Contains

106 107

Exercicio Coleções

! Criar uma classe que contém um ! Conjuntos: coleções com elementos

método para receber um array de únicos!
Contas existentes em uma região, um » HashSet e TreeSet
! Possuem os mesmos métodos de Collection
array com as contas de um banco e
com isso calcular as contas que não
fazem parte do banco!
» Deve ser usadas coleções para se implementar a resposta
desse problema!
» Verifique se a comparação de contas funciona
corretamente! Usar Vector na implementação!

108 109

27
 Coleções Coleções

! Faça a implementação do problema ! Mapas: coleções que associam chaves

anterior (descobrir contas que não a valores (mapeamento um para um).
pertencem a um banco) utilizando uma ! HashTable, HashMap, TreeMap

implementação de SET.

110 111

Exercício Datas

! Criar uma classe que contém um ! Java.util.Date

método para receber uma lista de » Datas simples
disciplinas de um curso, uma lista de » Date x = new Date()
disciplinas já cursadas e mostrar o que ! Convertendo texto em data
um aluno falta cursar ainda! » SimpleDateFormat sdf1= new
» Deve ser usadas coleções para se implementar a resposta
desse problema! SimpleDateFormat("dd/MM/yyyy");
» Date dataUsuario=sdf1.parse(stx);

112 113

28
 Datas Datas

! Convertendo data para texto ! Para manipular datas

» SimpleDateFormat sdf1= new » Gregorian Calendar
SimpleDateFormat("dd/MM/yyyy"); » Obter dia da semana, mês, ano
» Date y=new Date(); • GregorianCalendar gc=new GregorianCalendar();
» System.out.println(sdf1.format(y)); • Sysout (gc.get(gc.DAY_OF_WEEK));
• System.out.println(gc.get(gc.DATE));
• System.out.println(gc.get(gc.MONTH));
• System.out.println(gc.get(gc.YEAR));

114 115

Datas Datas

! Para manipular datas ! Para trabalhar com datas

» Gregorian Calendar » gc.add(gc.MONTH, 2); //Adiciona 2 meses à
» Verificar se uma data está antes ou depois data atual
de outra » gc.HOURS, gc.MINUTES, etc.
• AFTER/BEFORE » gc.isLeapYear(2009)
– gc.after(gc2)
• Indica se o ano é bissexto!
» Ajustando data
• gc.set(2009,10,03) ou gc.set(2009,
10,03,2009,10,30) ou gc.set(gc.HOUR,11);

116 117 » Leia mais em: Manipulando Datas em Java

http://www.devmedia.com.br/manipulando-
datas-em-java/21765#ixzz2boPKr287

29
 Dever de Casa Dever de Casa 3
! Estruture o sistema de controle de
estoque usando pacotes
! Implemente a classe Estoque usando a
classe ArrayList (ambas do pacote
“java.util”).
» OBS: Verifique no help quais são os
construtores da classe e os métodos a
serem utilizados !

118 119

Objeto Poupança Estados do Objeto Poupança

Crédito Crédito(20)
Crédito Crédito Crédito
Crédito Crédito

Saldo Número Saldo Número Saldo Número

Saldo Número Saldo Número Saldo Número
875,32 21.342-7 R. Juros 895,32 21.342-7 R. Juros
875,32 21.342-7 R. Juros 875,32 21.342-7 875,32 21.342-7
875,32 21.342-7

Débito
Débito Débito
Débito
Débito
Débito

120 121

30
 Estados do Objeto Poupança Classe de Poupanças: Descrição

class PoupancaSemHerança {
R.Juros(0.01) private String numero;
Crédito
Crédito
Crédito
Crédito private double saldo;
void credito (double valor) {saldo = saldo +
Saldo Número Saldo Número
Saldo Número
875,32 21.342-7 R. Juros
Saldo Número
884,07 21.342-7 R. Juros valor;}
875,32 21.342-7 875,32 21.342-7
String numero() {return numero;}
Débito
Débito Débito
Débito
...
void rende_juros (double t)
{this.credito(saldo * t);}
}

122 123

Classe de Bancos: Assinatura Classe de Bancos: Descrição

class BancoComPoupanca {
void cadastro_conta(Conta c) {} class BancoComPoupanca {
void cadastro_poupanca(PoupancaD p) {}
private Conta[] contas;
void credito_conta(String num, double val) {}
private PoupancaD[] poupancas;
void credito_poupanca(String num, double
val) {} private int indicep, indicec = 0;
...
BancoD () {}
}

124 125

31
 Classe de Bancos: Descrição Classe de Bancos: Descrição

void cadastro_conta(Conta c) { private Conta procura_conta(String n) {

contas[indicec] = c; int i = 0;
indicec = indicec + 1; boolean achou = false;
} while ((! achou) && (i < indicec)) {
if (contas[i].numero() == n) achou = true;
void cadastro_poupanca(PoupancaD p) { else i = i + 1;
poupancas[indicep] = p; }
indicep = indicep + 1; if (achou == true) return contas[i];
} else return null;
} ...

126 127

Problemas Subtipos e Subclasses

! Duplicação desnecessária de código: Poupança

» A definição de PoupançaSemHerança é
uma simples extensão da definição de
Conta
» Clientes de Conta que precisam trabalhar
também com PoupançaSemHerança terão
que ter código especial para manipular
poupanças
! Falta refletir relação entre tipos do Conta
“mundo real”

128 129

32
 Subclasses Herança

! Comportamento ! Reuso de Código

» Objetos da subclasse comportam-se como » A descrição da superclasse pode ser
os objetos da superclasse usada para definir a subclasse
! Substituição ! Extensibilidade
» objetos da subclasse podem ser usados » algumas operações da superclasse podem
no lugar de objetos da superclasse ser redefinidas na subclasse

130 131

Classe de Poupanças: Assinatura Classe de Poupanças: Descrição

class Poupanca class Poupanca

extends Conta { extends Conta {

void rende_juros(double t) {} void rende_juros(double t) {

Poupanca (String num) {} this.credito(this.saldo() * t);
} }
Poupanca (String num) { super (num);}
}

132 133

33
 Extends Extends: Restrições

! subclasse extends superclasse ! Atributos e métodos privados são

! Mecanismo para definição de herança e herdados, mas não podem ser
subtipos acessados diretamente
! Herança simples: só pode-se herdar ! Qualificador protected: visibilidade
uma classe por vez restrita a classe e subclasses
! Construtores não são herdados
! Construtor default só é disponível se
também for disponível na superclasse

134 135

Usando Poupanças Subtipos: Substituição

... ...
Poupanca poup; Conta conta;
poup = new Poupanca(¨21.342-7¨); conta = new Poupanca(¨21.342-7¨);
poup.credito(500.87); conta.credito(500.87);
poup.debito(45.00); conta.debito(45.00);
System.out.println(poup.saldo()); System.out.println(conta.saldo());
... ...

136 137

34
 Subtipos: Verificação Dinâmica
Substituição e Casts
com Casts
... ! Nos contextos onde contas são usadas
Conta conta; pode-se usar poupanças
! Nos contextos onde poupanças são
conta = new Poupanca(¨21.342-7¨); usadas pode-se usar contas com o uso
... explícito de casts
((Poupanca) conta).rende_juros(0.01); ! Casts correspondem a verificação
conta.imprime_saldo(); dinâmica de tipos e podem gerar
exceções (Cuidado!)
...
! Casts não fazem conversão de tipos

138 139

Classe de Bancos: Assinatura Subtipos: Substituição

class Banco { ...

void cadastro(Conta c) {} Banco banco = new Banco();
void credito(String num, double val) {} banco.cadastro(new Conta(¨21.345-7¨));
banco.cadastro(new Poupanca(¨1.21.345-
void debito(String num, double val) {} 9¨));
double saldo(String num) {} banco.credito(¨21.345-7¨,129.34);
void transfere(String d, String p, double banco.transfere(¨21.345-7¨,¨1.21.345-
v) {} 9¨,9.34);
Banco () {} System.out.print(banco.saldo(¨1.21.345-
} 9¨));
...
140 141

35
 Subtipos: Verificação Dinâmica
Exercício em Sala
com instanceof
! Modifique a classe Banco para que seja ...
possível render juros de uma poupança. Conta c = this.procura(¨123.45-8¨);
Isto é, adicione um novo método que
rende os juros da poupança cujo
número é parâmetro deste método; a if (c instanceof Poupanca)
taxa de juros corrente deve ser um ((Poupanca) c).rende_juros(0.01);
atributo de Banco. else System.out.print(¨Poupança
inexistente!¨)
...

142 143

Verificação Dinâmica de Tipos Objeto Conta Especial

! Casts e instanceof:
» ((Tipo) variável) Crédito

» variável instanceof Tipo

» O tipo de variável deve ser supertipo de Saldo Número Limite
Tipo
875,32 21.342-7 11,80
» Casts geram exceções, instanceof retorna
false
» Casts são essenciais para verificação
Débito
estática de tipos (compilação)

144 145

36
 Estados de uma Conta Especial Estados de uma Conta Especial

Crédito(20) Debito(900)
Débito Crédito
Crédito Débito Crédito
Crédito
Débito Crédito
Crédito Débito Crédito
Crédito

Saldo Número
Saldo Limite
Número Saldo Número
Saldo Limite
Número
Saldo Número
Saldo Limite
Número Saldo Número
Saldo Limite
Número
875,32 21.342-7 100 875,00 21.342-7 100
875,32 21.342-7 895,32 21.342-7 100 875,32 21.342-7 -25,00 21.342-7 100
875,32 21.342-7 875,32 21.342-7

146 147

Contas Especiais: Assinatura Contas Especiais: Descrição

class ContaEspecial class ContaEspecial

extends Conta { extends Conta {

private double limite;

void debito(double valor) {}
ContaEspecial (String num) {} void debito(double valor) {
} if (saldo + limite >= valor)
debito(valor);
}

148 149

37
 Redefinição de Métodos Usando Contas Especiais

! Invariância: tipos dos argumentos e ...

resultados da redefinição tem que ser ContaEspecial contae;
iguais aos tipos da definição
contae = new ContaEspecial(¨21.342-7¨);
! Semântica e Visibilidade dos métodos contae.credito(200.00);
redefinidos deve ser preservada
contae.debito(300.00);
! Só é possível acessar a definição dos
métodos da superclasse imediata (via System.out.print(contae.saldo());
super) ...

150 151

Ligações Dinâmicas Ligações Dinâmicas

... ! Dois métodos com o mesmo nome e tipo:

Conta conta; » definição e redefinição, qual usar?
conta = new ContaEspecial(¨21.342-7¨); ! O código é escolhido dinamicamente (em
tempo de execução), não estaticamente
conta.credito(200.00); (em tempo de compilação)
conta.debito(300.00); ! Escolha é feita com base na classe do
System.out.print(conta.saldo()); objeto associado à variável destino do
... método

152 153

38
 Dever de Casa Dever de Casa 4
! Modifique o sistema de controle de
estoque requisitado como exercício
para poder também armazenar
produtos perecíveis; isto é, produtos
que têm um prazo de validade.
! Modifique o sistema de controle de
estoque para manter um histórico de
vendas de determinados produtos.

154 155

Estados do Objeto Conta

Objeto Conta Imposto
Imposto
Débito(20)
Crédito
Crédito Crédito
Crédito Crédito

Saldo Número Saldo Número

Saldo Número
875,00 Saldo
21.342-7Número 854,98
Saldo
21.342-7
Número
875,32 21.342-7 875,32 21.342-7 875,32 21.342-7

Débito Débito

Débito

156 157

39
 Conta Imposto: Assinatura Conta Imposto: Assinatura

class ContaImposto { class ContaImpostoM

void credito (double valor) {} extends Conta {
void debito (double valor) {}
String numero() {} ContaImpostoM (String num) {}
double saldo() {} }
ContaImposto (String n) {}
}

158 159

Conta Imposto: Descrição Subtipos e Subclasses

Conta Imposto
class ContaImpostoM
extends Conta {

void debito(double val) {

super.debito(val + (val * 0.001));
}
ContaImpostoM (String num) {super
(num);}
Conta
}

160 161

40
 Subclasses e Evolução de
Subclasses e Comportamento
Software
! Objetos da subclasse comportam-se ! Deveria ser possível raciocinar sobre o
como os objetos da superclasse código usando-se apenas a definição
! Redefinições de métodos devem dos tipos das variáveis envolvidas
preservar o comportamento (semântica) (Conta)
do método original ! O comportamento do código deveria ser
! Grande impacto sobre independente do tipo do objeto (Conta,
manutenção/evolução de software... ContaEspecial, Conta Imposto)
associado a uma dada variável em
tempo de execução

162 163

Reuso sem Subtipos Reuso preservando Subtipos

ContaAbstrata
Conta

Conta ContaImposto
Poupança ContaImpostoM
ContaEspecial
Poupanca ContaEspecial

164 165

41
 Definindo Classes Abstratas Classes Abstratas
abstract class ContaAbstrata {
! Possibilita herança de código preservando
protected String numero; comportamento (semântica)
protected double saldo;
! Métodos abstratos:
void credito (double valor) {
» Geralmente existe pelo menos um
saldo = saldo + valor;
» São implementados nas subclasses
}
abstract void debito (double valor); ! Não cria-se objetos:
String numero() {return numero;} » Mas podem ter construtores, para reuso
double saldo() {return saldo;} » Atributos qualificados como protected
} para serem acessados nas subclasses

166 167

Contas: Descrição Modificada Poupanças: Descrição Original

class Conta class Poupanca extends Conta {

extends ContaAbstrata {
void rende_juros(double t) {
void debito (double valor) { this.credito(this.saldo() * t);
saldo = saldo - valor; }
} Poupanca (String num) {
Conta (String n) {numero = n; saldo = 0;} super (num);
} }
}

168 169

42
 Conta Especial: Descrição
Conta Imposto: Descrição
Original
class ContaEspecial extends Conta { class ContaImposto
extends ContaAbstrata {

private double bonus; void debito(double val) {

void credito(double valor) { saldo = saldo - (val + (val * 0.001));
bonus = bonus + (valor * 0.01); }
ContaImposto (String num) {
super.credito(valor); numero = num; saldo = 0;
} }
... }

170 171

Substituição e Ligações Dinâmicas Classes Abstratas: Utilização

... ! Herdar código sem quebrar noção de

ContaAbstrata ca, ca’; subtipos, preservando o
ca = new ContaEspecial(¨21.342-7¨); comportamento do supertipo
ca’ = new ContaImposto(¨21.987-8¨); ! Generalizar código, através da
ca.debito(500); abstração de detalhes não relevantes
ca’.debito(500); ! Projetar sistemas, definindo as suas
System.out.println(ca.saldo()); arquiteturas e servindo de base para a
System.out.println(ca’.saldo()); implementação progressiva dos
... mesmos

172 173

43
 Exercício em Sala Dever de Casa

! Modifique a classe Banco para

funcionar de modo semelhante aos
bancos do mundo real

174 175

Dever de Casa 5 Auditor de Banco

! Modifique o sistema de controle de class AuditorB {

estoque requisitado como exercício private String nome;
para que não seja possível vender
produtos fora do prazo de validade. void investiga_banco(Banco b) {
if ((b.saldo_total() / b.num_contas()) > 500)
System.out.print ("Aprovado!");
else System.out.print ("Não aprovado!");
}
}

176 177

44
 Auditor de Banco Modular Problema

class AuditorB { ! Duplicação desnecessária de código

private String nome; ! O mesmo auditor deveria ser capaz de
investigar qualquer tipo de banco que
void investiga_banco(BancoModular b) { possua operações para calcular
if ((b.saldo_total() / b.num_contas()) > 500) » o número de contas, e
System.out.print ("Aprovado!"); » o saldo total de todas as contas.
else System.out.print ("Não aprovado!");
}
}

178 179

Auditor Genérico Definindo Interfaces

class Auditor {
private String nome;
interface QQBanco {
void investiga_banco(QQBanco b) { double saldo_total();
if ((b.saldo_total() / b.num_contas()) > 500) int num_contas();
System.out.print ("Aprovado!"); }
else System.out.print ("Não aprovado!");
}
}

180 181

45
 Interfaces Subtipos sem Herança
! Caso especial de classes abstratas... class Banco
! Definem tipo de forma abstrata, apenas implements QQBanco {
indicando o nome e o tipo dos métodos ...
suportados pelos objetos do tipo }
! Os métodos são implementados pelos
subtipos (subclasses) class BancoModular
implements QQBanco {
! Não têm construtores: não pode-se ...
criar objetos já que métodos não são }
definidos

182 183

Implements Usando Auditores

! classe implements interface1, interface2, ... Banco b = new Banco();

subtipo implements supertipo1, supertipo2, ... BancoModular bm = new
! Múltiplos supertipos: uma classe pode BancoModular();
implementar mais de uma interface Auditor a = new Auditor();
(contraste com classes abstratas...)
...
! Classe que implementa uma interface
a.investiga_banco(b);
deve definir (não necessariamente
implementar!) os métodos da interface a.investiga_banco(bm);
...

184 185

46
 Definição de Classes:
Interfaces e Reusabilidade
Forma Geral
! Evita duplicação de código através da class C’
definição de um tipo genérico, tendo como
subtipos várias classes não relacionadas extends C
! Tipo genérico pode agrupar objetos de implements I1, I2, ..., In {...}
várias classes definidas
C
independentemente, sem compartilhar
código via herança, tendo implementações
totalmente diferentes
I1 I2 I3 ... In
! Classes podem até ter mesma
C’
semântica...

186 187

Subtipos com Herança

O que usar? Quando?
Múltipla
Classes (abstratas) Interfaces
interface I ! Agrupa objetos com ! Agrupa objetos com
extends I1, I2, ..., In implementações implementações
compartilhadas diferentes
{ ! Define novas ! Define novas
... assinaturas de novos métodos ... classes através de interfaces através
herança (simples) de herança
} de código (múltipla) de
! Só uma pode ser assinaturas
supertipo de outra ! Várias podem ser
classe supertipo do mesmo
tipo

188 189

47
 Bancos: Parametrização Bancos:Construtor
class BancoIndependente {
BancoIndependente
private RepositorioDeContas contas;
(RepositorioDeContas rep) {
void cadastro(Conta c) {contas.inserir(c);}
void debito(String num, double val) { contas = rep;
Conta c; }
c = contas.procurar(num);
if (c != null) c.debito(val); A estrutura para armazenamento das contas é
fornecida na inicialização do banco,
else System.out.println("Conta e pode depois ser trocada!
inexistente!");
}...

190 191

Repositório: Definição Repositório: Implementações

class ConjuntoDeContas
implements RepositorioDeContas {...}
interface RepositorioDeContas {
class ListaDeContas
void inserir(Conta c);
implements RepositorioDeContas {...}
Conta procurar(String num);
class ArrayDeContas
}
implements RepositorioDeContas {...}
class VectorDeContas
implements RepositorioDeContas {...}

192 193

48
 Exercício em Sala Dever de casa

! Modifique a classe Banco para utilizar o ! Modifique a classe Estoque para utilizar
Repositório de Contas, implementando o Repositório de Produtos,
a classe Lista de Contas e Array de implementando a classe Lista de
Contas Produtos, Array de Produtos, Vector de
Produtos e ArrayList de Produtos.

194 195

Classe de Contas: Descrição Desconsiderar Operação

class Conta { class Conta {

private String numero; private String numero;
private double saldo;
private double saldo;
void debito (double valor) {
void debito (double valor) {
saldo = saldo - valor;
}... if (valor <= saldo) saldo = saldo -
valor;
Como evitar débitos acima do limite permitido? }...
}

196 197

49
 Mostrar Mensagem de Erro Retornar Código de Erro
class Conta { class Conta {
private String numero; private String numero;
private double saldo; private double saldo;
void debito (double valor) { boolean debito (double valor) {
if (valor <= saldo) if (valor <= saldo) {
saldo = saldo - valor; saldo = saldo - valor;
else System.out.print(“Saldo return true;
Insuficiente!”); } else return false;
}... }...
} }

198 199

Problemas Código de Erro: Problemas

! Desconsiderar operação: não tem como class Conta { ...
saber se a operação foi realizada;
nenhuma informação é dada ao cliente. boolean transfere(Conta conta, double v) {
boolean b = conta.debito(v);
! Mensagem de erro: dependência entre
a classe e sua interface com o usuário; if (b) {
não sinaliza erro para outros métodos. this.credito(v);
! Código de erro: complica definição e return true;
uso do método (clientes têm que fazer }else return false;
testes); pior para métodos que já
retornam valores }
}

200 201

50
 Código de Erro: Problemas Exceções
class Banco { ... ! Ao invés de códigos, teremos exceções...
int debito(String num, double v) {
! São objetos comuns, portanto têm que ter
Conta c = this.procura(num);
uma classe associada
if (c != null) {
! Classes representando exceções herdam e
boolean b = c.debito(v); são subclasses de Exception (pré-definida)
if (b) return 0;
! Define-se subclasses de Exception para
else return 2;
} else return 1; » oferecer informações extras sobre a
falha, ou
}
} » distinguir os vários tipos de falhas

202 203

Definindo Métodos com

Definindo Exceções
Exceções
class SIException extends Exception { class Conta {
double sc; private String numero;
String nc; private double saldo;
void debito (double valor) throws SIException
SIException (double s, String n) { {
super (“Saldo Insuficiente!”); if (valor <= saldo)
sc = s; saldo = saldo - valor;
nc = n; else throw new SIException(saldo,numero);
} }...
}
}

204 205

51
 Definindo e Levantando
Usando Métodos com Exceções
Exceções
! Res metodo(Args) throws E1, ..., EN {...} class Conta { ...
! Todos os tipos de exceções levantadas no void transfere(Conta conta, double v)
corpo de um método devem ser throws SIException {
declaradas na sua assinatura conta.debito(v);
! Levantando exceções: throw obj-exceção this.credito(v);
! Fluxo de controle e exceção são passados }
para a chamada do código contendo o
}
comando throw, e assim por diante... Exceções levantadas indiretamente também
devem ser declaradas!

206 207

Usando e Definindo Métodos

Tratando Exceções
com Exceções
class Banco { ... try {
void debito(String num, double v) banco.debito(num,val); ...
}
throws SIException, CNEException {
catch (SIException sie) {
Conta c = this.procura(num); System.out.print(sie.getMessage());
if (c != null) c.debito(v); System.out.print(“ Conta/saldo: ”);
else throw new CNEException(); System.out.print(sie.nc+“/”+sie.sc);
} }
} catch (CNEException cnee) {...}

208 209

52
 Tratando Exceções Exceções em Banco
! A execução do try termina assim que
uma exceção é levantada class Banco {
! O primeiro catch de um (super) tipo da private Conta[] contas;
exceção é executado e o fluxo de private int indice = 0;
controle passa para o código seguinte
ao último catch
! Se não houver nenhum catch void cadastro(Conta c) {
compátivel, a exceção e o fluxo de contas[indice] = c;
controle são passados para a chamada indice = indice + 1;
do código com o try/catch
}

210 211

Exceções em Banco Exceções em Banco

private Conta procura(String n) void debito(String num, double val)
throws CNEException {
int i = 0; throws SIException, CNEException {
boolean achou = false;
while ((! achou) && (i < indice)) {
if ((contas[i].numero()).equals(n)) Conta c = this.procura(num);
achou = true; c.debito(val);
else i = i + 1;
} }
if (achou == true) return contas[i];
else throw new CNEException();
}

212 213

53
 Exercício em Sala Dever de Casa

! Altere o método saldo da classe Banco

para gerar uma exceção quando
alguém quiser saber o saldo de uma
conta não cadastrada.
! Altere a classe Banco para não permitir
que duas contas com o mesmo número
sejam cadastradas; use exceções para
lidar com esta situação de erro.

214 215

Dever de Casa 5 Layout Managers

! Modifique o sistema de controle de ! Utilizado por 2 razões:

estoque requisitado como exercício » Responsável pela determinação da
para que não seja possível vender localização de componentes, evitando
produtos fora do prazo de validade. assim, trabalhos repetitivos
» Componentes podem aparecer com
diferentes tamanhos e posições em virtude
da independência de plataforma

216 217

54
 Containers Ex: Hierarquia de Componentes
Frame
! São componentes que podem conter Panel
outros componentes Panel Panel Panel
! Subregiões são implementadas Label Label Label
utilizando Panels Scrollbar Scrollbar Scrollbar

! Panels podem conter Panels ou outros TextField TextField TextField

componentes
Panel
Botão Botão Botão

218 219

Ex: Hierarquia de Componentes Ex: Hierarquia de Componentes

import java.awt.*;
// Continuação ...
public class Hierarquia extends Frame {
Hierarquia() { add(grande, BorderLayout.CENTER);
super("Teste de Hierarquia de Componentes"); Panel embaixo = new Panel();
setBounds(20,20,300,180); embaixo.add(new Button("Aplicar"));
setLayout(new BorderLayout()); embaixo.add(new Button("Limpar"));
String strings[]={"Vermelhor:","Verde:","Azul:"};
Panel grande = new Panel(); embaixo.add(new Button("Cancelar"));
grande.setLayout(new GridLayout(1,3,20,0)); add(embaixo, BorderLayout.SOUTH);
for(int i=0; i<3; i++) { this.show();
Panel interno = new Panel(); }
interno.setLayout(new GridLayout(3,1,0,10));
public static void main(String args[]) throws Exception {
interno.add(new Label(strings[i]));
interno.add(new Hierarquia h=new Hierarquia();
Scrollbar(Scrollbar.HORIZONTAL,i,10,0,255)); System.in.read();
interno.add(new TextField("0")); }
grande.add(interno); }
}

220 221

55
 Ex: Hierarquia de Componentes Políticas de Layout: FlowLayout

! Default para Panels

! Dispõe os componentes em colunas
horizontais
! Mantém os componentes do Preferred
Size

222 223

Políticas de Layout: FlowLayout Políticas de Layout: FlowLayout

import java.awt.*;
import java.applet.*;

public class TesteFlow extends Applet {

public void init() {
Label label=new Label("Nome:");
add(label);
TextField textfield=new
TextField("Teste FlowLayout");
add(textfield);
Button button=new Button("OK");
add(button);
}
}

224 225

56
 Políticas de Layout: GridLayout Políticas de Layout: GridLayout

! Ignora o Preferred Size ! GridLayout(int linhas, int colunas)

! Divide uma área em uma matriz de
linhas e colunas
» setLayout(new GridLayout(5,3));
• 5 linhas
• 3 colunas

226 227

Políticas de Layout: GridLayout Políticas de Layout: BorderLayout

import java.awt.*; ! Layout default em Frames
import java.applet.*;
! Divide a área em 5 regiões: North,
public class TesteGrid extends Applet {
public void init() {
South, East, West, Center
setLayout(new GridLayout(5,3));
for(int linha=0; linha<5; linha++){
add(new Label("Label"+linha));
add(new Button("Botao"+linha));
add(new TextField("TextField"+linha));
}
}
}

228 229

57
 Políticas de Layout: BorderLayout Dever de Casa
import java.awt.*;
import java.applet.*;
public class TesteBorder extends Applet {
public void init() {
setLayout(new BorderLayout());
add(new Button("North"),BorderLayout.NORTH);
add(new Button("South"),BorderLayout.SOUTH);
add(new Button("East"),BorderLayout.EAST);
add(new Button("West"),BorderLayout.WEST);
Panel p = new Panel();
p.setBackground(Color.blue);
add(p,BorderLayout.CENTER);
}
}

230 231

Dever de Casa 6 Threads em Java

! Modifique o sistema de controle de ! Multithreads. Por que Usar?

estoque para funcionar com uma » Melhor aproveitamento dos recursos
interface gráfica. » Vários threads resolvem problemas de
forma melhor
! Como utilizar
» Dividindo-se as tarefas potencialmente
longas em tarefas separadas

232 233

58
 Threads em Java: Exemplo Threads em Java: Exemplo
import java.io.*; class PseudoIOSemThread {
public class SemThread {
static long tempobase=System.currentTimeMillis(); PseudoIOSemThread() {
public static void main(String args[]) throws Exception { SemThread.mostraTempo("PseudoIO Criada");
PseudoIOSemThread pseudo=new PseudoIOSemThread(); }
pseudo.run(); public void run(){
mostraTempo("Outra Tarefa Inicia"); SemThread.mostraTempo("PseudoIO Iniciado");
System.in.read();
} try {
static void mostraTempo(String mens){ Thread.sleep(10000);
long tempogasto=System.currentTimeMillis()-tempobase; SemThread.mostraTempo("PseudoIO Termina");
System.out.println(mens+" em "+(tempogasto/1000.0)+"
segundos"); } catch (InterruptedException e) {}
} }
} }

234 235

Threads em Java: Exemplo Threads em Java: Exemplo

import java.io.*; class PseudoIOComThread extends Thread {
public class ComThread {
static long tempobase=System.currentTimeMillis(); PseudoIOComThread() {
public static void main(String args[]) throws Exception { ComThread.mostraTempo("PseudoIO Criada");
PseudoIOComThread pseudo=new PseudoIOComThread(); }
pseudo.start(); public void run(){
mostraTempo("Outra Tarefa Inicia"); ComThread.mostraTempo("PseudoIO Iniciado");
System.in.read();
} try {
static void mostraTempo(String mens){ Thread.sleep(10000);
long tempogasto=System.currentTimeMillis()-tempobase; ComThread.mostraTempo("PseudoIO Termina");
System.out.println(mens+" em "+(tempogasto/1000.0)+"
segundos"); } catch (InterruptedException e) {}
} }
} }

236 237

59
 Threads em Java: Exemplo Threads em Java: Exemplo
! Saída para o programa SemThreads ! Programa SemThread
» PseudoIO Criada em 0.11 segundos » Durante o bloqueio, nada é executado
» PseudoIO Iniciado em 0.22 segundos » Ineficiência na utilização do processador
» PseudoIO Termina em 10.27 segundos ! Programa ComThread
» Outra Tarefa Inicia em 10.27 segundos » Outras atividades executam durante o
! Saída para o programa ComThreads bloqueio de um Thread
» PseudoIO Criada em 0.11 segundos » Utilização mais eficiente do processador
» Outra Tarefa Inicia em 0.22 segundos
» PseudoIO Iniciado em 0.22 segundos
» PseudoIO Termina em 10.21 segundos

238 239

Métodos para controle de

Criação de Threads
Threads
! Feito basicamente de 2 maneiras ! void start() throw IllegalThreadStateException
» Inicia a execução do corpo do Thread definido no
» Estendendo a classe Thread método run(). O controle do programa retorna ao
• Deve-se criar um objeto dessa classe com chamador e o novo Thread será escalonado para
new() e chamar o start() para iniciar execução executar concorrentemente.
– PseudoIOComThread t= new PseudoIOComThread(); ! void stop()
– t.start();
» Usado para encerrar a execução do Thread.
» Implementando a Interface Runnable ! void suspend()
• Deve-se criar um objeto da classe Thread
» Usado para suspender temporariamente a
passando o objeto que implementa Runnable execução do Thread.
como parâmetro e depois executar start()
– PseudoIOComThread p= new PseudoIOComThread(); ! void resume()
– Thread t=new Thread(p); » Usado para continuar a execução de um Thread
– t.start(); suspenso

240 241

60
 Métodos para controle de Métodos para controle de
Threads Threads: Exemplo
import java.io.*;
! Static void sleep(long sleepTimeInMillis) public class TesteThreads {
public static void main (String args[]) throws Exception {
throws InterruptedException FirstThread first=new FirstThread();
SecondThread second=new SecondThread();
» Coloca o Thread para dormir por um tempo first.start();
second.start();
especificado como parâmetro try {
System.out.println("Esperando pelo primeiro Thread Terminar...");
! void join() throws InterruptedException first.join();
System.out.println("Foi uma longa espera !");
» O Thread chamador bloqueia esperando este System.out.println("Acordando o segundo Thread...");
synchronized(second){
Thread morrer second.notify();
! static void yield() }
System.out.println("Esperando pelo termino do segundo Thread...");
» Bloqueia o chamador e o coloca no fim da fila de second.join();
} catch (InterruptedException e){ }
escalonamento System.out.println("Estou terminando tambem ...");
System.in.read();
}
}

242 243

Métodos para controle de Métodos para controle de

Threads: Exemplo Threads: Exemplo
public class SecondThread extends Thread {
class FirstThread extends Thread {
public void run() {
public void run() {
try {
try {
System.out.println("\t Inicio do Segundo Thread");
System.out.println("\t Inicio do Primeiro Thread"); System.out.println("\t Segundo Thread chama
sleep(5000); wait()");
System.out.println("\t Fim do Primeiro Thread"); wait();
} catch(InterruptedException e) {} System.out.println("\t Segundo Thread volta a
executar e termina");
}
} catch(InterruptedException e) {}
}
}
}

244 245

61
 Métodos para controle de
Ciclo de Vida de um Thread
Threads: Exemplo
! Saída do programa TesteThreads
Runnable suspend(), sleep(),
» Esperando pelo primeiro Thread Terminar. new()
wait() ou I/O
• Inicio do Primeiro Thread

t()
ar
• Inicio do Segundo Thread resume(),

st
stop(), ou notify(),
• Segundo Thread chama wait() Recentemente timeout, IO
Criada fim do run() Bloqueada
• Fim do Primeiro Thread
» Foi uma longa espera !
stop(), ou stop(), ou
» Acordando o segundo Thread... fim do run() Morta fim do run()
» Esperando pelo termino do segundo Thread...
• Segundo Thread volta a executar e termina
» Estou terminando tambem ...

246 247

Multithread Avançado O Programa Exemplo: Depósito

import java.io.*;
! Sincronização public class Deposito {
static int balanco=1000;
» Método utilizado para evitar a corrupção de public static void main(String args[]) throws Exception {
dados Conta conta=new Conta();
ThreadDeposito first=new ThreadDeposito(conta, 1000, "#1");
! Quando isso é necessário? ThreadDeposito second=
» Programa para realizar depósitos em contas new ThreadDeposito(conta, 1000, "\t\t\t\t#2");
first.start(); second.start();
• Obtenção do saldo em um servidor remoto try {
• Soma do valor depositado ao saldo first.join(); second.join();
• Envio do novo saldo ao servidor remoto } catch(InterruptedException e) {}
System.out.println("O balanco final e "+balanco);
! 2 Threads tentando depositar R$1.000,00 System.in.read();
em uma conta com R$1.000,00 }
}

248 249

62
 O Programa Exemplo: Conta O Programa Exemplo: Conta
class Conta {
int getSaldo(){
void deposito(int v, String nome){
try {
int saldo;
Thread.sleep(5000);
System.out.println(nome+" tentando depositar "+v);
} catch(InterruptedException e) {}
System.out.println(nome+" obtendo saldo...");
return Deposito.balanco;
saldo=getSaldo();
}
System.out.println(nome+" saldo obtido "+saldo);
void setSaldo(int saldo){
saldo+=v;
try {
System.out.println(nome+" ajustando saldo para "+saldo);
Thread.sleep(5000);
setSaldo(saldo);
} catch(InterruptedException e) {}
System.out.println(nome+" saldo ajustado para "+
Deposito.balanco=saldo;
Deposito.balanco);
}
}
}

250 251

O Programa Exemplo:
O Programa Exemplo: Resultado
ThreadDeposito
class ThreadDeposito extends Thread {
Conta conta; ! Atribuição de um valor incorreto ao
int valor; saldo
String mens;
» Saldo = 2000
ThreadDeposito(Conta conta, int valor, String mens) {
this.mens=mens; ! Como resolver este problema?
this.conta=conta;
» Utilizando Monitores
this.valor=valor;
} • Semelhante a um local fechado aonde existe
public void run(){ apenas uma chave para se entrar
conta.deposito(valor, mens);
}
}

252 253

63
 Monitores Monitores
Monitor
! Como sincronizar o programa anterior?
Método 1 » Basta incluir a palavra reservada
chave
“synchronized” na definição do método
depósito
Método 2
» É criado um monitor no método depósito
» Apenas 1 programa pode acessar a
Threads Método 3 execução de depósito
Método 4

254 255

Applets com Threads Applets com Threads

public void start() {
import java.awt.*;
if (pedro==null) {
import java.applet.*;
pedro = new Thread(this);
public class Pedros extends Applet implements Runnable { pedro.start(); }
Image pedros[]=new Image[6]; }
int currentimg=0; public void stop(){
boolean sair; if (pedro != null)
Thread pedro; sair=true;
public void init() { }
pedros[0]=getImage(getCodeBase(), "pedro1.JPG"); public void run () {
pedros[1]=getImage(getCodeBase(), "pedro2.JPG"); while(!sair) {
setBackground(Color.yellow);
pedros[2]=getImage(getCodeBase(), "pedro3.JPG");
repaint(); pause(500);
pedros[3]=getImage(getCodeBase(), "pedro4.JPG"); currentimg++;
pedros[4]=getImage(getCodeBase(), "pedro5.JPG"); if(currentimg>5)
pedros[5]=getImage(getCodeBase(), "pedro6.JPG"); currentimg=0;
} }
}

256 257

64
 Applets com Threads O Caminho para JDBC
void pause(int time) {
try {Thread.sleep(time); }
catch(InterruptedException e) {}
! Grande desenvolvimento da linguagem
} Java
public void paint(Graphics g) {

}
g.drawImage(pedros[currentimg],0,0,this); ! Necessidade de uma API puramente
} JAVA para acesso a bancos de dados
! Sucesso do modelo de API ODBC da
Microsoft
! Em 1996 é lançado o kit JDBC

258 259

Características do JDBC Características do JDBC

Aplicativo Java
! Portabilidade ! Interfaces em
! API única, independente do Banco de camadas
Gerenc. de Driver JDBC
Dados subjacente ! Programador se
preocupa apenas
! Estrutura em Camadas Ponte ODBC Driver JDBC
com API do
gerenciador de
drivers Driver ODBC

! Drivers se ocupam
da interface com o Banco Banco
banco

260 261

65
 Instalando o JDBC A linguagem SQL

! O pacote JDBC vêm incluso com as ! Linguagem de manipulação de dados

distribuições Java ! Comandos Simples
! Deve-se obter um driver com o ! Mnemônica
fabricante do Banco de Dados ! Pequenas diferenças (extensões) de
! Pode-se usar a Ponte ODBC para um banco de dados para outro
acessar bancos que não possuam ! Comandos básicos padronizados
drivers JDBC

262 263

A linguagem SQL A linguagem SQL

! Comandos Importantes » Delete

» Insert • Exclui Registros de uma tabela
• Insere registros em uma tabela • Forma: Delete from <tabela> [ where
<condição>]
• Forma: Insert into <tabela>
(<campo1>,<campo2>,...) values • Exemplo: Delete from cliente
(<valor1>,<valor2>,...); • Exemplo: Delete from cliente where
cd_cliente <=20;
• Exemplo: Insert into cliente
(cd_cliente,nm_clente,cpf_cliente) values
(1,’Carlos Futino’,’9998998-09’);

264 265

66
 A linguagem SQL A linguagem SQL

» Update » Select
• Altera registros em uma tabela • Recupera registros de uma ou mais tabelas
• Forma: update <tabela> set • Forma: select <campo1>,<campo 2> ,...from
<campo1>=<valor1>, <campo2>= valor2> <tabela 1>,<tabela 2>,... [where <condição>]
[where <condição>] • Exemplo: select * from cliente,pedido where
• Exemplo: Update cliente set pedido.cd_cliente=cliente.cd_cliente
cd_cliente=cd_cliente+1; • Exemplo: select cd_cliente,nm_cliente from
• update fazenda set numero=numero+10 cliente
Exemplo: Update cliente set cd_cliente=1,
nm_cliente=‘Carlos’ where cd_cliente=0;

266 267

Usando BD em Java Conectando a uma base de dados

! Passos ! Carregando driver do banco

» Carregar o driver do banco » Class.forName("com.mysql.jdbc.Driver");
» Estabelecer uma conexão » Carrega uma classe pelo seu nome;
» Criar um canal para envio de comandos » Para isso o driver deve estar visível ao
» Executar os comandos projeto (configurar build path)
»

268 269

67
 Conectando a uma base de dados Conectando a uma base de dados

! Estabelecendo a conexão ! Atenção: A conexão pode gerar uma

» Classe Connection exceção, que deve ser tratada
» Usar método getConnection da classe » Código melhorado
DriverManager • try
» DriverManager.getConnection(url,usuariom {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver
senha); ");
Ex:Connection con = DriverManager.getConnection(“jdbc:odbc:myja
DriverManager.getConnection(“"jdbc:mysql:// vadb”,””,””);
10.0.0.18/projeto”,”usu",”123456" ); }catch (Exception e) {e.printStackTrace();
return;}

270 271

Statements Criando Statements

! Um Objeto da classe Statement é uma ! Método createStatement da classe

espécie de canal que envia comandos Connection
SQL através de uma conexão ! Statement
! O mesmo Statement pode enviar vários stmt=conexao.createStatement();
comandos » Onde conexao é um objeto da classe
! Para se criar um Statement, é preciso Connection
ter criado anteriormente uma conexão ! Nesse ponto o Statement existe mas
! Uma conexão suporta diversos ainda não executa código SQL nenhum
Statements

272 273

68
 Executando Statements Executando Statements

! Dois métodos possíveis ! executeQuery

! executeUpdate » Para comandos ”select” ou outros que
» Para comandos “insert”, ”update”, ”delete”, ou retornem dados
outros que alterem a base e não retornem
dados
» Forma: stmt.executeQuery(<comando>);
» Ex: ResultSet rs =
» Forma: executeUpdate(<comando>)
stmt.executeQuery(“Select * from cliente”);
» Ex: stmt.executeUpdate(“delete from cliente”);
» Retorna um objeto da classe ResultSet
» Retorna a quantidade de linhas impactada
pelo comando

274 275

Recuperando dados de ResultSets Recuperando dados de ResultSets

! Métodos getXXX ! Método Next

» getInt, getFloat, getString, getBoolean » Forma: rs.next()
getDate » Avança para o próximo registro retornado
» Recuperam um dado de acordo com o tipo » Retorna verdadeiro se existe um próximo
» Formas: rs.getXXX(<nome do campo>) ou registro, falso caso contrário
rs.getXXX(<posição do campo >) » Exemplo:
» Exemplo:rs. getString(“nm_cliente”) ou • while (rs.next())
rs.getString(2) {
System.out.println(rs.getString(2));
}

276 277

69
 Exemplos: Consulta Exemplos: Consulta
import java.net.URL; while (rs.next()) {
import java.sql.*; System.out.println("Nome: "+rs.getString(1)+" Fone:
import java.io.*; "+rs.getString(2));
public class Consulta{ }
public static void main(String args[]) throws IOException{ st.close();
String comando="SELECT * FROM FONES" ; con.close();
try{ }
Connection con; catch(Exception e){
Class.forName("com.mysql.jdbc.Driver"); e.printStackTrace();
con=DriverManager.getConnection("jdbc:mysql://localhost/banco", return;
}
”usuario",”senha"); System.in.read();
System.out.println("Conectado OK"); }
Statement st = con.createStatement(); }
ResultSet rs = st.executeQuery(comando);

278 279

Exemplos: Inserção Exemplos: Inserção

import java.net.URL; System.out.println("Concetado OK");
import java.sql.*; import java.io.*; Statement st = con.createStatement();
public class Insere{ st.executeUpdate(comando);
public static void main(String args[]) throws IOException{ System.out.println("INSERCAO OK");
String fonte="jdbc:odbc:javadb"; st.close();
String comando="INSERT INTO FONES con.close();
VALUES('"+args[0]+"','"+args[1]+"')" ; }
System.out.println(comando+"\n"); catch(Exception e){
try{ e.printStackTrace();
Connection con; return;
Class.forName("com.ashna.jturbo.driver.Driver"); }
con=DriverManager.getConnection("jdbc:JTurbo://rubi/javadb", }
"sa",""); }

280 281

70
 Statements Especiais Statements Especiais

! preparedStatements ! preparedStatements (Cont)

» Um Statement com um único comando » O comando SQL
SQL interno • Qualquer comando, na forma de uma string
• PreparedStatement pst= • Suporta parâmetros, que são simbolizados
con.prepareStatement(<comando>);
por pontos de interrogação.
» Os métodos executeQuery e • Configura o valor dso parametros por
executeUpdate não recebem parâmetros métodos setXXX

282 283

Statements Especiais Statements Especiais

! preparedStatement (cont) ! callableStatement

» Exemplo: » Usados para chamar Stored Procedures
• preparedStatement pst= » Sintaxe abstrata
con.prepareStatement(“insert into clientes • callableStatement cst=con.prepareCall(“{call
(cd_cliente,nm_cliente) values (?,?)”); <nome_da_SP>}”);
pst.setInt(1,10);
ps.setString(2,”Futino”); » Métodos setXXX, como nos
preparedStatements

284 285

71
 Transações Transações (Exemplo)

! Modo padrão: Compromissamento preparedStatement pst

pst=con.prepareStatement(“insert into fones
automático (auto_commit)
(nome,fone) values (?,?)”);
! Pode ser mudado para callableStatement cst
compromissamento manual cst=con.prepareCall(“{call insert_endereco}”);
! método setAutoCommit(<true|false>), con.setAutoCommit(false);
da classe Connection
! Métodos commit e rollback na conexão
para compromissamento manual

286 287

Transações (Exemplo) (Cont) Java Web

try { ! Java EE
pst.setString(1,”Carlos”);
pst.setString(2,”222-2222”); » plataforma de programação para servidores
cst.setString(1,”Futino”);
cst.setString(2,”Rua das Casas, 222”); Java
con.commit(); • Servlets: API que abstrai e disponibiliza os
} catch (SQLException e) { recursos do servidor Web de maneira
con.roolback(); simplificada para o programador.
System.out.println(“Erro: transação
• JSP (Java Server Pages): uma especialização do
abortada”);
servlet que permite que conteúdo dinâmico seja
}
facilmente desenvolvido.

288 289

72
 Java Web Java Web

! Java EE ! Java EE
» Deve ser executado em um servidor que » Preparando o ambiente
implemente os serviços relacionados a essa • Baixe um Apache Tomcat
plataforma – Basta baixar o arquivo compactado e extrair para uma
pasta do seu computador
• Jboss
• Glassfish • Configure um servidor no seu Eclipse
– Basta usar uma versão do eclipse para Java EE
• Apache developers
– Tomcat: implementa parte da especificação – Procure a perspectiva de servidores e crie um novo
servidor ligado ao Tomcat que você baixou

290 291

Java Web Java Web

! Projetos Web
» New Dynamic Web Project
» Configurar servidor Web associado
• Na aba servidores (servers) clique com o botão
direito no Tomcat e selecione add/remove.
! Estrutura
» Webcontent
» Web-Inf
• Web.xml: configurações do projeto web

292 293

73
 Java Web Java Web

! Páginas HTML ! Páginas HTML

» <html> » h1 - h6: define cabeçalhos, do h1 ao h6,
» <head> <title>Título </title> </head> onde menor o número, maior a importância
» <body> Corpo </body> do cabeçalho;
» a: cria um link para outra página, ou para
» </html>
algum ponto da mesma página;
» p: define que o texto dentro dela estará em
um parágrafo;

294 295

Mas
culi
no
<br

Java Web >

– <inp
Java Web
ut
type
! Páginas HTML
! Páginas HTML ="ra
dio" » Form: inclui formulários em páginas html
» ul: cria uma lista de elementos; nam
• <form> <input> <input> </form>
e="
» li: cria um novo item numa lista de sex" • input: coloca um controle de formulário na tela
valu
elementos; (caixa de texto, botão, radio button etc.)
e="f
» input: coloca um controle de formulário na ema
tela (caixa de texto, botão, radio button le">
Fe
etc.) mini
no
– <inp
ut
type
="c
hec
296 297
kbo
x"
nam
e="
bike
">
Eu
tenh
o
uma
bici
clet
a
<br
>
<inp
ut
type
="c
hec
kbo
x"
nam 74
e="
car"
>
 Java Web Java Web

! Páginas HTML ! Páginas HTML

» Form: inclui formulários em páginas html » table: define uma tabela;
• \input: controle de formulário • tr: uma linha da tabela;
– <input type="checkbox" name="bike"> bicicleta <br> • td: uma célula;
– <input type="checkbox" name="car"> carro <br> – <table>
– <input type="submit" value="Enviar"> – <tr> <td>Célula 1</td> <td>Célula 2</td> </tr> <tr>
– <select name="cars"> <td>Célula 3</td> <td>Célula 4</td> </tr> <tr>
» <option value=”ford">Ford <td>Célula 5</td> <td>Célula 6</td></tr>
» <option value="fiat">Fiat – </table>
– </select>

298 299

Java Web Java Web

! Projetos Web ! Primeiro Servlet

» New Dynamic Web Project » Gerador de página HTML
» Configurar servidor Web associado • Você pode dizer o que deve ser gerado de
conteúdo!
• Na aba servidores (servers) clique com o botão
– public class OiMundo extends HttpServlet {
direito no Tomcat e selecione add/remove.
– protected void service (HttpServletRequest request,
HttpServletResponse response) throws
ServletException, IOException {
! Inserir uma página – PrintWriter out = response.getWriter();
» <html><head> <title>Projeto Novo</title> </head> – out.println("<html>"); out.println("<body>");
» <body> Primeira página do projeto </body> </html> out.println("Primeira servlet"); out.println("</body>");
» Pasta Webcontent out.println("</html>"); } }

300 301

75
 Java Web Java Web

! Primeiro Servlet ! JSP

» Mapeando o Servlet no Web.xml » Servlets possuem problemas de
– <servlet> legibilidade e manutenção
– <servlet-name>primeiraServlet</servlet-name>
» <servlet-class>br.com.OiMundo</servlet-class>
» O ideal é que pudéssemos separar html e
– </servlet>
Java
» Criando um mapeamento para acesso » JSP veio resolver esse problema!
– <servlet-mapping> • Código Java pode ser escrito entre tags
» <servlet-name>primeiraServlet</servlet-name> – <% %>
» <url-pattern>/oi</url-pattern>
– </servlet-mapping>

302 303

Java Web Java Web

! JSP <html><body>
<%-- comentário em JSP --%>
» Toda página JSP possui uma variável
<% String mensagem = "Bem vindo!; %>
JSPWriter (para escrever na saída),
denominada out <% out.println(mensagem); %><br/>
<% String desenvolvido = "Desenvolvido por voce"; %>
»
<%= desenvolvido %><br /> <%
System.out.println("Tudo foi executado!"); %>
</body> </html>

304 305

76
 Java Web Java Web
Listando elementos de um BD ! JSP
<%@ page import="modelo.academico.*, java.util.*" %>
» Embora JSP tenha sido uma evolução em
<ul> relação a Servlets, ainda temos código
<% ControlePessoa control = new ControlePessoa(); Java misturado no HTML
List<Pessoa> todos = control.recuperarTodos(); • Dificulta vida do designer!
for (Pessoa p : todos ) { %>
<li><%=p.getRg()%>, <%=p.getNome()%></li>
» Solução:
<%} • Usar elementos associados à lógica HTML
</ul> para exibir dados dinâmicos

306 307

Java Web Java Web

! TagLibs ! JSTL
» Elementos HTML para programação Web » JavaServer Pages Standard Tag Library
» Exemplo: Trabalhando com POJO » Tags mais comuns para programação Web
• Construtor sem parâmetros e métodos get e com Java
set para atributos » Existem 4 grupos comuns de bibliotecas:
• <jsp:useBean id=”p"
• Core
class=“modelo.academico.Pessoa"/>
• Formatação
• ${p.nome}: invoca getNome no objeto p
• Internacionalização
• Manipulação de XML

308 309

77
 Java Web Java Web
! Declarando a TagLib ! Principais tags: forEach
» <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

! É necessário configurar o Web.xml! <jsp:useBean id="ctrl” class="modelo.academico.ControlePessoa"/>

<jsp-config> <c:forEach var="p" items="${ctrl.todos}">
<taglib> <taglib-uri>http://java.sun.com/jstl/core</taglib-uri> ${p.rg}, ${p.nome}, ${p.nascimento}
<taglib-location>/WEB-INF/c.tld</taglib-location> </c:forEach>
</taglib>
</jsp-config>

310 311

Java Web Java Web

! Principais tags: forEach ! Principais tags:

! <table border="1"> ! IF
» <c:if test="${not empty p.curso}"> ${p.curso}</c:if>
! <c:forEach var="p" items="${ctrl.todos}" varStatus="id">
! <tr bgcolor="#${id.count % 2 == 0 ? 'aaee88' : 'ffffff' }" >
! <td>${p.rg}</td><td>${p.nome}</td> ! When
» <c:choose>
! </tr>
» <c:when test="${not empty p.email}">
! </c:forEach> » <a href="mailto:${p.email}">${p.email}</a>
! </table> » </c:when>
» <c:otherwise> E-mail não informado </c:otherwise>
» </c:choose>

312 313

78
 Java Web Java Web

! Principais tags: ! Utilizando bibliotecas Javascript

! Importação de outras páginas ! Passo 1: baixar arquivos
» <c:import url="cabecalho.jsp" /> » http://jqueryui.com/download
» <c:import url=”rodape.jsp" /> » Copiar as pastas JS e CSS para sua aplicação
» Referencia-las nas páginas:
! Formatação
• <script type="text/javascript" src="js/jquery-1.9.1.js"></script>
» <fmt:formatDate value="${p.nascimento}" pattern="dd/MM/yyyy" />
• <script type="text/javascript" src="js/jquery-ui-1.10.3.custom.min.js"></script>
• <script type="text/javascript" src="js/jquery-ui-1.10.3.custom.js"></script>
! Saída
» <c:out value="${p.nascimento}” />

314 315

ChatBots ChatBots

! O que é um chatbot? ! Plataformas para criação de chatbots

» Robôs que interagem com o ser humano por » APIs de interação e manipulação de diálogos
meio da linguagem natural

316 317

79
 ChatBots ChatBots

! API Telegram
» Use o BotFather para criar seu bot

318 319

ChatBots ChatBots

! API Telegram ! API Telegram

» Anote o seu Bot Token!!! » Crie seu programa Java que escuta
interações com o seu Bot

320 321

80
 ChatBots ChatBots

! API Telegram ! Questões avançadas em ChatBots

» O ChatID é um identificador único para uma » Controlar conversas simultâneas
conversa. Podem existir várias conversas • Estrutura de dados contendo identificação das
simultâneas... interações
» Uso de processamento de linguagem natural
• Usar radical de palavras
• Usar dicionário de sinônimos

322 323

81