Java - I520

Java
Índice
•
•
•
•
•
•
•
•
•
•
•
Referências
UA 1 - Introdução a Java
UA 2 - Tipos de dados, operadores e comandos de fluxo
UA 3 - Uso classes e objetos: String, arrays, Math, outras
UA 4 - Criação de métodos, classes e objetos
UA 5 - Herança e polimorfismo
UA 6 - Classes abstratas e interfaces
UA 7 - Tratamento de exceções
UA 8 - Componentes gráficos em Java (AWT e Swing)
UA 9 - Multithreading
UA 10 - Acesso a banco de dados via JDBC
Objetivos
• Posicionar a linguagem Java no contexto do
desenvolvimento de sistemas;
• Conceituar os vários termos usados em Java
como Swing, Applets, Servlets, JSP, EJB,
etc.;
• Desenvolvimento de sistemas cliente
servidor com acesso a banco de dados
usando JDBC.
Pré-requisitos
• Noções de Programação
• Noções de Orientação a Objetos
• Noções de SQL
Livros
•
•
•
•
•
Java Como Programar
Beginning Java 1.3
The Java 2 Complete Certification Study Guide
Core Java 2: Guia Autorizado
The Java Class Libraries, Second Edition,
Volumes I e II
Internet
•
•
•
•
•
•
•
http://java.sun.com/
http://www.javaboutique.com/
http://www.javaworld.com
http://www.componentsource.com/java
http://www.jguru.com/portal
http://www.theserverside.com/
http://www.javareport.com/
Referências
Introdução a Java
O que é a linguagem Java?
O que é a linguagem Java?
•
•
•
•
Você aprenderá:
Histórico da linguagem.
Características mais importantes.
Versões existentes.
Uma aplicação inicial.
Histórico da Linguagem
• Projeto Oak
• 1990
• Integração de aparelhos
• Advento da internet
• 1994 lançamento oficial
• animações, applets e conexão com servidores
• JVM embutida nos browsers
• Panorama Atual
• Grande utilização nos servidores web
• Suportada pela grande maioria dos servidores de aplicação
• SGBD com JVM
Características importantes
• Orientada a objeto
– “Modificar é a regra e não a exceção”
• Interpretada e independente de plataforma
– JVM com JIT - Just in Time Compilers
• Multithreaded
– Executa, por natureza, vários trechos de código ao mesmo tempo
• Robusta e segura
– Fortemente tipada, sem acesso direto a endereços de memória evitando
erros de acesso e perda de ponteiros, applets sem acesso a disco, etc..
• Dinâmica e distribuída
– Alterações feitas apenas nas classes pertinentes sem a necessidade de
recompilação de todo o sistema. Possibilidade de “entrega” de
componentes pela rede de forma transparente para o usuário
Versões existentes
•
•
•
•
•
•
Versão 1.0
Versão 1.1 - Ainda muito usado
Versão 1.2 (Java 2) - Grandes mudanças
Versão 1.3
Versão 1.4
De uma versão para outra um método, atributos ou
mesmo uma classe inteira pode ficar “deprecated”
ou depreciada, obsoleta. Tenha sempre em mãos a
documentação apropriada.
Especializações do JDK
• JRE - Java Runtime Edition
– É o próprio interpretador Java, o mínimo necessário para executar
programas em Java. Browsers instalam apenas o JRE (5Mb aprox.).
• J2SE - Java 2 Standard Edition
– Também conhecido como JDK - Java Development Kit. É composto do
JRE, ferramentas de desenvolvimento e compilador (45Mb aprox).
• J2EE - Java 2 Enterprise Edition
– Complemento ao JDK que instala um conjunto de bibliotecas necessárias
para suportar Servlets, JSP, JDBC e outras (aprox. 17Mb).
• J2ME - Java 2 Micro Edition
– Simplificação da linguagem usada para desenvolvimento de aplicações
para palmtops e dispositivos hand-held
• Documentação
– Fornecido separadamente. Existem versões próprias para cada
especialização do JDK (aprox. 20Mb).
Alguns Ambientes de
Desenvolvimento
• Ferramentas de linha de comando
– Notepad :)
– TextPad
– UltraEdit
• Ferramentas visuais
–
–
–
–
–
Borland JBuilder
IBM Visual Age for Java
Visual Café
Oracle JDeveloper (facilidades para o DB)
MS Visual J++ (Evitem – problemas de
compatibilidade)
– iPlanet Fortè
Uma aplicação inicial
Comentários:
// - uma única linha.
/* ...*/ - várias linhas
/** .... */ javadoc
1
2
3
4
5
6
Nome da classe, também
define o nome do
arquivo.java
Método main( ).
Ponto de entrada
no sistema
// Isso é um programa exemplo
public class HelloWorld {
public static void main (String args[]) {
System.out.println(“Oi mundo!”);
}
}
{ } - chaves delimitam
um bloco de comando.
Case sensitive, sensível
à maiúsculas e
minúsculas
Obs.: Todo código Java tem que estar dentro de uma classe (class).
Classes serão usadas para criação de objetos, mas aqui, foi
colocada apenas por compatibilidade.
; - ponto-e-vírgula
é obrigatório ao final
de cada instrução.
Lab 01-B
caixa de mensagem
Objetivo:
– Aprofundar conceitos
Tarefas:
– Altere seu programa conforme o código abaixo:
1
2
3
4
5
6
7
8
9
// Programa exemplo
public class HelloWorld2 {
public static void main (String args[]) {
System.out.println("Antes da mensagem");
javax.swing.JOptionPane.showMessageDialog(null,
"Oi mundo!", "exercício Java",1);
System.out.println("Depois da mensagem");
}
}
Observe que as linhas 5 e 6 representam uma mesma
instrução.
Máquina Virtual Java (JVM)
Máquina Virtual Java (JVM)
Você aprenderá:
• O que é a máquina virtual Java.
• Por “dentro” da JVM
–
–
–
–
Class Loader.
Bytecode Verifier.
Interpretador
Garbage Collector.
O que é a máquina virtual
Java (JVM)
• É o ambiente onde os programas
desenvolvidos na linguagem Java são
executados.
• Responsável pela importante característica
de portabilidade de Java.
• Vem junto com o JDK e em alguns
browsers (Microsoft Internet Explorer e
Netscape Navigator) para execução de
applets.
Por “dentro” da JVM
Class Loader e Bytecode Verifier
• Class Loader - Carregador de classe
– Faz a carga de todas as classes necessárias para a
execução do programa feito em Java.
– Faz parte do esquema de segurança da linguagem.
• Bytecode Verifier - Verificador de Bytecode
– Testa o código contido no arquivo com extensão class
antes de executá-lo.
– Verifica se há código ilegal.
– Também faz parte do esquema de segurança da
linguagem.
Por “dentro” da JVM
Interpretador
• Lê os bytecodes e os traduz para uma
linguagem que o computador pode
entender.
• Armazena valores dos dados enquanto
executa o programa.
Por “dentro” da JVM
Garbage Collector
• O GC ou “coletor de lixo” é responsável
pelo gerenciamento da memória usada pelo
programa.
• Evita que acessos a posições inválidas de
memória sejam feitas pelos programadores.
• A implementação varia de acordo com a
plataforma considerada.
Lab 1.D
observação de erros comuns
Objetivo:
– Praticar o processo de edição-compilaçãoexecução de código Java
Tarefas:
– Resolvendo pequenos problemas (bugs)
ocorridos em tempo de compilação e execução.
Arquiteturas de
Desenvolvimento
O desenvolvimento de
sistemas
• As arquiteturas para desenvolvimento de
sistemas podem ser dividas em 3 grupos:
– 1-tier (1 camada)
– 2-tier (2 camadas)
– 3-tier (3 camadas)
Arquitetura 1-tier
• Arquitetura antiga onde as aplicações e os
dados residem em um único ambiente,
geralmente um computador central como os
mainframes. Os clientes são terminais
sem poder de processamento.
Arquitetura 2-tier
• Arquitetura recente e muito utilizada. Mais
conhecida como arquitetura cliente/servidor
(nome muito comum);
• Os componentes são geralmente o cliente,
residente em estações de trabalho, e o
servidor, residente em máquinas centrais, de
maior capacidade;
• O componente cliente faz solicitações que
são atendidas pelo componente servidor,
criando um interação contínua.
Arquitetura 2-tier
• Na arquitetura cliente/servidor, os dados
ficam armazenados em bancos de dados e é
necessário instalar o software nos clientes.
Clientes
(Front-End)
servidor
(banco de dados)
Oracle
Informix
Sybase
SQL Server
...
Arquitetura 3-tier
• Arquitetura diretamente derivada da
cliente/servidor, o modelo 3-tier foi uma
divisão lógica feita em relação ao modelo
precursor e que pode ser considerada o
padrão para o desenvolvimento de
aplicações baseadas na Web (Web-based
applications).
• Isola o cliente da base de dados.
Características
1a. Camada
Serviço de
Apresentação
cliente
(browser)
2a. Camada
Serviço de
Negócios
servidor
(servidor Web)
aplicação dinâmica
3a. Camada
Serviço de
Dados
servidor
(banco de dados)
Oracle
Informix
Sybase
SQL Server
...
Conceitos de Java no
Desenvolvimento de Sistemas
Programação Java
Conceitos Fundamentais
• Regras da linguagem - sintaxe;
• Estruturas de controle de fluxo;
• Métodos e classes - Programação
Baseada em Objetos;
• O estudo destes tópicos será foco deste
curso.
Programação Java
Conceitos Avançados
• Herança, polimorfismo, interfaces programação Orientada a Objetos;
• Tratamento de exceções
• Capacidade multithreding
AWT e Swing
• Classes Java usadas para criação de
interfaces gráficas para sistemas
cliente/servidor (2 camadas)
Applet
• Classe Java usada na arquitetura Web (3
camadas), mais especificamente na primeira
camada, encapsulado ao Browser.
Conectividade de banco de
dados Java - JDBC
• Tecnologia que permite acessar banco de
dados.
• Possui várias características importantes:
–
–
–
–
Modelo próprio de Serviços de Negócios
Reduz o risco do negócio
Permite a portabilidade entre plataformas
Especificado por Comitê
• O estudo de JDBC será foco deste curso.
Servlets
• Classes Java que executam dentro do servidor
Web (2ª camada);
• Possui várias características importantes:
– É executada dentro de processos especiais
– Pode ser chamado por múltiplos clientes, sejam eles feitos
em Java ou não.
– Processamento de pedidos concorrentes.
– Os métodos de um servlet são executados em threads.
– As instâncias de um servlet são reutilizadas quando
necessárias.
Java Server Pages - JSP
• Páginas HTML geradas dinamicamente no
Servidor Web (2ª camada);
• Possui várias características importantes:
– São independentes de plataforma, eficientes e
seguros.
– Separa a interface do usuário do conteúdo
dinâmico.
– Podem conectar-se a um JavaBean .
• O estudo de servles é foco do curso “Java II
- Servlets e JSP” do Instituto Infnet.
Enterprise JavaBeans - EJB
• Empacotamento de classes definidas como
componentes de software reutilizáveis.
• Possui várias características importantes:
–
–
–
–
Modelo próprio de Serviços de Negócios
Reduz o risco do negócio
Permite a portabilidade entre plataformas
Especificado por Comitê
UA “Introdução a Java” - BCA “Arquiteturas de Desenvolvimento e o Java ”
Tipos de Dados, Operadores
e Comandos de Fluxo
Tipos de Dados Primitivos
Identificadores
• Usados para identificar variáveis,
constantes, classes, instâncias de classe
(objetos), métodos, etc..
• Regras de formação de identificadores
• Algumas convenções estabelecidas
Identificadores
Principais regras
• Começa com letras ou _(sublinhado). $ é
válido mas deve ser evitado;
• Pode conter dígitos no meio ou no final;
• Há distinção entre maiúsculas e minúsculas;
• Não podemos usar caracteres acentuados de
qualquer tipo;
• Não podemos usar palavras reservadas.
Identificadores
Principais convenções
• Métodos e variáveis:
– Palavras simples - tudo em minúsculo
– Palavras compostas - Começa com minúscula
e a inicial das outras palavras em maiúscula.
• Constantes:
– Tudo em maiúsculo. Palavras compostas separadas com _
(sublinhado).
• Classes:
– Palavras simples - Começa com maiúscula
– Palavras compostas Começa com maiúscula
e a inicial das outras palavras em maiúscula.
• Arquivos:
– Mesmas convenções das classes.
Identificadores
Exemplos de identificadores válidos:
Botafogo
_teste20
$dinheiro
futebolProfissionalBrasileiro
nome_jogador
thisOne
TAXA_SERVICO
Os 8 Tipos Primitivos
•
•
•
•
•
•
•
•
byte
short
int
long
float
double
char
boolean
(8 bits)
(16 bits)
(32 bits)
(64 bits)
(32 bits)
(64 bits)
(16 bits)
(1 bit)
Numéricos sem
casa decimal
Numéricos com
casa decimal
Caracter da tabela unicode
true/false (não pode ser
numérico)
Os 8 Tipos Primitivos
Lógico – boolean
boolean status = true;
// os literais sempre em letra minúscula
Os 8 Tipos Primitivos
Textual – char - 16 bits - 2 bytes
char meuCaracter = ‘L’;
char meuCharUnicode = ‘\u0058’;
A contrabarra indica uma seqüência de
escape.
Os 8 Tipos Primitivos
‘\b’ - backspace
‘\t’ - tab
‘\f’ - form feed
‘\n’ - line feed
‘\r’ - carriage return
‘\’’ - aspas simples
‘\”’ - aspas duplas
‘\\’ - contrabarra
Os 8 Tipos Primitivos
Inteiros – byte, short, int e long
A diferença entre eles está no intervalo de
valores que cada um pode suportar
byte menor = 10; // 1 byte -128 a 127
short pequeno = 456;// 2 bytes
int normal = 10252; // 4 bytes
long muitoGrande = 6263732239; // 8 bytes
Os 8 Tipos Primitivos
Ponto flutuante – float e double
• float - precisão simples que utiliza 32 bits de
armazenamento. Tornam-se imprecisas para valores muito
grandes ou muito pequenos. Úteis quando precisamos de
um valor fracional sem grande necessidade de precisão.
Exemplo reais e centavos.
• Double - precisão dupla que utiliza 64 bits de
armazenamento.
float numeroReal = 10.9f;// 4 bytes
double numero = 6745.9E13;// 8 bytes
Variáveis
• Java é uma linguagem “fortemente tipada”
• Cada variável pode armazenar um único
tipo de dado.
• Cada variável possui:
–
–
–
–
Um identificador
Um tipo de dado
Um valor (pode ser null)
Um tamanho (definido pelo tipo)
Declaração de variáveis
 Toda variável deve ser declarada explicitamente
<tipo primitivo>< identificador > [ ,
< identificador2, ... > ][ = valor inicial ] ;
• Exemplos:
int numeroDias;
char opcao;
float cotacaoDolar;
boolean status;
double qtd1, preco1;
Inicialização de variáveis
• Variáveis possuem um escopo que determina em
que locais do código-fonte elas podem ser
visualizadas.
• Dependendo do local onde a variável for declarada
esta receberá um valor padrão (default).
• Exemplo:
int numeroDias;
numeroDias = 15;
ou
int numeroDias = 15, cont, f = 5;
Conversões e casting
• Não existe downcasting
• A conversão deve ser explícita
public class TiposPrimitivos{
public static void main(String args[])
{
int a = 4, b = 5;
int c;
c = a / b;
System.out.println("c = " + c);
double d;
d = a / b;
System.out.println("d = " + d);
c=0
d = 0.0
e = 0.8
Press any key...
double e;
e = (double) a / b; //Conversão deve ser explícita
System.out.println("e = " + e);
}
}
Conversões e casting
long grande = 890L;// inicialmente com 64 bits
int pequeno = (int) (grande); //coerção explícita
char letra = (char) 87 // Letra ‘W’
Lembre-se que fazer a coerção explícita,
podem surgir resultados imprevisíveis.
Operadores
Operador de atribuição
• Atribuição simples ( = )
• A expressão da direita é atribuída à variável
que está à esquerda.
x = 110;
Y = x + 12;
• Pode ser utilizado de forma encadeada
x = y = z = 55;
Operadores aritméticos
operadores binários
• Requerem dois operandos
• Operações aritméticas básicas
• Funciona com variáveis numéricas e literais
int
x =
y =
z =
x =
y =
x, y, z;
229 + 23;
73 – 9;
72 * 6;
y / z;
x % z;
//
//
//
//
//
adição
subtração
multiplicação
divisão
resto da divisão
Operadores aritméticos
operadores unários
• O operador ++ incrementa de 1
• O operador -- decrementa de 1
• Duas formas de utilização: pré-fixada e pósfixada.
int x, y;
x = 2;
y = x++; // pós-fixado => x = 3 e y = 2
x = 2;
y = ++x; // pré-fixado => x = 3 e y = 3
Operadores relacionais
>
>=
<
<=
==
!=
Maior que
Maior ou igual a
Menor que
Menor ou igual a
Igual a
Diferente de
Operadores lógicos
&
&&
|
||
^
!
E (longo)
E (curto)
Ou (longo)
Ou (curto)
Ou exclusivo
Não
longo - significa que todas as condições são avaliadas
curto - a avaliação da condição da esquerda já define o
resultado
exclusivo - se uma e apenas uma condição for true. Se
duas forem true resulta em false.
Operadores compostos
• O operador de atribuição pode ser
combinado com qualquer operador binário.
x = 110;
x += 12; // mesmo que x = x + 12
x /= 4; // mesmo que x = x / 4
Precedência
Ordem
1
2
3
4
5
6
7
8
9
10
11
Operador
++ -- + - ~ !(tipo)
* / %
+ < > <= >= instanceof
== !=
^
|
&&
||
?:
= += -= *= /=
Associatividade
D para E
E para D
E para D
E para D
E para D
E para D
E para D
E para D
E para D
D para E
D para E
Parênteses podem ser usados para alterar a precedência.
Comandos de Fluxo
Comandos de Decisão
if...else
• Executa, condicionalmente, um grupo de
comandos, dependendo do valor de uma
expressão. Caso só haja uma instrução no
bloco, as chaves poderão ser omitidas.
• Sintaxe:
if (condição) comandos [else comandos]
if (condição)
instrução ou bloco de instruções cercados por chaves
[else if (condição-n)
instrução ou bloco de instruções cercados por chaves]
[else
instrução ou bloco de instruções cercados por chaves]
if…else – exemplos
int x = 7;
if (x > abc)
// abc é uma variável definida
//em outra parte do programa
System.out.println(“x é maior que abc”);
else{
x += abc;
abc++;
}
if ( k < 20 ) j = 5 ; //é válido
if…else – exemplos
if aninhado
if ((salario >= 1000) && (salario < 2500))
IR = salario * 0.1;
else
if (salario < 5000)
IR = salario * 0.2;
else
IR = salario * 0.25;
Operador Condicional ?:
• Alternativa para o comando if... else.
• Sintaxe:
(expressão lógica) ? expressão 1 : expressão 2
int total = (salario < 1000) ? salario : salario – IR;
switch
• Executa um de vários grupos de comandos,
dependendo do valor de uma expressão.
• Sintaxe:
switch (expressão_teste) {
[case expressão constante 1:
comandos]
[default expressão constante n:
comandos]
}
• expressão_teste só pode ser do tipo byte,
short, int ou char
switch – exemplos
switch (diaSemana) {
case 1:
System.out.println(“Hoje é segunda-feira”);
break;
case 2:
System.out.println(“Hoje é terça-feira”);
break;
...
case 6:
System.out.println(“Hoje é sábado”);
break;
case 7:
System.out.println(“Hoje é domingo”);
break;
default:
System.out.println(“Opção inválida!!!”);
break;
}
switch – exemplos
switch (diaSemana) {
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println(“Hoje é dia de trabalho!!”);
break;
case 6:
case 7:
System.out.println(“Hoje é fim de semana!!!”);
break;
default:
System.out.println(“Opção inválida!!!”);
break;
}
Comandos de Repetição
• while.
• do...while.
• for
while
• Executa uma série de comandos enquanto
uma condição for verdadeira.
• Sintaxe:
while (condição) {
comandos
}
while - exemplo
int i = 0;
while (i < 10) {
a += 45;
i++;
}
do...while
• Repete um bloco de comandos enquanto uma
condição for verdadeira ou até que uma condição
seja verdadeira.
• Sintaxe:
do{
instrução ou bloco de instruções;
}while (condição);
• Pode-se omitir as chaves se o bloco tiver apenas
uma linha ou uma instrução.
for
•Repete um grupo de comandos em um número
específico de vezes.
•Sintaxe:
for (inicialização; terminação; incremento){
instrução ou bloco de instruções
}
inicialização - pode ser uma ou mais separadas por
vírgula
terminação - uma expressão lógica
incremento - pode ser um ou mais separados por vírgula
for
public class TestaFor{
public static void main(String args[])
{
for (int i = 0; i <=10 ; i++){
System.out.println("i = " + i);
for (int j = 1; j <= 20; j++){
System.out.println("\tj = " + j);
if (j == 5) break;
}
}
}
}
Comandos de Desvio
• break.
• continue.
• break e continue rotulados
break
• Sai incondicionalmente para primeira
instrução após um laço ou de uma instrução
switch.
1
2
3
4
5
6
7
8
9
10
for (int i = 1; i <= limite; i++) {
fatorial = 1;
for (int j = 2; j <= i; j++) {
fatorial *= j;
if (fatorial == 120)
break;// vai para linha 8
}
System.out.println(i + "! é " + fatorial);
}
System.out.println(“O valor do fatorial é “ + fatorial);
continue
• Abandona a iteração em que o laço se
encontra e vai incondiconalmente para a
próxima.
1
2
3
4
5
6
7
8
9
10
for (int i = 1; i <= limite; i++) {
fatorial = 1;
for (int j = 2; j <= i; j++) {
if (fatorial == 120)
continue;//vai para linha 3
fatorial *= j;
}
System.out.println(i + "! é " + fatorial);
}
System.out.println(“O valor do fatorial é “ + fatorial);
break e continue rotulados
• É utilizado para sair ou ir para a próxima
iteração dentro de laços aninhados.
1 loop_fora:
2
for (int i = 1; i <= limite; i++) {
3
fatorial = 1;
4
for (int j = 2; j <= i; j++) {
5
if (fatorial == 120)
6
break loop_fora;// vai para linha 11
7
fatorial *= j;
8
}
9
System.out.println(i + "! é " + fatorial);
10
}
11
System.out.println(“O valor do fatorial é “ + fatorial);
Lab 02.A
gráfico de barras horizontais
Objetivo:
– Exercitar o uso de tipos de dados primitivos,
declaração de variáveis e controles de fluxo de
programa.
Tarefas da etapa A:
– Usando a estrutura for faça um código que
desenhe na tela do sistema n pontinhos
horizontais.
Lab 02.C
gráfico de barras horizontais
Objetivo:
– Exercitar o uso de tipos de dados primitivos,
declaração de variáveis e controles de fluxo de
programa.
Tarefas da etapa C:
– Dado um programa que calcula a soma de dois
números entrados pelo usuário, faça um outro que
calcule a média dos números.