Apostila Poo

Programaa o
Orientada a Objetos
Curso de Sistemas de Informao
Este documento apresenta algumas notas de aula do curso de Programao Orientada a
Objetos. Este material no substitui o livro de referncia bsica do curso.

Sumrio
Nota de aula 1 ............................................................................................................................... 1
Classe e objetos ......................................................................................................................... 1
Objetos ...................................................................................................................................... 5
Variveis de instncia ou Atributos ........................................................................................... 7
Varivel versus Atributo ............................................................................................................ 8
Declarando um atributo ............................................................................................................ 8
Tipos de dados .......................................................................................................................... 8
Tipo de retorno ......................................................................................................................... 9
Corpo do mtodo .................................................................................................................... 10
Prefixos set e get para mtodos.............................................................................................. 10
Exerccios tericos ................................................................................................................... 11
Nota de aula 2 ............................................................................................................................. 12
Linguagem de programao Java ............................................................................................ 12
Particularidades da linguagem ................................................................................................ 12
A plataforma de desenvolvimento Java .................................................................................. 14
Comandos bsicos da linguagem Java .................................................................................... 14
Interface grfica para entrada de dados ................................................................................. 15
Entrada de dados via teclado - console .................................................................................. 16
Estruturas de controle em Java ............................................................................................... 16
Estrutura condicional: if ...................................................................................................... 16
Estruturas de seleo mltipla: switch ............................................................................... 17
Estruturas de repetio: while ............................................................................................ 18
Estruturas de repetio: do/while ...................................................................................... 18
Estruturas de repetio: for ................................................................................................ 18
Exerccios ................................................................................................................................. 18
No laboratrio ..................................................................................................................... 18
Exerccios complementares................................................................................................. 20
Nota de aula 3 ............................................................................................................................. 22
Modificadores de acesso ......................................................................................................... 22
Construtores ............................................................................................................................ 25
A palavra static ........................................................................................................................ 28

Modificador de acesso - Protected ......................................................................................... 29
Exerccios ................................................................................................................................. 32
No laboratrio ..................................................................................................................... 34
Nota de aula4 .............................................................................................................................. 37
Herana ................................................................................................................................... 37
Construtor chamando construtor da superclasse ................................................................... 42
Construtor chamando outro construtor da mesma classe. .................................................... 44
Relacionamento "tem um" ou composio ............................................................................ 45
Importante ........................................................................................................................... 48
Exerccios ................................................................................................................................. 48
No laboratrio ..................................................................................................................... 50
Nota de aula 5 ............................................................................................................................. 51
Sobrecarga de mtodos .......................................................................................................... 51
Reescrita de mtodos.............................................................................................................. 52
Chamando o mtodo original ................................................................................................. 54
Exerccios ................................................................................................................................. 56
No laboratrio ..................................................................................................................... 57
Nota de aula 6 ............................................................................................................................. 60
Polimorfismo ........................................................................................................................... 60
Polimorfismo de incluso ........................................................................................................ 60
Leitura complementar ......................................................................................................... 62
Exerccios ................................................................................................................................. 62
No laboratrio ..................................................................................................................... 62
Nota de aula 7 ............................................................................................................................. 64
A Classes abstratas "existem" ................................................................................................. 64
Particularidades das classes abstratas. ................................................................................... 66
Exerccios ................................................................................................................................. 67
No laboratrio ..................................................................................................................... 67
Nota de aula 8 ............................................................................................................................. 68
Interfaces de classe ................................................................................................................. 68
final .......................................................................................................................................... 73

Exerccios ................................................................................................................................. 73
No laboratrio ..................................................................................................................... 74
Nota de aula 9 ............................................................................................................................. 76
Arrays ...................................................................................................................................... 76
Arrays multidimensionais ou matrizes .................................................................................... 80
Classes Wrappers - Embrulhos ................................................................................................ 81
Classes Wrappers .................................................................................................................... 82
A classe List ............................................................................................................................. 84
Ordenando uma lista ........................................................................................................... 85
Remover elemento de uma lista ......................................................................................... 86
Como saber o tamanho de uma lista. ................................................................................. 87
Mostrar um elemento que est em uma determinada posio ......................................... 88
Exerccios ................................................................................................................................. 89
No laboratrio ..................................................................................................................... 90
Nota de aula 10 ........................................................................................................................... 92
GUI - Interface grfica com o usurio ..................................................................................... 92
Inserindo componentes na tela. ............................................................................................. 95
Os Gerenciadores de Layout ................................................................................................... 96
BorderLayout ....................................................................................................................... 98
FlowLayout ........................................................................................................................ 101
Importante ......................................................................................................................... 102
Frames internos .................................................................................................................... 103
Exemplo de Mscara de entradas para componentes da interface grfica ......................... 105
Exerccios ............................................................................................................................... 108
No Laboratrio .................................................................................................................. 108
Nota de aula 11 ......................................................................................................................... 109
Painis ................................................................................................................................... 109
JScrollPane ......................................................................................................................... 112
Menus em Java ...................................................................................................................... 116
Submenus .............................................................................................................................. 118

Radio Button ......................................................................................................................... 120
Checkbox ............................................................................................................................... 121
Listas ...................................................................................................................................... 123
Password ............................................................................................................................... 125
ComboBox ............................................................................................................................. 126
Exerccios ............................................................................................................................... 128
Nota de aula 12 ......................................................................................................................... 129
Usando o MigLayout ............................................................................................................. 129
Adicionar componentes em uma grade ................................................................................ 129
Mesclar e dividir clulas ........................................................................................................ 130
Usando coordenadas absolutas ............................................................................................ 131
Exerccios ............................................................................................................................... 132
Nota de aula 13 ......................................................................................................................... 133
Manipuladores de Eventos em Java ...................................................................................... 133
Evento para JButton .......................................................................................................... 133
Evento para JTextField ...................................................................................................... 139
Evento para JMenuItem .................................................................................................... 141
Eventos para JList .............................................................................................................. 143
Eventos para ComboBox ................................................................................................... 146
Eventos para JRadioButton ............................................................................................... 148
Eventos para JCheckBox .................................................................................................... 150
Exerccios ............................................................................................................................... 153
No Laboratrio .................................................................................................................. 153
Mais informaes .............................................................................................................. 153
Nota de aula 14 ......................................................................................................................... 154
Eventos para JTable ............................................................................................................... 154
"Ouvindo" as mudanas ........................................................................................................ 158
Inserindo e excluindo linhas na tabela .............................................................................. 161
Exerccios ............................................................................................................................... 165
Nota de aula 15 ......................................................................................................................... 166
Manipulando excees ......................................................................................................... 166
Manipulando arquivos .......................................................................................................... 170

Escrevendo em arquivos ....................................................................................................... 171
Lendo um arquivo escrito ..................................................................................................... 173
Exerccios ............................................................................................................................... 174
Nota de aula 16 ......................................................................................................................... 175
Banco de dados em Java ....................................................................................................... 175
Criando um novo projeto no Eclipse ..................................................................................... 176
Criando uma classe no Eclipse .............................................................................................. 176
Acessando o MySQL no Eclipse ............................................................................................. 177
Consulta ................................................................................................................................. 179
Delete .................................................................................................................................... 180
Altera ..................................................................................................................................... 181
Usando o NetBeans ............................................................................................................... 183
Exerccios ............................................................................................................................... 183
REFERNCIAS ............................................................................................................................. 189

Quando se desenvolve uma aplicao
utilizando o paradigma de
programao Orientado a Objetos, as
aplicaes so desenvolvidas a partir
de objetos. "Na programao
orientada a objetos, programa-se um
conjunto de classes que definem os
objetos presentes no sistema de
software. Cada classe determina o
comportamento (definidos nos
mtodos) e estados possveis
(atributos) de seus objetos, assim
como o relacionamento com outros
objetos."[8]
Bem vindo Programao Orientada
a Objetos

Programao Orientada a Objetos 1

Nota de aula 1

Ao final da aula o aluno ser capaz de:
Conceituar classes
Diferenciar classes de objetos
Identificar as partes de uma classe
Conceituar mtodos construtores
Conceituar mtodos operacionais
Instanciar objetos
Diferenciar atributos de variveis
Utilizar tipos de retorno nos mtodos

Classe e objetos
Vamos pensar no mundo real olhando a nossa volta. Podemos ver mouses, carros,
cadeiras, pessoas, fichas cadastrais, rvores etc. Sabemos que cada um desses itens so
objetos. Esses objetos tm caractersticas e tambm funcionalidades (fazem alguma
coisa).
Vamos tomar como exemplo uma Pessoa. Temos vrias formas de vermos uma Pessoa.
Se o observador for um mdico em seu consultrio no horrio de trabalho, ir ver a
pessoa como um paciente ento ir observar somente o que importante para ele na
funo de profissional da sade. Ele no interessa em saber qual o nmero do CPF
dessa pessoa por exemplo.
Se o observador for um funcionrio de recursos humanos de uma empresa ele ir querer
saber informaes da pessoa tais como CPF, RG, PIS, nmero da conta bancria e no
ir se interessar pela presso arterial da Pessoa, por exemplo.

Essas formas de ver o objeto Pessoa chamamos de Modelo Conceitual e para
desenvolver o modelo conceitual necessrio se concentrar no que mais relevante
para o problema.
Na Programao Orientada a Objetos temos que criar modelos conceituais de elementos
da natureza para construirmos os objetos. Os objetos no sero reais (objetos reais so
muito complexos) e sim um esboo de objetos com os dados mais relevantes para o
desenvolvimento do projeto.
A Programao Orientada a Objetos (POO) muda a forma de pensar em um programa.
Ela considerada um novo paradigma de programao. Geralmente construmos
programas pensando na soluo atravs de rotinas e funes.
Na POO devemos pensar em objetos e como esses objetos iro interagir entre si para
formar um programa. Um objeto dever ser capaz de "conversar" com outro objeto.
Quase tudo o que construirmos na POO sero objetos sendo assim devemos pensar:
Vou construir um objeto.
''O que esse objeto tem?"
"O que esse objeto faz?''
Para construir um objeto devemos montar primeiro o modelo conceitual e depois digitar
o cdigo em uma estrutura chamada classe. A classe um cdigo de programa que fica
armazenado no computador que depois de compilado ser o objeto.
Logo a classe pode ser entendida como um projeto de um objeto ou um molde para
construirmos objetos.
Quando escrevemos uma classe estamos criando a representao das propriedades e o
comportamento de um conjunto de objetos. Um sistema no possui somente uma
classe e sim vrias delas.

Quando vamos construir um objeto pensamos o que esse objeto tem e o que esse
objeto poder fazer. O que o objeto tem chamado de atributo ou propriedade do
objeto. O que o objeto faz chamado de mtodo ou funcionalidade do objeto. Ento
se a classe o projeto de um objeto ento devemos colocar na classe o que o
objeto ter e o que o objeto far.
Exemplo:
Para construir um objeto Pessoa.
1. - Construir o modelo conceitual de Pessoa.
2. - Construir o cdigo do modelo conceitual na classe chamada Pessoa.
3. - Na classe Pessoa devemos definir o que essa pessoa tem (atributos).
4. - Na classe Pessoa devemos definir tambm o que o objeto Pessoa poder fazer
(mtodos)
Digamos que o objeto Pessoa possua:
nome
telefone
Ento nome e telefone so atributos da classe Pessoa que se tornar o objeto Pessoa
depois de compilado.
Vamos ver como ficar a classe Pessoa.
class Pessoa{
String nome;
String telefone;
}
Os atributos so as propriedades ou caractersticas da classe (que se tornar um objeto
depois de compilado).


Observao:
Quando falamos da classe temos que ter em mente que ela ser o objeto depois de
compilada.
Bem esse objeto Pessoa dever fazer a recepo de um valor para o nome e um para
o telefone. Essa recepo indica o que ele capaz de fazer e neste caso receber
um nome e um telefone. Para que o objeto possa receber o nome ele deve ter
ummtodo que faa isso.
Vamos ver o cdigo.

class Pessoa{
String nome;
String telefone;

public String mostraNome() {
return nome;
}
public void recebeNome(String nome) {
this.nome = nome;
}
public String mostraTelefone() {
return telefone;
}
public void recebeTelefone(String telefone) {
this.telefone = telefone;
}
}
Veja que a classe acima possui os atributos nome e telefone do tipo String e possui
tambm os mtodos recebeNome(String nome), recebeTelefone(String telefone),
mostraNome() e mostraTelefone().

Os mtodos recebeNome(String nome) e recebeTelefone(telefone) devero ter como
argumento um nome e um telefonerespectivamente. O argumento nome passado para
o mtodo recebeNome(String nome) e o argumento telefone passado para o mtodo
recebeTelefone(String telefone) e depois eles so enviados para os
atributos nome e telefone respectivamente atravs do comando this.nome =
nome e this.telefone = telefone.
O comando this.nome indica que para atribuir nome para o atributo nome desta
classe e o comando this.telefone indica que para atribuir o telefone para o
atributo telefone desta classe.
Assim temos nossa classe que se tornar um objeto depois de compilado.
Podemos concluir ento que uma classe possui as seguintes partes:

Objetos
Projetamos o objeto na classe. Para se ter realmente o objeto necessrio coloc-lo na
memria do computador, isto , instanci-lo.
O objeto a cpia dos atributos e mtodos de uma classe na memria do computador.
Vamos utilizar novamente a classe Pessoa (que o projeto do objeto Pessoa) como
exemplo:
class Pessoa{
String nome;
String telefone;

public String mostraNome() {
return nome;
}
public void recebeNome(String nome) {
this.nome = nome;
}
public String mostraTelefone() {
return telefone;
}
public void recebeTelefone(String telefone) {
}
}
Vamos agora instanciar o objeto Pessoa a partir da classe Pessoa:
public class AppPessoa {
public static void main(String[] args){
Pessoa p = new Pessoa();
p.recebeNome("Maria");
p.recebeTelefone("98780976");
System.out.println(p.mostraNome());
System.out.println(p.mostraTelefone());
}
}
Veja que no cdigo acima foi instanciada a classe Pessoa que ento passa a ser o objeto
Pessoa.

Esse objeto Pessoa possui como varivel de referncia a letra p. Atravs da varivel de
referncia p podemos ter acesso aos atributos e mtodos o objeto.
Observe que depois do operador new temos um mtodo (possui parnteses () ).
Observe tambm que esse mtodo no foi declarado na classe Pessoa.
Veja tambm que esse mtodo tem o mesmo nome da classe e por isso ele chamado
de mtodo construtor.
Temos dois tipos de mtodos que so:
Mtodos construtores: Utilizados para construir os objetos.
Mtodos operacionais: utilizados durante o ciclo de vida do objeto.
Depois que construmos um objeto no mais utilizaremos o mtodo construtor para esse
objeto. Usaremos ento os mtodos operacionais.
Ento:
Pessoa() um mtodo construtor
mostraNome() um mtodo operacional.
recebeNome(String nome) um mtodo operacional.
mostraTelefone() um mtodo operacional.
recebeTelefone(String telefone) um mtodo operacional.
O exemplo acima est escrito no linguagem de programao JAVA. Ento vamos
entender um pouco mais sobre essa linguagem de programao.
Variveis de instncia ou Atributos
As classes possuem os atributos, tambm conhecidos por variveis de instncia, que
armazenam valores para as classes. nome daclasse Pessoa um atributo. Quando
instanciamos a classe, e ela se torna um objeto, esse atributo pode ser chamado
devarivel de instncia pois pertence a uma classe instanciada.
A funo do atributo armazenar valores para os objetos na memria.

Varivel versus Atributo
Uma varivel muito parecida com um atributo mas tem algumas diferenas que so:
Um atributo est no corpo da classe.
Uma varivel est no mtodo (como argumento ou no corpo do mtodo).
Um atributo ir ocupar memria somente quando uma instncia da classe for
executada.
Uma varivel ir ocupar memria quando a instruo que declara a varivel for
executada.
Variveis devem ser inicializadas.
Declarando um atributo
Em Java usamos:
Modificador (public, protected ou private)
Tipo de dados
Nome da varivel de instncia
Ponto-e-vrgula
Tipos de dados
Os tipos de dados informam o quanto de memria o computador ir alocar para
armazenar um dado.
A tabela abaixo mostra os tipos de dados primitivos utilizados em Java.
Tipo de dados Faixa de valores
byte -128 a 127
short (curto) -32.768 a 32.767
int (inteiro) -2.147.483.648 a 2.147.483.647
long (longo) -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807
char (caractere) 65000
float (vrgula flutuante) 3.4e-038 a 3.4e+038

double (duplo) 1.7e-308 a 1.7e+308
boolean (booleano) true (verdadeiro) ou false (falso)

Nome do atributo
Para nomearmos atributos devemos sempre utilizar letras minsculas.

Nome do mtodo
Para nomearmos um mtodo devemos sempre utilizar a primeira letra minscula e se ele
for composto a segunda letra dever ser maiscula sem espaos entre elas. Exemplo:
cadastroContas();
mostraNome();
mostraTelefone();
Os mtodos so as funcionalidades do objeto (o que o objeto pode fazer) e so divididos
em dois que so:
Mtodos construtores
Mtodos operacionais
Os mtodos so declarados como a seguir:
Modificador (public, private ou protected)
Tipo de retorno (se for operacional)
Nome do mtodo
Lista de argumentos do mtodo (opcional)
Corpo do mtodo delimitado por chaves
Tipo de retorno
Os mtodos que retornam valores so os mtodos operacionais. Mtodos sempre
manipulam os atributos e devem ter como tipo de retorno o mesmo tipo de retorno do
atributo.
A sintaxe para a construo de um mtodo :

modificador tipo_de_retorno nomeDoMetodo([argumentos]);
Exemplo:
void recebeNome(String nome){
this.nome = nome;
}
Podemos ver que o tipo de retorno do mtodo acima vazio representado por void na
programao.
Corpo do mtodo
O corpo do mtodo composto por um bloco de cdigo onde inserimos as instrues
que dizem o que o mtodo ir fazer. Instrues como (if, for, while, case....) so usadas
sempre dentro do corpo de um mtodo.
Prefixos set e get para mtodos
Ao programar utilizando a linguagem Java iremos encontrar vrios mtodos com os
prefixos set e get. Esses prefixos no tm poder especial na programao, isto , no
fazem nada de especial eles somente dizem ao programador o que o mtodo ir fazer.
Um mtodo como pr-fixo set indica que esse mtodo ir atribuir (configurar, setar) um
valor para um atributo e mtodos com prefixos get dizem que o mtodo ir mostrar um
valor. Os mtodos com pr-fixo get geralmente possuem um retorno.
No exemplo da classe Pessoa podemos alterar os nomes dos mtodos recebeNome(),
recebeTelefone(), mostraNome() e mostraTelefone() por setNome(), setTelefone,
getNome() e getTelefone(). Vejamos o exemplo no cdigo abaixo:
class Pessoa{
String nome;
String telefone;

public String getNome() {
return nome;

}
public void setNome(String nome) {
this.nome = nome;
}
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
}
}

Exerccios tericos
1. Defina o que um modelo conceitual
2. O que uma classe?
3. A afirmativa: "Um objeto construdo a partir de uma classe" verdadeira?
Justifique sua resposta.
4. Quantos o objetos podemos instanciar (criar) a partir de uma classe?
5. Para que servem os mtodos na orientao a objetos?
6. Quais as partes de uma classe?
7. O que devemos fazer para construir um objeto?
8. O que uma varivel de referncia?
9. O que um atributo?
10. Qual a diferena entre atributo e varivel?
11. Explique os passos necessrios para acionar um mtodo operacional.
12. Defina acesso direto a um atributo.
13. Defina acesso indireto ao um atributo.
14. Defina mtodo construtor.
15. Defina mtodo operacional.

Nota de aula 2

Utilizar comandos da linguagem Java para ler dados.
Utilizar comandos da linguagem Java para mostrar dados.
Utilizar estruturas de controle na linguagem Java.

Linguagem de programao Java

A linguagem Java :
Parcialmente Orientada a Objetos
uma linguagem de alto nvel
uma linguagem multithread
Possui arquitetura neutra
Linguagem multiplataforma
etc.
A tecnologia Java composta por uma linguagem de programao e uma mquina
virtual que permite seus cdigos serem executados em diversas plataformas.
Utilizamos um editor ASCII para escrever os cdigos da linguagem Java. Neste curso
iremos utilizar o Eclipse para escrever os cdigos porque ele disponibiliza vrias
facilidades para o programador.
Particularidades da linguagem
Java Case Sensitive (diferencia letras maisculas de minsculas).
Java fortemente tipada (deve declarar variveis).
Nome do arquivo deve ser o mesmo nome da classe.
Exemplo:

Se tivermos a classe Pessoa ento o nome do arquivo deve ser Pessoa. Esse arquivo ter
que ter a extenso .java.
Depois de escrito o cdigo (classe) ento devemos compilar o cdigo (da classe).
Depois de compilado o cdigo (.java) gerado um cdigo .class que tambm chamado
de bytecode. O cdigo .class ento interpretado pela mquina virtual java e finalmente
executado.
Ento arquivos com extenso .java possuem o cdigo fonte e arquivos com
extenso class so os bytescodes que a mquina virtual java (JVM) ir interpretar.
Veja a figura abaixo que mostra todo o processo:

Podemos na figura acima que a linguagem Java compilada e interpretada. O cdigo
fonte (.java) depois de compilado se transforma em bytecodes (.class) que so
interpretados pela mquina virtual Java (JVM).
Podemos utilizar o mesmo cdigo (.class) em vrios sistemas operacionais desde que
cada sistema operacional tenha uma mquina virtual Java para interpretar esse cdigo.


A plataforma de desenvolvimento Java
A plataforma Java possui dois componentes:
Java Virtual Machine - JVM ou Mquina Virtual Java (MVJ);
Java Application Programming Interface(API)

Comandos bsicos da linguagem Java
Para escrever uma mensagem no console em Java, utilizamos o comando
System.out.println("mensagem");
Ou
System.out.print("mensagem");
O primeiro comando imprime uma mensagem no console e salta uma linha (println), o
segundo imprime uma mensagem na tela e continua na mesma linha.
O programa abaixo escreve Programao Orientada a Objetos na tela.
public class EscreveNaTela{
System.out.println("Programao Orientada a Objetos");
}
}
Veja que o programa est dentro de uma classe que se chama EscreveNaTela. Logo esse
arquivo deve ser gravado como EscreveNaTela.java. Depois de compilado ele ir gerar
um arquivo chamado EscreveNaTela.java e esse arquivo ser interpretado pela JVM.

Observe tambm que temos a linha de comando

Essa linha de comando (mtodo) prprio da linguagem java e indica que esse
programa uma aplicao (pode ser executado). Na programao orientada a objetos
temos vrios objetos que comunicam entre si mas geralmente somente um objeto o
executvel e para ser executvel necessrio que ele tenha o mtodo abaixo:

Interface grfica para entrada de dados
Para utilizar a interface grfica da linguagem Java importamos (import) o pacote
javax.swing que j est na API da linguagem.
import javax.swing.*;
public class Aula{
//declara x do tipo inteiro
int x;
//declara sx do tipo string
String sx;
//faz a leitura e grava em sx
sx = JOptionPane.showInputDialog("Digite o valor de x");
//converte sx(string)inteiro
x = Integer.parseInt(sx);
//mostra o resultado na janela grfica.
JOptionPane.showMessageDialog(null,"Valor de x: " +x);
}
}

Entrada de dados via teclado - console
O programa abaixo mostra a entrada de dados via teclado utilizando o console e mostra
as informaes tambm no console.
import java.util.Scanner;

public class EntradaDeDados{
String nome;
int idade;

Scanner s = new Scanner(System.in);

System.out.println("Idade:");
idade = s.nextInt();

s.nextLine();

System.out.println("Nome:");
nome = s.nextLine();

System.out.println("Nome: "+nome);
System.out.println("Idade: "+idade);
}
}

Estruturas de controle em Java
Estrutura condicional: if
if(condio){

//comandos;
}
Ou
if(condio){
//comandos1;
}
else{
//comandos2;
}

Estruturas de seleo mltipla: switch
switch(opo){
//opo pode ser do tipo byte, short, int ou char
case opcao1:
comandos1;
break;
case opcao2:
comandos2;
break;
. .
.
case opcaon:
comandosn;
break;
default:
comandos;
}

Estruturas de repetio: while
while(condio){
comandos;
}

Estruturas de repetio: do/while

do{
comandos;
}while(condio);

Estruturas de repetio: for
for(inicializa; condio; incremento){
comandos;
}
Consulte o livro "Java: Como Programar" - Deitel nos captulos 4 e 5 para revisar as
estruturas de controle.

Exerccios
No laboratrio
1. Escrever um programa em Java que mostre seu nome na tela utilizando o
console.
2. Escrever uma classe chamada Calculadora que contenha os atributos rSoma,
rSub, rDiv, rMult sendo todos do tipo float.
a) Sua classe dever ter tambm os mtodos setSoma, setSubtrai, setDivide
e setMultiplica.

b) Cada mtodo dever possuir dois argumentos (num1 e num2).
c) O mtodo setSoma dever somar os dois argumentos e coloc-los no
atributo rSoma.
d) O mtodo setSubtrai dever subtrair os dois argumentos e coloc-los no
atributo rSub.
e) O mtodo setDivide dever Dividir os dois argumentos e coloc-los no
atributo rDiv. Verifique se o denominador diferente de zero.
f) O mtodo setMultiplica dever multiplicar os dois argumentos e coloc-
los no atributo rMult.
g) Sua Classe dever ter tambm os mtodos getSoma, getSubtrai,
getDivide e getMultiplica e cada mtodo dever retornar o valor da
soma, subtrao, diviso e multiplicao respectivamente.
3. Escrever um programa em Java que mostre a soma de dois nmeros quaisquer.
Os nmeros podem ser inseridos no cdigo do programa.
4. Escrever um programa para mostrar os nmeros de 1 a 100 na tela utilizando a
estrutura de repetio while.
estrutura de repetio do while.
estrutura de repetio for.
7. Escrever um programa para ler um nmero e verificar se ele positivo ou
negativo. Utilize o console para fazer a leitura.
8. Escreva um programa que solicite o nome de uma pessoa utilizando a interface
grfica. Mostre o nome digitado utilizando a interface grfica.
9. Escreva um programa que solicite o nome de uma pessoa utilizando o console.
Mostre o nome digitado utilizando o console.
10. Escreva um programa que mostre a figura abaixo na tela - no necessrio
utilizar comandos de repetio para este exerccio.
*
***

*****
*******
*********
10. Escreva o programa anterior utilizando os comandos de repetio.

Exerccios complementares
1. Escreva um programa para calcular o n-simo termo da srie de Fibonacci. A
entrada dever ser utilizando a janela grfica
2. Escreva um programa para calcular a diviso de dois nmeros quaisquer,
utilizando a entrada grfica.
3. A empresa RGS Ltda. concedeu um bnus de 20 por cento do valor do salrio a
todos os funcionrios com tempo de trabalho na empresa igual ou superior a
cinco anos e dez por cento aos demais. Calcular e exibir o valor do bnus.
4. Ler o cdigo de um produto e exibir o seu nome de acordo com a tabela abaixo:
Cdigo do produto Nome do produto
1 Caderno
2 Lpis
3 Borracha
5. Ler 280 nmeros fornecidos pelo usurio calcular e exibir a mdia. (utilize do-
while)
6. Ler 280 nmeros fornecidos pelo usurio calcular e exibir a mdia. (utilize
while)
7. Ler 280 nmeros fornecidos pelo usurio calcular e exibir a mdia. (utilize for)
8. Um aluno realizou trs provas de uma disciplina. Considerando o critrio
abaixo, faa um programa que mostre se ele ficou para exame; em caso positivo,
qual nota esse aluno precisa tirar no exame para passar.

mdia = (prova1 + prova2 + prova3)/3 A mdia deve ser maior ou igual a 7,0. Se no
conseguir, a nova mdia deve ser: final = (mdia + exame)/2 Nesse caso, a mdia final
deve ser maior ou igual a 5.
9. A srie de RICCI difere da srie de FIBONACCI porque os dois primeiros
termos so fornecidos pelo usurio. Os demais termos so gerados da mesma
forma que a srie de FIBONACCI. Criar um programa que imprima os N
primeiros termos da srie de RICCI e a soma dos termos impressos, sabendo-se
que para existir esta srie sero necessrios pelo menos trs termos.


Nota de aula 3

Utilizar os modificadores de acesso public, private e protected.
Difenciar os tipos dos modificadores de acesso.
Utilizar mtodos construtores.
Utilizar variveis e mtodos estticos.

Modificadores de acesso
Os modificadores de acesso manipulam a visibilidade de um atributo ou mtodo da
classe.
Temos trs tipos de modificadores de acesso que so:
public - modificador de acesso pblico
protected - modificador de acesso intermedirio entre o modificador public e o
modificador private
private - modificador de acesso privado
O modificador public torna diponvel para acesso os atributos e mtodos de uma classe
para todas as classes do sistema. Quando um atributo possui um atributo public isso
significa que ele pode ser acessado diretamente como mostra o exemplo abaixo:
public class Pessoa{
public String nome;
public int idade;
}
O cdigo acima diz que os atributos nome e idade da classe Pessoa so pblicos e
sendo assim podem ser acessados diretamente.
Vejamos:

public class AcessoPublico{
public static void main (String[] args){
//instancia o objeto Pessoa
//Acessando diretamente o atributo nome
p.nome = "Ana";
//fazendo acesso direto ao atributo idade;
p.idade = 39;
}
}
No cdigo acima acessamos diretamente os atributos nome e idade'. Quando fazemos
um acesso direto, qualquer valor atribudo ao atributo ser aceito. Sabemos que a idade
de uma pessoa no pode ser negativa. Quando fazemos um acesso direto ao atributo
idade possvel inserir qualquer valor para a idade sendo eles positivos ou negativos.
Para solucionar esse problema temos que "proteger" o atributo idade. Para fazermos
isso devemos colocar a frente o tipo do atributo a palavra private. Veja o cdigo
abaixo:
Vejamos o cdigo:
public class Pessoa {
private String nome;
private int idade;

void setIdade(int idade){
if (idade >= 0) {
this.idade = idade;
}
else{
System.out.print("Idade invlida");

}
}
}
No cdigo acima foi implementado o mtodo void setIdade(String idade) que ir validar
se a idade da pessoa positiva.
Agora se o programador tentar acessar diretamente o atributo idade o compilador ir
emitir o seguinte erro:
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
Syntax error, insert "AssignmentOperator Expression" to complete Expression
The field Pessoa.idade is not visible

at mateiralaula.AppPessoa.main(AppPessoa.java:10)
O erro acima diz que o atributo idade no est visvel.
Para atribuir um valor ao atributo idade necessrio fazer um acesso indireto, isto ,
utilizando o mtodo como mostra o exemplo abaixo:
private int idade;

if (idade >= 0) {
this.idade = idade;
}
else{
}
}


int getIdade(){
return this.idade;
}
}
Veja que foi necessrio escrever um mtodo (int 'getIdade()) para retornar a idade que
est gravada no atributo idade'. Sem esse mtodo no possvel ler o que est gravado
em um atributo privado.
Veja no cdigo abaixo como atribuir um valor para o atributo idade e como mostrar o
valor atribudo a esse atributo.
public static void main(String[] args) {
p.setIdade(34);
System.out.println("A idade "+p.getIdade());
}
}
Veja que para podermos mostrar a idade na tela devemos utilizar o
comando System.out.println() da linguagem Java.
Construtores
O mtodo construtor utilizado somente para construir objetos. Depois de construdo
um objeto o mtodo construtor no mais utilizado.
Veja o cdigo abaixo:
O construtor incializa os atributos quando um objeto construdo. Se o atributo for:
Tipo String inicializado com null;
Tipo numrico inicializado com zero

Tipo booleano inicializado com false
Tipo objeto inicializado com null.
public class Pessoa{//declarao de atributos
static String nome;
static int idade;
static boolean ativa;
System.out.println("Nome: "+Pessoa.nome);
System.out.println("Idade: "+Pessoa.idade);
System.out.println("Est na ativa: "+Pessoa.ativa);
}
}
A sada ser
Nome: null
Idade: 0
Est na ativa: false
Se voc escrever o cdigo de uma classe em Java e no escrever o cdigo do construtor
a linguagem Java cria um automaticamente para voc. O construtor criado pela
linguagem Java possui o seguinte cdigo:
Pessoa(){}
O cdigo acima mostra o construtor criado pela linguagem Java se voc no cri-lo.
Caso voc escreva o cdigo para um construtor, usando argumentos por exemplo, o
construtor padro (mostrado acima) no poder mais ser utilizado automaticamente.
Voc deve ento criar seu construtor com argumentos e o construtor padro.
Uma boa dica de programao voc sempre criar o construtor padro nos seus
cdigos.
Exemplo:

private int idade;

Pessoa(int idade){
this.idade = idade;
}

if(idade >= 0){
this.idade = idade;
}
else{
}
}
}
Se tentarmos criar um objeto da classe Pessoa acima utilizando o cdigo:
p.setIdade(39);
p.idade = 34;
}
}
Isso ir gerar um erro como mostrado abaixo:
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
The constructor Pessoa() is undefined
The method setIdade(int) is undefined for the type Pessoa

at mateiralaula.AppPessoa.main(AppPessoa.java:5)

A palavra static
A palavra static cria uma varivel nica (neste caso numeroDePessoas) que
ser compartilhada por todos os objetos dessa classe. Vamos lembrar que tendo uma
classe ns podemos instanciar vrios objetos. Se a classe tem um atributo esttico
(static) ento esse atributo poder ser compartilhado por todos os objetos que foram
instanciados dessa classe.
Vejamos:
private int idade;
public static int numeroDePessoas;

Pessoa(){
numeroDePessoas++;
}

Pessoa(String nome){
this.nome = nome;
}

Pessoa(int idade){
this.idade = idade;
}

Pessoa(String nome, int idade){
this(nome);

this.idade = idade;
}

}
Pessoa p1 = new Pessoa();
System.out.println("Total de pessoas: "+p4.numeroDePessoas);
}
}
A sada do cdigo acima ser:
Total de pessoas: 5
Se voc usar qualquer objeto para mostrar o nmero de pessoas o resultado ser o
mesmo porque o atributo numeroDePessoasest compartilhado com todos os objetos
dessa classe.

Modificador de acesso - Protected
Vamos agora verificar o comportamento do modificador de acesso protected nas
classes. Vejamos o cdigo abaixo que possui uma classe chamada Classe1 e esta classe
est em um pacote chamado p1. Lembre-se que um pacote muito parecido com uma
pasta do sistema de arquivos do Windows. O cdigo da classe Classe1 est dentro do
pacote p1.
package p1;
public class Classe1 {
protected int x;

}
Veja que a primeira linha do cdigo acima o package p1 isso faz com que a
clsse Classe1 seja criada dentro do pacote p1.
Veja tambm que o atributo x do tipo inteiro e est com o modificador de
acesso protected. Isso significa que se quisermos acessar esse atributo x de um outro
pacote ento devemos criar na Classe1 um mtodo que permita o acesso.
Vamos analisar a figura abaixo:

Veja que a classe Classe2 est em um pacote chamado p2. O pacote p1 foi importado
(import) porque nele est a classe Classe1mas quando tentamos acessar o atributo x da
classe Classe1 que est protegido (protected) o compilador sugere que:
O atributo int x seja modificado para public ou
Que seja criado um mtodo getter (get) e um mtodo setter (set) para acessar o
atributo x.
Os mtodos get e set sugeridos pelo compilador devem ser criados na
classe Classe1 como mostra o cdigo abaixo.
package p1;

protected int x;

void setX(int z){
this.x = z;
}

int getX(){
return this.x;
}
}
Agora quando quisermos utilizar o atributo x devemos utiliza os mtodos getX e setX.
Veja agora o cdigo abaixo:
package p1;

Classe1 c3 = new Classe1();
c3.x = 10;
}
}
O cdigo acima est no mesmo pacote que a Classe1 e ele acessou diretamente o
atributo x sem problemas.
Ento podemos concluir que quando um atributo possui o modificador de
acesso protected, esse atributo pode ser acessadodiretamente por classes que
estejam no mesmo pacote e classes que esto em pacotes diferentes devem utilizar os
mtodos set e get da classe que possui o atributo protected para poer ter acesso.

Quando no colocamos nenhum modificador de acesso, dizemos que o atributo tem
acesso default que no o mesmo que acesso pblico. O acesso default no permite
acesso de pacotes diferentes.

Exerccios
1. Pela conveno, qual o prefixo utilizado em mtodos que retornam boolean?
2. Quais as principais caractersticas de um construtor?
3. Qual a sintaxe para acessar um atributo esttico dentro de um mtodo esttico
4. Escreva um exemplo que utilize um mtodo esttico
5. Qual a funo do modificador public
6. Escreva um exemplo (classe) que utiliza o modificador private e public
7. Qual a funo de um mtodo que possui get como prefixo no nome?
8. Escreva um programa que utilize um mtodo get.
9. Atributos do tipo String e atributos do tipo de uma classe (objetos) so
inicializados com null. Por qu?
10. Qual a funo do modificador private?
11. Escreva um exemplo que utilize o modificador private
12. O que um atributo static?
13. O que acontece, em java, quando criamos uma classe e no definimos um
construtor para ela?
14. Qual a funo de um mtodo que possui set como prefixo no nome?
15. Escreva um programa que utilize um mtodo set.
16. Quais so os trs tipod de modificadores de acesso?
17. O que um "acesso direto"?
18. O que um construtor?
19. O que acontece com o construtor padro quando criamos um construtor na
classe?
20. Atributos so inicializados autmoaticamente. Qual o valor inicial para tipos
numricos primitivos, String, objetos e boolean?

21. Uma classe chamada ClasseA possui o construtor ClasseA(int x). A ClasseB
herda da ClasseA e quer utilizar o construtor da ClasseA passando como
argumento o valor 10. Para que isso acontea, qual a linha de comando dever
ser escrita pelo desenvolvedor?

a) super(ClasseA());
b) super.ClasseA(10);
c) super(10);
d) ClasseA(10);
e) n.d.a.

22. Faa o rastreio do cdigo abaixo:

public class ExemploStatic {

int x;


int y;

y = 93;

x = y % 2;

System.out.println("O valor de x ser: "+x);
}
}

a) 1
b) 0
c) Apresenta um erro porque x deve ser esttico
d) apresenta um erro porque y deve ser esttico
e) n.d.a.

23. Escreva qual o tipo de relacionamento ( um ou tem um) existe entre as classes
abaixo:

a) Classe Imvel e classe Casa ______________________________
b) Classe Casa e classe Endereco ____________________________
c) Classe Conta e classe Cliente _____________________________
d) Classe Cliente e classe PessoaFsica _______________________

e) Classe Professor e classe Alunos __________________________

24. A melhor definio para modificadores de acesso :

a) O modificador de acesso compartilha o atributo para todos os objetos da classe.
b) Todos os modificadores de acesso no permitem que o atributo seja herdado
pelas subclasses da classe que o contm.
c) O modificador de acesso faz com que mtodos devam ser reescritos na classe
filha.
d) Os modificadores de acesso manipulam a visibilidade de um atributo ou mtodo
da classe.
e) n.d.a.

25. Quanto aos tipos de acesso a um atributo podemos afirmar que:

a) Acesso direto feito utilizando-se a varivel de referncia a um objeto, o
operador ponto e o nome do atributo.
b) Acesso direto feito utilizando-se a varivel de referncia, ponto e o mtodo que
acesso o atributo private.
c) Acesso direto feito utilizando-se a varivel de referncia, ponto e o nome do
atributo private.
d) Acesso direto feito utilizando-se a varivel de referncia, ponto e o nome do
atributo public.
e) n.d.a.

No laboratrio
1. Inicie o Eclipse e escreva o cdigo abaixo:
package br.aula.pacote;
public class Conta {
public float saldo;
}
2. Agora construa outra classe chamada AppConta e escreva o cdigo abaixo:
package br.aula.pacote;
public class AppConta {

Conta c = new Conta();
c.saldo = 100;
System.out.println("Saldo: "+c.saldo);
}
}
Veja que as duas classes esto no mesmo pacote (br.aula.pacote). Qual foi a sada do
programa?
3. Agora escreva o cdigo abaixo:
package br.aula.pacote2;
import br.aula.pacote.Conta;

public class AppConta3 {
Conta c2 = new Conta();
c2.saldo = 100;
System.out.println("Saldo: "+c2.saldo);
}
}
Observe que este cdigo est em outro pacote que o br.aula.pacote2 e que foi
importado a classe Conta do pacote pacote na linha import br.aula.pacote. Qual foi a
sada do cdigo acima? Se apresentou um erro, qual a soluo para o erro?
4. Construa uma classe chamada Cliente com os atributos nome e telefone. Crie os
mtodos get e set para configurar os atributos. Leve em considerao o
encapsulamento dos dados.
5. Construa uma classe chamada Conta que possui os seguintes atributos privados
saldo, limite do tipo double e dono do tipo String. Construa os getters e setters
para os todos atributos. Crie um programa para testar sua classe.

6. Na classe Conta adicione um construtor que quando utilizado mostra a
mensagem "Construindo uma conta" na tela.
7. Faa com que seu construtor alm de mostrar a mensagem na tela, acumule em
um atributo totalContas a quantidade de conta abertas.
8. Crie a classe Funcionario com os atributos salario (float), empresa (string) , setor
(string), nome (string)
9. Adicione o modificador de visibilidade (private se necessrio) para cada atributo
e mtodo da classe Funcionario. Crie uma classe chamada MeuFuncionario,
instancie um funcionrio qualquer e tente modificar ou ler um de seus atributos
privados. O que acontece?
10. Crie os getters e setters necessrios da sua classe Funcionario
11. Modifique a sua classe MeuFuncionario que acessam e modificam atributos de
um Funcionario para utilizar getters e setters.
12. Adicione um atributo na classe Funcionario do tipo int que se chama
identificador. Esse identificador deve ter um valor nico para cada instncia do
tipo Funcionario.
13. Crie um getter para o identificador. Voc deve criar um setter? Justifique.
14. Crie a classe PessoaFisica. Queremos ter a garantia que todas as pessoas
instanciadas que o cpf invlido no seja criada e que pessoas que no tenham cpf
tambm no sejam criadas. Nesse caso, o cpf vlido aquele que tenha 11
dgitos. Utilize o m todo length() da classe String.


Nota de aula4

Conceituar herana.
Diferenciar o relacionamento um do relacionamento tem um.
Utilizar o modificador de acesso protected.

Herana
Na orientao a objetos possvel relacionar as classes. Uma das formas de
relacionamento entre classes a herana. Esse relacionamento muito importante pois
aumenta a reusabilidade do cdigo. Neste relacionamento (herana) uma classe
chamada de classe me ou superclasse e a outra chamada de
classe filha ou subclasse. Quando uma classe herda de outra classe ela poder utilizar
"todos" os atributos e mtodos da classe me.
Em Java a palavra extends representa essa herana. Vejamos:
public String nome;
public String telefone;

public void setNome(String n){
this.nome = n;
}

public String getNome(){
return this.nome;
}

public void setTelefone(String tel){

this.telefone = tel;
}

public String getTelefone(){
return this.telefone;
}
}
A classe Pessoa representa uma pessoa. Esse conceito de pessoa muito genrico
porque a pessoa pode ser fsica ou jurdica.
Vamos especializar a classe pessoa criando uma classe PessoaFisica por exemplo.
public class PessoaFisica extends Pessoa {
private String cpf;

void setCPF(String cpf){
//...cdigo de validao do cpf
this.cpf = cpf;
}

String getCPF(){
return this.cpf;
}
}
Vejamos que na classe PessoaFisica uma Pessoa mais especializada e ela tem um
CPF.
A herana feita pelo comando extends e nos diz que a classe PessoaFisica
uma 'Pessoa sendo assim ela pode utilizar os atributos e mtodos (pblicos) da
classe Pessoa.

Agora poderemos acessar os atributos e mtodos da classe Pessoa instanciando apenas a
classe PessoaFisica.
Veja o cdigo:

PessoaFisica pf = new PessoaFisica();
pf.nome = "Joana";
pf.telefone = "3188439844";

System.out.println("Nome: "+pf.nome);
System.out.println("Telefone: "+pf.telefone);

pf.setNome("Joana");
pf.setTelefone("3188439844");

System.out.println("Nome: "+pf.getNome());
System.out.println("Telefone: "+pf.getTelefone());

pf.setCPF("90878765487");
System.out.println("CPF: "+pf.getCPF());
}
}
Veja que foi possvel acessar os atributos nome e telefone da
classe Pessoa instanciando um objeto da classe PessoaFisica isto porque os atributos
so pblicos (public). Se encapsularmos os atributos nome e telefone da
classe Pessoa ento no ser mais possvel fazer o acesso direto a esses atributos como
mostra o cdigo abaixo:

private String telefone;

this.nome = n;
}

return this.nome;
}

public void setTelefone(String tel){
}

public String getTelefone(){
}
}
Veja que agora os atributos nome e telefone da classe Pessoa so privados e que
quando queremos instanciar a classePessoaFisica que herda de Pessoa no possvel
acessar os atributos privados como mostra a figura abaixo:

Assim podemos concluir que atributos privados de superclasses no so herdados para
as subclasses.
A representao na UML de um relacionamento de herana mostrada na figura abaixo.


Construtor chamando construtor da superclasse
Os construtores so utilizados para construir objetos e depois de um objeto construdo
ele no mais utilizado. Os construtores podem ter assinaturas (argumentos) e tambm
podem chamar outro construtor para construir um objeto.
Em uma classe filha possvel chamar o construtor da classe pai imediatamente
superior utilizando a palavra super que vem de super-classe.
Na classe Pessoa abaixo temos dois construtores, sendo um o construtor padro e o
outro o construtor que utiliza um valor Stringcomo argumento. Esse construtor ir
verificar se o telefone da Pessoa possui oito dgitos. Veja o cdigo.
private String telefone;

Pessoa(){}

Pessoa(String tel){
if(tel.length() == 8){
}
else{
System.out.print("Nmero de telefone invlido");
}
}
void setId(String tel){
}

void setSaldo(String nome){
this.nome = nome;

}

String getTelefone(){
}

String getNome(){
return this.nome;
}

}
Vamos construir uma classe chamada PessoaFisica que herda da
classe Pessoa e chama o construtor da classe Pessoa no seu construtor.
public class PessoaFisica extends Pessoa{
private String cpf;

PessoaFisica(){}

PessoaFisica(String tel, String cpf){
super(tel);
this.cpf = cpf;
}

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

String getCPF(){
return this.cpf;
}

}
Veja que o mtodo construtor PessoaFisica(String tel, String CPF) possui na primeira
linha o comando super(tel). Veja que o mtodo construtor Pessoa(String tel) da
classe Pessoa possui como argumento tambm um String tel. Agora quando um objeto
for instanciado utilizando o construtor PessoaFisica(String tel, String cpf) o valor
de tel passado ser utilizado como argumento de super(tel) e ser enviado para o
construtor Pessoa(String tel) da super-classe Pessoa. O valor de tel ser validado no
mtodo Pessoa(String tel) da classe Pessoa e o objeto PessoaFisica ser instanciado.
importante ressaltar que super deve ser sempre a primeira linha do construtor.
Construtor chamando outro construtor da mesma classe.
Uma classe pode ter mais de um construtor (chamado de sobrecarga de mtodos) e um
construtor pode chamar outro construtor da mesma classe. Vejamos o cdigo abaixo:
private int idade;

Pessoa(){ }

Pessoa(String nome){
this.nome = nome;
}

Pessoa(int idade){
this.idade = idade;
}

Pessoa(String nome, int idade){
this(nome);
this.idade = idade;

}

}
Veja que o cdigo acima possui trs construtores todos com o mesmo nome e com
assinaturas diferentes. Isso chamado desobrecarga de mtodos. Veja que o
construtor Pessoa(String nome, int idade) possui uma linha chamada this(nome) que
chama o construtor Pessoa(String nome). Essa linha deve ser a primeira linha dentro
do cdigo do construtor. Quando o compilador "v" o comando this(nome) ele procura
um construtor que possua uma argumento do tipo igual ao solicitado nos argumentos do
construtor.
Em resumo podemos chamar um construtor dentro de outro construtor da mesma
classe usando a palavra this(argumento) e chamar o construtor dentro de outro
construtor em classes diferentes (na herana) utilizando a palavra super(argumento).

Relacionamento "tem um" ou composio
Acima vimos que PessoaFsica uma Pessoa por isso herda as caractersticas
(atributos) e funcionalidades (mtodos) da classePessoa. Existe outro relacionamento
entre as classes que o tem um. Como exemplo podemos citar o Endereo. Uma
Pessoatem um Endereo. Assim vamos construir uma classe chamada Endereco como
mostra o cdigo abaixo:
public class Endereco {
private String rua, bairro;

public String getRua() {
return rua;
}

public void setRua(String rua) {
this.rua = rua;

}

public String getBairro() {
return bairro;
}

public void setBairro(String bairro) {
this.bairro = bairro;
}
}
Veja que a classe acima uma classe que possui atributos e mtodos.
O cdigo abaixo mostra como ser feito o relacionamento tem um entre a
classe Pessoa e a classe Endereco.
package br.atenac.com;

private String nome ;
private String telefone ;
public Endereco end = new Endereco();

Pessoa(){}

Pessoa(String tel){
}

public String getNome() {
return nome;
}

public void setNome(String nome) {
this.nome = nome;
}

public String getTelefone() {
return telefone;
}

public void setTelefone(String telefone) {
}

public void setBairro(String bairro){
end.setBairro(bairro);
}

public String getBairro(){
return end.getBairro();
}

public void setRua(String rua){
end.setRua(rua);
}

public String getRua(){
return end.getRua();
}
}

Importante
Veja que ao declarar o atributo end do tipo Endereco j foi feita tambm a instanciao
dele. Isso poderia tambm ser feito para os atributos do tipo String. Observe a
linha public Endereco end; que faz o relacionamento entre as
classes Pessoa e Endereco.
Para podermos utilizar as funcionalidades (mtodos) da classe Endereco devemos, no
programa principal instanciar a classeEndereco. Vejamos
package br.atenac.com;

public static void main(String[]args){
p.setNome("Ana");
p.setTelefone("90994949");
p.setBairro("Bairro A");
p.setRua("Rua a");

System.out.println("Nome: "+p.getNome());
System.out.println("Telefone: "+p.getTelefone());
System.out.println("Bairro: "+p.getBairro());
System.out.println("Rua: "+p.getRua());
}
}
Veja que para utilizar os mtodos setBairro(String
bairro), getBairro(), getRua() e setRua(String rua) usamos a varivel de referncia
do objeto Pessoa porque esses mtodo foram construdos na classe Pessoa.
Exerccios
1. Escrever os exemplos deste Nota de aulae analisar os resultados.

2. Escreva uma classe chamada ClasseA que possua um mtodo chamado
metodoA que retorna "eu sou o mtodo A".
3. Escreva uma classe chamada ClasseB que estende da ClasseA e possua um
mtodo chamado metodoB que retorna "eu sou o mtodo B".
4. Crie uma aplicao, em Java, que instancie um objeto da ClasseB e imprimima
utilizando o console o retorno dos dois mtodos criados.
5. Crie uma classe chamada Animal que possua os atributos peso e cor. O
construtor dessa classe dever atribuir o peso e a cor para o animal no momento
da instanciao. Crie os mtodos para configurar e ler esses atributos (mtodos
set e get). Um mtodo chamado mostraAnimal dever ser criado para mostrar o
peso do animal e a cor do animal. O mtodo mostraAnimal dever escrever na
janela gr fica "O animal tem cor " +cor+ "e pesa: " +peso+ " kilos."
6. Crie uma classe chamada Cachorro que estende a classe Animal e coloque os
atributos nome e raa. Crie um construtor para atribuir o nome e a raa do
animal. No corpo do construtor chame o construtor da superclasse para atribuir
peso e cor ao animal instanciado. Crie um outro construtor que atribua somente
o nome do animal ao atributo nome no momento em que o objeto for
instanciado. Crie mtodos para configurar e mostrar os atributos nome e raa.
Nesse caso quando for mostrar o animal, utilize return. No coloque comandos
para imprimir graficamente nem no console.
7. Crie uma classe chamada Cox que estende de Cachorro. Coloque como atributo
tosa do tipo booleano. Crie um construtor que tenha como argumentos o peso,
cor e tosa. Os argumentos peso e cor devero ser passados para o construtor da
super classe e tosa dever ser atribudo ao atributo tosa. Crie um mtodo
chamado mostraAnimal que dever escrever na janela "Este cachorro est
tosado!" se tosa for verdadeiro (true)e a frase "Voc precisa tosar o cachorro!" se
tosa for falsa (false).
8. Crie uma classe chamada Zoologico para implementar criar um objeto de
Cachorro e um objeto de Cox. Utilize os mtodos criados comentando-os.

No laboratrio
1. Implemente o exerccio anterior no Java utilizando somente sada grfica.
2. Desenvolver um programa que efetue a soma de todos os nmeros mpares que
se encontram no conjunto dos nmeros inteiros. Construa um mtodo que
possua o nmero inicial e o nmero final. A entrada de dados dever ser feita via
teclado utilizando a interface grfica.
3. Altere o programa anterior para que sejam mostrados os nmeros pares no
intervalo.


Nota de aula 5

Utilizar a sobrecarga de mtodos;
Utilizar reescrita de mtodos;
Diferenciar sobrecarga de reescrita de mtodos;

Sobrecarga de mtodos
Na orientao a objetos podemos utilizar mtodos com mesmo nome mas com
assinaturas diferentes dentro de uma mesma classe. Isso se chama sobrecarga de
mtodos.
Mtodo operacionais e construtores podem ser sobrecarregados em suas classes.
A assinatura do mtodo dada pelos seus argumentos. As assinaturas se diferem de
acordo com a posio e o tipo de dados utilizados.
Vejamos um exemplo:
setRel(String titulo, int pag){}
setRel(int pag, int num_linhas){}
setRel(int titulo, int num_linhas){}
Os mtodos operacionais acima foram todos sobrecarregados pois, possuem o mesmo
nome e as assinaturas so diferentes. Podemos tambm sobrecarregar os mtodos
construtures da mesma forma que sobrecarregamos os mtodos operacionais.
Veja que se tivermos o mtodo abaixo
setRel(String rodape, int pag){}

junto com os mtodos acima no temos aqui a sobrecarga de mtodos pois o mtodo
possui assinatura igual ao primeiro mtodo da lista. Veja que ele tem como assinatura
um tipo string e um tipo int igual ao primeiro mtodo da lista acima.

Reescrita de mtodos
A reescrita de mtodo depende da herana. Podemos reescrever os mtodos da classe
me. Reescrever um mtodo significa escrever o tipo de retorno do mtodo, o nome do
mtodo e os argumentos (assinatura) conforme o mtodo original. O que ir mudar
somente o corpo do mtodo, isto , o que est entre as chaves {}
Vejamos a classe Conta abaixo:
public String id;
private float saldo;

Conta(){}

Conta(String id){
if(id.length() == 6){
this.id = id;
}
else{
System.out.print("Nmero de Id invlido");
}
}
public void setId(String id){
this.id = id;
}
else{

}
}

void setSaldo(float s){
this.saldo = s;
}

String getId(){
return this.id;
}

float getSaldo(){
return this.saldo;
}

}

Veja que ela possui um mtodo operacional que configura o id da conta com 6
caracteres.
Vamos reescrever esse mtodo na classe ContaPF que herda da classe Conta
public class ContaPF extends Conta{
private String cpf;

ContaPF(){}

void setId(String id){
this.id = id;
}

else{
System.out.println("Valor incorreto para Pessoa Fsica");
}
}

public void setCpf(String cpf) {
this.cpf = cpf;
}
public String getCpf() {
return cpf;
}
}
Veja que na classe ContaPF o mtodo setId no mais valida a id da conta com 6
caracteres e sim com 8 caracteres. Observe que o mtodo setId foi reescrito na
classe ContaPF.
Chamando o mtodo original
Caso queiramos chamar o mtodo original que foi reescrito utilizamos a
palavra super um operador . e o nome do mtodo que queremos chamar.
Vejamos:
public String id;

Conta(){}

this.id = id;
}
else{

}
}

String getId(){
return this.id;
}
}

A classe ContaPF ir utilizar o mtodo getId() da classe Conta.
Veja o cdigo:
private String cpf;

ContaPF(){}

this.id = id;
}
else{
}
}

public String getId(){
return super.getId() + "AA";
}


this.cpf = cpf;
}

return cpf;
}
}
Veja que o mtodo getId() da classe ContaPF chamou o mtodo getId() da
classe Conta utilizando a palavra super um operador .e o nome do mtodo da super
classe. Depois de chamado o mtodo da superclasse foi adicionado os caracteres AA ao
final do retorno do mtodo.
Exerccios
1. Qual a vantagem da reescrita de mtodos?
2. O mtodo de qual classe ser chamado pelo comando super.NomeDoMetodo()?
3. Escreva uma classe chamada Pessoa que possua nome e e-mail como atributos
privados. Crie os mtodos para configurar e mostrar os valores dos atributos.
4. Escreva uma classe que se chama Aluno que herda de Pessoa. Adicione ao aluno
um atributo privado chamado srie, um atributo privado do tipo boolean
chamado aprovado, os atributos privados chamado nota1, nota2, nota3, nota4 e
mdia. Construa os mtodos:
setSerie (pode aceitar nmeros de 1 a 8, caso contrrio zero dever ser atribudo ao
atributo)
seAprovado (aceita valores true ou false)
setNota1(aceita nmeros positivos de 1 a 10, caso contrrio zero dever ser atribudo
ao atributo)
ao atributo)

ao atributo)
ao atributo)
setMdia(dever fazer verificar se (n1+n2+n3+n4)/4 >=7. Caso a mdia seja >=7
ento o atributo aprovado dever receber (true) caso contrrio dever receber
(false)).
getSerie(dever retornar a srie)
isAprovado(dever retornar true ou false)
getNota1 (dever retornar a nota1)
5. Crie uma classe chamada AlunoFaculdade que herda de Aluno e reescreva o
mtodo setMedia() de forma que a mdia mude de 7 para 8. Reescreva o mtodo
setSerie para que o aluno se enquadre na faixa de 1 a 3. Construa uma aplicao
para executar as classes acima.
No laboratrio
1. Faa os exerccios anteriores utilizando entradas e sa das grficas do Java
1. Escreva uma classe chamada Pedido. A classe Pedido dever possuir os
atributos privados: cliente, numeroDoPedido, quantidadeDeItens. Crie um
construtor que utilize como parmetro o nome do cliente. Um outro construtor
dever possuir o nome do cliente e o nmero do pedido e um outro construtor
dever possuir como argumento o nome do cliente a quantidadeDeItens e o
nmero do pedido. Insira os mtodos para mostrar cada atributo da classe Pedido
2. Escreva uma aplicao que instancie 3 objetos sendo que cada um utilize um
construtor criado. Mostre todos os atributos para cada objeto instanciado.

3. Crie uma classe Conta, que possua um saldo, e os mtodos para configurar
saldo, depositar, e retirar. Siga o esqueleto abaixo:
class Conta {
private double saldo;
void deposita(double x){
//..
}
void retira(double x) {
//..
}
double getSaldo() {
//..
}
}
4. Preencha o esqueleto conforme exemplos vistos no decorrer dos m dulos. Crie
o mtodo retira() que retira um valor da conta e retorne um boolean indicando o
sucesso da operao.
5. Adicione um mtodo na classe Conta, que atualiza essa conta de acordo com a
taxa selic fornecida.
void atualiza(double taxaSelic) {
this.saldo = this.saldo * (1 + taxaSelic);
}
6. Crie duas subclasses da classe Conta: ContaCorrente e ContaPoupanca. Ambas
tero o mtodo atualiza reescrito: A ContaCorrente deve atualizar-se com o
dobro da taxaSelic, porm subtraindo 15 reais de taxa bancria. A
ContaPoupanca deve atualizar-se com 75% da taxaSelic. Alm disso, a
ContaCorrente deve reescrever o mtodo deposita, afim de retirar a CPMF de
0.38% a cada depsito.
class ContaCorrente extends Conta {

void atualiza(double taxaSelic){
// fazer conforme enunciado
}
void deposita(double valor) {
// o deposito deve depositar apenas 99.62% do valor
}
}

class ContaPoupanca extends Conta {
void atualiza(double taxaSelic){
// fazer conforme enunciado
}
}
Compila? Executa? O que muda? Qual a utilidade disso?


Nota de aula 6

Instanciar objetos utilizando polimorfismo
Escrever mtodos polimrficos;
Utilizar mtodos polimrfico;

Polimorfismo
Poli significa muitas e morfos significa formas logo a palavra polimorfismo
significa muitas formas. O polimorfismo permite que um objeto assuma um
comportamento diferente daquele definido em sua classe.
A linguagem Java possui dois tipos de polimofismo:
Incluso: quando utilizamos a classe me para instanciar uma classe filha.
Sobrecarga: onde dois mtodos possuem mesmo nome mas assinaturas diferentes.
Polimorfismo de incluso
A reescrita de mtodos deve ser entendida como polimorfismo de incluso. Para
reescrever um mtodo necessrio que tenhamos uma relao de herana entre duas ou
mais classes. O mtodo que ser reescrito deve existir na classe me. Ao reescrever o
mtodo ele dever ter o mesmo tipo de retorno, mesmo nome e mesma assinatura. O
mtodo na classe filha ir fornecer apenas uma nova funcionalidade para o mtodo da
classe me, ou seja, o corpo do mtodo ser escrito de forma diferente da classe me.
O exemplo abaixo possui uma classe chamada Figura que tem um mtodo public float
calcularArea(float p1, float p2). O corpo do mtodo retorna zero (no sabemos de qual
figura ser calculada a rea ainda. Mas sabemos que necessrio ter dois argumentos).
public class Figura {
public float calcularArea(float p1, float p2){
return 0;

}
}
Agora temos a classe chamada Triangulo'' que herda de Figura (porque um
tringulo uma figura) em que o mtodocalcuarArea(float p1, float p2) foi reescrito.
public class Triangulo extends Figura{
return (p1 * p2)/2;
}
}
E temos tambm a classe Retangulo que tambm herda da classe Figura (porque um
retngulo uma figura) em que o mtodo ''public float calcularArea(float p1, float p2)
tambm foi reescrito.
public class Retangulo extends Figura {
return p1 * p2;
}
}
Observe que na classe Retangulo e Triangulo o mtodo public float
calcuarArea(float p1, float p2) foram reescritos.
O cdigo abaixo mostra o programa principal que ir instanciar as classes acima.
public class AppFigura {
Figura r = new Retangulo();
Figura t = new Triangulo();
System.out.println("Area do retngulo: "+r.calcularArea(10, 20));
System.out.println("Area do tringulo: "+t.calcularArea(10, 20));
}

}
Temos no cdigo acima a classe Figura instanciando uma classe filha Retangulo e
dpois a classe me Figura instanciando a classe filha Triangulo.
Note que quando o mtodo operacional calcularArea(10,20) foi chamado ento ele
utilizou a funcionalidade (clculo de rea) da classe que utilizou o construtor. Isso
chamado de Ligao Tardia. Ligao Tardia quer dizer que a definio do mtodo
que ser invocado ocorre durante a execuo do programa. O mecanismo de ligao
tardia tambm conhecido pelos termos dynamic binding ou run-time binding.
Leitura complementar
Leia o artigo no site Metrpole Digital em
http://www.metropoledigital.ufrn.br/aulas/disciplinas/poo/aula_12.html
Exerccios
1. Explique e d exemplo de:
1. classe
2. objeto
3. atributo
4. mtodo
5. herana
No laboratrio
1. Escreva uma classe chamada Animal. Essa classe deve ter um mtodo chamado
comer()vque escreve na tela "animal comendo".
2. Escreva uma classe chamada Cao que estende de Animal e reescreve o mtodo
comer() escrevendo na tela "cao comendo".
3. Escreva uma classe chamada Tigre que estende de Animal e reescreve o mtodo
comer() escrevendo na tela "tigre comendo".
4. Escreva uma classe chamada Teste que tenha o mtodo abaixo:
public void fazerAnimalComer( Animal animal ) {
animal.comer();

}
5. Crie o mtodo principal da classe Teste com o cdigo abaixo:
public static void main( String[] args ) {
Teste t = new Teste();
t.fazerAnimalComer( new Animal() );
t.fazerAnimalComer( new Cao() );
t.fazerAnimalComer( new Tigre() );
}
6. Analise os resultados.


Nota de aula 7

Utilizar a abstrao de dados;
Declarar classes abstratas;
Declarar mtodos abstratos;
Herdar classes abstratas;
Reescrever mtodos abstratos;

A Classes abstratas "existem"
Quando usamos a herana, podemos utilizar os atributos e mtodos da classe me em
uma classe filha. Essa utilizao facultativa pois a herana apenas disponibiliza para
uso os atributos e mtodos. Para forarmos a utilizao de alguns mtodos da
classe me na classe filha devemos tornar a classe me abstrata. Com isso o
mtodo abstrato da classe me dever ser utilizado na clsse filha. Vejamos como tornar
a classe me abstrata.
abstract public class Conta {
public String id;

abstract void setId(String id);

String getId(){
return this.id;
}
}
Veja que a classe acima uma classe abstrata pois possui a palavra abstract antes do
tipo da classe. Essa palavra abstract foi adicionada antes do nome da classe porque essa
classe agora possui um mtodo abstrato. O mtodo abstrato o

abstract void setId(String id);
Veja que esse mtodo no possui um corpo. Note a falta das {}.
Um mtodo abstrato no possui corpo e deve ter em sua declarao a palavra abstract.
Esse mtodo diz que a classe possui um mtodo para configurar um Id mas a
configurao do Id depende da aplicao do usurio. Sendo assim ela apenas diz que
existe, na classse me, um mtodo que deve ser implementado pela classe filha.
Isso fora o programador a implementar um corpo para o mtodo na classe filha.
Veja como ficaria a classe filha:
private String cpf;

ContaPF(){}

this.id = id;
}
else{
}
}

this.cpf = cpf;
}

return cpf;

}
}
Observe que o mtodo setId(String id) foi reescrito na classe ContaPF.
Caso voc no reescreva o mtodo um erro na compilao apresentado. Veja:

Veja que, se voc no reescrever o mtodo abstrato o sistema solicita que isso seja feito
como mostra a mensagem de erro acima.

Particularidades das classes abstratas.
Uma classe abstrata no pode ser instanciada ,isto , no possvel declarar um
objeto do tipo da classe abstrata.
Para que seja possvel utilizar uma classe abstrata esta deve ser a herdada por outra
classe e seus mtodos abstratos serem reescritos nas classes filhas.
Uma classe abstrata pode ter mtodos no abstratos. Mas se uma classe tiver pelo
menos um mtodo abstrato ento essa classe deve ser abstrata.
Mtodos abstratos no podem ser acessados diretamente.
Mtodos abstratos tm que ser redefinidos em uma subclasse.

Mtodos abstratos sero acessados depois de redefinidos na subclasse.

Exerccios
1. Defina classe abstrata.
2. Qual a diferena entre funo e funcionalidade. D um exemplo
3. O que reescrita de mtodos? D um exemplo.
4. Qual a sintaxe para se declarar uma classe abstrata.
5. O que acontece quando uma classe abstrata instanciada?
6. Uma classe que possui um mtodo abstrato tem que ser declarada como
abstrata? Justifique sua resposta.
7. Como podemos instanciar objetos de uma classe que possui mtodos abstratos?
8. Refaa o exerccio 1 do Nota de aula4 aplicando abstrao de dados.

No laboratrio
1. Crie uma classe abstrata chamada forma possua os mtodos abstratos void
calculaArea(float lado1, lado2) e o mtodo abstrato calculaPerimetro(float x1,
float x2).
2. Crie uma classe chamada Retngulo que herda de Forma e possua os mtodos
getArea() e getPermetro. Os mtodos calculaArea(float lado1, float lado2) e
calculaPerimetro(float x1, float x2) devem verificar se os lados no so iguais.
3. Crie uma classe chamada Quadrado que herda de Forma e possua os mtodos
getArea e getPermetro().
4. Crie uma aplicao para ler os lados de um retngulo e mostrar a rea e o
permetro. Os mtodos calculaArea(float lado1, float lado2) e
calculaPerimetro(float x1, float x2) devem verificar se os lados so iguais.


Nota de aula 8

Diferenciar classes abstratas de interfaces
Declarar interfaces
Utilizar interfaces
Utilizar classes adaptadoras

Interfaces de classe
No devemos confundir uma interface de classe com uma interface grfica. Uma
interface de classe possui mtodos sem suas funcionalidades (como o mtodo executa
suas funes). A interface muito parecida com uma classe abstrata pura. Uma classe
abstrata pura seria uma classe abstrata que possui todos os seus mtodos abstratos,
isto , sem corpo.
Na interface todos os mtodos so implicitamente abstract e public, e todos os
atributos so implicitamente static e final.
Para definir uma interface utilizamos ao invs da palavra class a
palavra interface dizendo que o cdigo uma interface e no uma classe.
Ao utilizarmos uma interface em Java, fazemos um contrato entre o cdigo da interface
e a classe que implementa a interface. O contrato diz que ser obrigatrio a
implementao de todos os mtodos da interface.
Vejamos um exemplo de uma interface:
public interface OpConta{
public void creditar(float v);
public void debitar(float v);
}

Veja agora o cdigo que implementa a interface:
public class Movimenta implements OpConta {
private static float saldo;

public void creditar(float v){
saldo = saldo + v;
}
public void debitar(float v){
saldo = saldo - v;
}
}
Veja que os mtodos abstratos creditar(float v) e debitar(float v) foram reescritos na
classe que implementa a interfaceOpConta.
Caso voc esquea de implementar algum mtodo da interface ento o erro abaixo ser
mostrado.

Em Java
Quando programamos utilizando os componentes grficos da linguagem Java usamos
constantemente as interfaces de classes.
Veja o exemplo:
//cria uma janela

import java.awt.event.*;
public class Janela{
JButton botao = new JButton("Clique aqui!");
JFrame minhaJanela = new JFrame("Janela 1");
Janela(){
minhaJanela.setLayout(null);
botao.setBounds(10, 10, 150, 25);
TrataBotao tb = new TrataBotao();
botao.addActionListener(tb);
minhaJanela.add(botao);
minhaJanela.setSize(300,200);
minhaJanela.setLocation(10,20);
minhaJanela.setVisible(true);
}
//classe Interna
private class TrataBotao implements ActionListener{
//precessa eventos capturados
public void actionPerformed(ActionEvent e){
if(e.getSource()== botao){
JOptionPane.showMessageDialog(minhaJanela,"Botao
pressionado");
System.exit(0);
}
}
}
}
Observe que no cdigo acima a classe interna TrataBotao implementou
a interface ActionListener. Essa interface j faz parte da API da linguagem Java. Ela
possui um mtodo que deve ser implementado, este mtodo o public void
actionPerformed(ActionEvent e){.

O uso de interfaces na POO se justifica porque sabemos o que o mtodo deve fazer
(funo do mtodo) mas no sabemos como(funcionalidade) ele deve fazer. Quando
voc coloca um boto em uma aplicao grfica voc sabe que aquele boto ao ser
pressionado deve fechar a aplicao. Mas como esse fechamento da aplicao ser
feito? Ele ir verificar se existem janelas da aplicao aberta e ir fech-las para depois
fechar a janela principal? Ou ele ir fechar somente a janela principal? Sendo assim
quando voc colocar um boto em uma aplicao voc dever implementar o mtodo
da interface do boto.
A interface obriga ao programador implementar todos os mtods que foram declarados
nela. Quando for construir uma interface voc deve sempre pensar nisso e desenvolver a
interface com mtodos que realmente devero ser implementados. Caso voc no
precise implementar algum mtodo de uma interface voc deve escrever o nome do
mtodo com seus argumentos se houverem e depois colocar os pares de chaves de
abertura e fechamento do corpo {}.
A linguagem Java possui o chamado classes adaptadoras que facilitam o trabalho com
as interfaces. Quando voc utiliza uma classe adaptadora voc no precisa implementar
todos os mtodos da interface e sim somente os que voc precisa.
O cdigo abaixo mostra o uso das classes adapatadoras:

import java.awt.BorderLayout;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JFrame;
import javax.swing.JLabel;

public class Mouse extends JFrame{
private JLabel estado;


public Mouse(){
super("Demonstrao do uso do mouse");
estado = new JLabel();
getContentPane().add(estado, BorderLayout.SOUTH);

//instancia a classe interna
Posicao m = new Posicao();
this.addMouseListener(m);
setSize(300,100);
setVisible(true);

}
//construo da classe interna
private class Posicao extends MouseAdapter{
public void mouseClicked(MouseEvent e){
estado.setText("Boto pressionado em "+e.getX()+ "; "+e.getY());
}
}

Mouse m = new Mouse();
}
}
Note que a classe interna Posio herdou da classe MouseAdapter e sendo assim s
reescreveu o mtodo mouseClicked().
Algumas interfaces possuem classes adaptadoras equivalentes. Veja a tabela abaixo:
Interface Classe Adaptadora
ComponentListener ComponentAdapter
ContainerListener ContainerAdapter

FocusListener FocusAdapter
KeyListener KeyAdapter
MouseListener MouseAdapter
MouseMotionListener MouseMotionAdapter
WindowListener WindowAdapter
Uma observao importante que no existe ActionAdapter porque a interface
ActionListener s possui um mtodo chamado actionPerformed() e sendo assim no
justifica uma classe adaptadora para ele.
Ateno:
As variveis declaradas dentro de uma interface sero automaticamente public, static e
final.
final
A palavra-chave final diz que um atributo no poder ser alterado durante a execuo do
programa.
A palavra-chave final diz que um mtodo no poder ser sobrescrito durante a execuo
de um programa.
A palavra-chave final antes da classe diz que a classe no poder ser herdada.
Vejamos:
public final class Relatorio { // no poder ter subclasses
public final int LINHAS = 35; //valor constante
// este mtodo nunca poder ser sobrescrito
public final void tenteSobrescrever(){ }
}

Exerccios
1. Escreva o cdigo que exemplifique uma classe final.

2. O que acontece com um mtodo quando ele declarado como final?
3. Qual a diferena de sintaxe de uma classe abstrata e uma interface?
4. O que acontece com o compilador ao "enxergar" a palavra implements no
cdigo de uma classe?
5. Por que de usar interface?
6. O que acontece com uma classe quando ela decalrada como final?
7. Escreva o cdigo que exemplifique um mtodo final.
8. O que acontece com um objeto declarado como final?
9. Na interface todos os mtodos so implicitamente abstract e public e os atributos
so implicitamente static e final. Explique cada um dos modificadores citados na
afirmao acima.
10. Qual a sintaxe para a declarao de uma interface?
11. Escreva o cdigo que exemplifique um objeto final.
12. O que acontece com um atributo quando ele declarado como final?
13. Escreva o cdigo que exemplifique um atributo final.
No laboratrio
1. Escreva uma classe concreta chamada Conta que possua o atributo privado do
tipo double saldo.
2. Crie um mtodo chamado deposito que possua um parmetro chamado
valorDepositado do tipo double em que um usurio poder fazer um depsito de
uma determinada quantia. Outro mtodo chamado retirada dever ser criado
tendo como parmetro um valorRetirado. Os dois mtodos devero afetar o
atributo saldo.
3. Escreva um mtodo chamado extrato para mostrar o valor do saldo atual.
4. Escreva uma classe que ir instanciar dois objetos de Conta um chamado c1 e
outro chamado c2. Faa com que o cliente1 (c1) deposite 100.45 no banco e que
o cliente c2 deposite 400.0 no banco. Depois mostre o saldo da conta. Faa o
cliente c3 retirar 20.0 e mostre o saldo novamente.
5. Insira na classe Conta uma varivel esttica chamada contOpDep do tipo inteiro.
6. Insira na classe Conta uma varivel esttica chamada contOpRet do tipo inteiro.

7. Escreva uma interface chamada Relatrio que possui o mtodo relatrio.
8. A classe Conta dever impelementar a interface Relatrio da seguinte forma: O
mtodo relatrio dever mostrar o saldo atual e quantas operaes de depsito
foram efetuadas e quantas operaes de retiradas foram efetuadas.
1. Faa as seguintes modificaes no exerccio anterior:
No coloque o saldo como static, compile e execute o programa. Anote a mensagem
de erro.
Escreva um corpo qualquer no mtodo da sua interface. Anote a mensagem de erro.
1. Podemos utilizar uma classe abstrata para resolver o exerccio anterior?
2. Escreva um programa que desenhe uma janela com um boto no centro do
monitor. Ao ser pressionado o boto, seu nome dever ser mostrado na tela em
uma janela de dilogo.


Nota de aula 9

Criar e utilizar a classe Arrays
Criar e utilizar a classe List
Criar e utilizar Arrays multidimensionais
Explicar o funcionamento da classe Wrapper
Criar e utilizar as classes Wrappers

Arrays
O array em Java tratado como um objeto sendo assim devemos:
Declar-lo. int[] meuArray;
Constru-lo. meuArray = new int[5];
Inicializa-lo.
vetor[0] = 2;
vetor[1] = 7;
vetor[2]=3;
vetor[3]=4;
vetor=9;
Os vetores em Java tm como ndice da primeira posio o zero.
O exemplo abaixo mostra como declarar um vetor de nmeros inteiros.
int[] vetor;

Depois de declarado necessrio que o vetor seja instanciado (construdo na memria).
Nesse momento definido a dimenso do vetor.

vetor = new int[3];
Agora iremos adicionar valores aos campos reservados, vejamos
vetor[0] = 5;
vetor[1] = 0;
vetor[2] = 9;
Para carregar um vetor necessrio a utilizao de um lao de repetio.
for (int i = 0; i < vetor.length; i++){
System.out.println("Posio: " + i + " = " + vetor[i]);
}
Vejamos o cdigo completo:
public class Vetor {
public static void main( String args[]){
int[] vetor;
vetor = new int[3];

vetor[0] = 5;
vetor[1] = 0;
vetor[2] = 9;

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

Depois de executado o cdigo acima ir produzir a seguinte sada:
posio 0 = 5
posio 1 = 0
posio 2 = 9
Para utilizarmos a classe Arrays preciso importar a classe java.util. A classe Arrays
possui os seguintes mtodos:
binarySearch Busca elementos em um vetor ordenado e retorna um nmero
inteiro que representa a posio do elemento procurado no vetor.
equal Compara dois vetores retornando verdadeiro (true) se os vetores forem
iguais.
fill Preenche o vetor com o nmero utilizado no argumento do mtodo.
sort Ordena os elementos do vetor. Utilizado antes do mtodo binarySearch();
toString Mostra todos os elementos do vetor.
Um vetor pode tambm ser declarado e inicializado da seguinte forma:
int[] vetor = {5,0,9};
Para verificar se o elemento 5 est no vetor acima devemos primeiro ordenar o vetor,
utilizando o mtodo sort() e depois utilizar o mtodo binarySearch() que ir procurar
pelo elemento 5 no vetor e retornar a posio deste elemento caso ele esteja no vetor.
java.util.Arrays.sort(vetor);
Depois de ordenado usamos o mtodo binarySearch, vejamos:
java.util.Arrays.binarySearch(vetor,5);
Vejamos o cdigo completo:
int[] vetor = {5,0,9};
java.util.Arrays.sort(vetor);

for (int i = 0; i <vetor.length; i++){
System.out.println("posio " + i + "= " + vetor[i]);
}
System.out.println("posio do elemento 5 :"
+ java.util.Arrays.binarySearch(vetor,5));
}
}
Para comparar dois vetores usamos o mtodo equals como mostra o exemplo abaixo:

int[] vetor1 = {4,9,5};
int[] vetor2 = {4,9,5};

if (java.util.Arrays.equals(vetor1, vetor2)){
System.out.println("so identicos...");
}else{
System.out.println("so diferentes...");
}
}
}
O mtodo equals() compara os vetores elemento por elemento.
O mtodo fill da classe Arrays, preenche todos os elementos de um array com um
mesmo valor, vajamos:
int[] vetor = {4,3,9};


java.util.Arrays.fill(vetor,1);

for(int i=0; i < vetor.length; i++){

System.out.println("arrayIgual[ "+i+" ]= "+vetor[i]);
}
}
}
Para exibir todos os elementos do vetor utilizamos o mtodo toString().
int[] vetor = {4,3,6};
System.out.println("Contedo vetor : " +java.util.Arrays.toString(vetor));
}
}

Arrays multidimensionais ou matrizes
Vejamos o cdigo:
public class Matriz {
public static void main (String args[]){
int [][] mat = new int[3][3];
int x = 1;
for(int lin=0; lin <mat.length; lin++){
for(int col=0; col < mat.length; col++){
mat[lin][col] = x;
x++;
}
}
//mostra os dados

for(int lin=0; lin < mat.length; lin++){
for(int col=0; col < mat.length;col++){
System.out.println("mat["+lin+"]["+col+"] ="+mat[lin]
[col]);
}
}
}
}

Classes Wrappers - Embrulhos
Em Java temos os tipos primitivos que so boolean (verdadeiro ou falso), caracteres,
valores numricos inteiros e valores numricos em ponto flutuante.
Inteiros
Os valores numricos podem ser representados por
byte;
short;
int;
long;
O valor padro esses atributos e 0 (zero).
Ocupao da memria
byte: ocupam 8 bits de armazenamento interno.
short: ocupam 16 bits de armazenamento interno.
int: ocupam 32 bits de armazenamento interno.
long: ocupam 64 bits de armazenamento interno.
As variveis do tipo long podem ser identificadas em codigo Java atravs do sufixo l
ou L, vejamos:
long valor = 100L;

Em Java no devemos combinar long int ou short int isso causa um erro de compilao.
Valores Reais
Os valores em ponto flutuante podem ser representados por float ou double. Tanto float
quanto double possuem uma representao interna que segue o padro de representao
IEEE 754, sendo 0.0 o valor padro para tais atributos.
Ocupao da memria
float: ocupam 32 bits de armazenamento interno.
double: ocupam 64 bits de armazenamento interno.
Em Java identificamos um double pelo sufixo d ou D e um float pelo sufixo f ou F.
Os tipos primitivos so mais rpidos, consomem pouca memria, permitem operaes
complexas e so eficientes quando utilizados em laos de repetio e expresses.
Classes Wrappers

Tipo Primitivo Classe Wrapper SubClasse
Lgico boolean Boolean Object
Caractere char Character Object
Integral byte Byte Number
Integral short Short Number
Integral int Integer Number
Integral long Long Number
Ponto Flutuante float Float Number
Ponto Flutuante double Double Number
Quando queremos transformar uma String em um nmero utilizamos as classes
wrappers. Essas classes possuem mtodos que inclusive fazem a transformao de um
String para um nmero. Por exemplo, para transformar a String s em um nmero inteiro
utilizamos o m todo esttico da classe Integer, vejamos:

String texto = "1911";
int x = Integer.parseInt(texto);
Como vimos na tabela acima, as classes Double, Short, etc contm o mesmo mtodo de
converso parse, como parseDouble e parseFloat que retornam um double e float
respectivamente.
As classes wrappers embrulham os tipos primitivos como objetos.
Vejamos o exemplo abaixo que mostra como "embrulhar" ou "empacotar" nmeros
inteiros:

int x = 50;
Integer i = new Integer(x);
O exemplo abaixo mostra como "desembrulhar" ou "desempacotar" um nmero inteiro,
vejamos:
int x = 50;
Integer embrulha = new Integer(x);
int desembrulha = x.intValue();
Autoboxing no Java 5.0 O processo de wrapping no java 1.4 desgastante pois temos
que "embrulhar"o nmero e depois "desembrulhar" para podermos utiliza-lo como visto
no exemplo anterior.
No Java 5.0 temos o chamado autoboxing, que faz as operaes de embrulo e
desembrulho automaticamente aumentando a legibilidade, vejamos:
Integer x = 50;
int y = x;
Esse cdigo ao ser executado no Java 1.4 causaria um erro de compilao mas no Java
5.0 ele compila perfeitamente. Isso no quer dizer que tipos primitivos e referncias

agora so a mesma coisa, isso simplesmente uma facilidade do Java 1.5 que melhora a
codificao.
A classe List
Listas facilitam a forma de se trabalhar com conjunto de dados. O exemplo abaixo
carrega uma lista com 10 strings e mostra o contedo na tela.
import java.util.ArrayList;
import java.util.List;

import javax.swing.JOptionPane;

public class ExemploLista {

//Primeiro criamos um ArrayList.
List<String> lista = new ArrayList<String>();
String valor = "";

//carrega uma lista com 10 nmeros
for(int i=0; i<=10; i++){
valor = JOptionPane.showInputDialog("Digite um valor: ");
lista.add(valor);
}
System.out.println(lista);
}
}
Veja que o mtodo add() adiciona um elemento em uma lista.
No exemplo acima carregamos uma lista com dados do tipo String. Para carregarmos
uma lista com dados do tipo inteiro devemos escrever:




List<Integer> lista = new ArrayList<Integer>();
int valor = 0;

for(int i=0; i<=10; i++){
valor = Integer.parseIng(JOptionPane.showInputDialog("Digite um valor: "));
lista.add(valor);
}
}
}

Ordenando uma lista
import java.util.Collections;



String valor = "";

for(int i=0; i<=10; i++){
lista.add(valor);
}

Collections.sort(lista);
}
}
Veja que o mtodo sort() da classe Collections faz o ordenamento da lista.

Remover elemento de uma lista



String valor = "";


for(int i=0; i<=10; i++){
lista.add(valor);
}

System.out.println("Lista completa: "+lista);
lista.remove(8);
System.out.println("Lista com elemento removido: "+lista);

}
}
Veja que para remover um elemento de uma lista usamos o mtodo remove() e o
argumento desse mtodo a posio onde o elemento ser removido.

Como saber o tamanho de uma lista.



String valor = "";


for(int i=0; i<=10; i++){
lista.add(valor);
}

System.out.println("Tamanho da: "+lista.size());
}
}
O mtodo size() devolve o tamanho da lista.
Mostrar um elemento que est em uma determinada posio



String valor = "";

for(int i=0; i<=10; i++){
lista.add(valor);
}
System.out.println("Lista completa: "+lista);
System.out.println("Posio do elemento na posio 4: "+lista.get(4));

}
}
O mtodo get() tem como argumento a posio do elemento na lista e retorna qual
elemento est nessa posio.

Exerccios
1. O que um Array?
2. Escreva a(s) linha(s) de cdigo para construir um array de inteiros com 20
posies.
3. Escreva um lao de repetio para carregar um array de inteiros de 10 posies.
O array dever receber como contedo o valor da sua posio.
4. Escreva o comando para mostrar o tamanho de um array.
5. A qual pacote pertence a classe Arrays?
6. Para que serve o mtodo binarySearch()?
7. Para que serve o mtodo equal?
8. Para que serve o mtodo fill?
9. Para que serve o mtodo sort?
10. Para que serve o mtodo toString?
11. Escreva a linha de cdigo para instanciar um array 3x2.
12. Escreva o cdigo para carregar um array 3x4;
13. Para que serve as classes Wrapper?
14. O que "Autoboxing" oferecido pelo Java 5?
15. Qual a diferena entre um vetor e um array?
16. Qual o comando utilizado para criar um vetor?
17. Qual a diferena entre a capacidade de um vetor e um tamanho de array?
18. O que faz o mtodo add() da classe Vector?
19. Qual a vantagem da utilizao da classe Vector?

20. Suponha que voc tenha um vetor chamado agenda que tenha capacidade de
armazenar 30 nomes e voc adiciona um 31; nome. O que acontece com o
vetor?
21. Como podemos gerenciar o tamanho de um vetor?

No laboratrio
1. Escreva um programa para:
2. Carregar um array unidimensional com 10 posies de inteiros onde os nmeros
devero ser digitados pelo usurio utilizando a entrada grfica de Java.
3. Ordenar os nmeros carregados no array.
4. Adicionar um cdigo que solicita ao usurio um nmero qualquer e o programa
dever buscar esse nmero no array carregado.
5. Escreva um cdigo para mostrar todos os nmeros carregados.
6. Escreva um programa onde o usurio digita um nmero inteiro e um vetor de 50
posies armazena esse nmero em todas as suas posies.
7. Escreva um programa que carrega um array bidimensional 3x3 somente com
nmeros pares(o programa dever validar a entrada) e mostre os nmeros
carregados.
8. Refaa o exerccio anterior utilizando a classe Vector.
9. Divirta-se agora com palavras cruzadas sobre Programao Orientada a Objetos
clicando aqui
1. Consulte a API do JAVA e descreva os seguintes mtodos da classe Vector:
o insertElementAt(E obj, int index);
o isEmpty();
o elementAt(int index);
o firstElement();
o get(int index);
o lastElement();
o remove(Object o);

o removeElement(Object obj);
o removeElementAt(int index);
2. Escreva o cdigo de um programa que mostre a utilizao dos mtodos da classe
Vector que voc aprendeu. Escreva mensagens dizendo o que o mtodo ir fazer
depois execute o mtodo e mostre o vetor.
3. Consulta a API do Java 1.5 e descreva os seguites mtodos das classes Wrapper.
4. Consulte a API do Java 1.5 e descreva os mtodos ou constantes da classe
Integer:
o MAX_VALUE;
o MIN_VALUE;
o Integer(int value);
o Integer(String s);
o parseInt(String s);
o toString(int i);
o toString();
5. Consulte a API do Java 1.5 e descreva os mtodos ou constantes da classe Float:
o SIZE;
o intValue();
o Float(String s);
o Float(double s);
o toString(float f);
o toString();
o Float(float s);
6. O construtor Float(float s) qual a vantagem de usar esse construtor sendo que o
argumento tambm um float?


Nota de aula 10

Criar interfaces grficas com o usurio
Definir e utilizar os gerenciadores de leiaute
Frames internos

GUI - Interface grfica com o usurio
Para construirmos uma interface grfica na linguagem Java usamos basicamente dois
pacotes importantes que so o java.awwt e ojavax.swing .
O java.awt onde awt o acrnimo de Abstract Window Toolkit considerado um
pacote chamado de peso pesado'. Ele considerado ser peso pesado por ter uma forte
dependncia com o sistema operacional quando vai construir uma interface grfica, isto
, quando vai construir uma interface grfica ele necessita de informaes do sistema
operacional para a construo do pacote. Sendo assim as interfaces seguiro o padro da
interface grfica do sistema operacional.
O javax.swing um pacote chamado de peso leve pois consegue construir interfaces
grficas sem depender do padro de interface do sistema operacional. O x acoplado
ao java indica que este um pacote de extenso da linguagem java sendo mais novo
que oawt. Com o pacote javax.swing possvel construir frames (nome dado as janelas
na linguagem Java) com aparncia do Unix em ambientes Windows por exemplo.
Vamos construir uma janela (JFrame) simples para entender os conceitos.
public class Janela1 {
Janela1(){
JFrame j1 = new JFrame("Cadastro");
j1.setVisible(true);

}
}
O cdigo abaixo ir executar a o cdigo acima
public class AppJanela1 {
Janela1 cadastro = new Janela1();
}
}
Se voc executar o cdigo acima ir ver que uma janela ser aberta (aparecendo
somente o ttulo) no canto superior esquerdo da tela
Agora vamos aumentar o tamanho da janela:
Janela1(){
j1.setSize(400, 200);
}
}
Veja que a janela foi aumentada em 400 pixels de largura e 200 pixels de altura.
Vamos posicionar a janela no centro da tela
Janela1(){
j1.setLocation(550, 250);
j1.setSize(400, 200);

}
}
Se quisermos que a janela no seja redimensionada ento utilizamos o mtodo
setResizable(false), vejamos o cdigo.
Janela1(){
j1.setLocation(550, 250);
j1.setSize(400, 200);
j1.setResizable(false);
}
}
Para tornar a janela sempre maximizada usamos os mtodos abaixo:
import java.awt.*;
Janela1(){
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
JFrame janela = new JFrame("Cadastro");
janela.setSize(d);
janela.setVisible(true);
}
}
Veja na API outros mtodos interessantes para manipular janelas (JFrame).

Inserindo componentes na tela.
Para posicionar botes, caixas de entrada de texto, botes de opo e labels em uma
janela podemos utilizar coordenadas x e y como mostra o exemplo abaixo:

public class JanelaSemLayout {
JFrame janela;
JLabel lblNome;
JTextField tfNome;
JButton btoEnviar;

JanelaSemLayout(){
//instancia os obejetos
janela = new JFrame("Cadastro");
janela.setLayout(null);
janela.setSize(300,200);
lblNome = new JLabel("Nome: ");
tfNome = new JTextField();
btoEnviar = new JButton("Enviar");

//posiciona os elementos
lblNome.setBounds(10, 10, 50, 20);
tfNome.setBounds(50, 10, 180, 20);
btoEnviar.setBounds(10, 50, 150, 30);

//adiciona os elementos janela
janela.add(lblNome);
janela.add(tfNome);
janela.add(btoEnviar);

//mostra a janela

}
}
Para executar o cdigo acima utilize a classe abaixo:
public class AppJanelaSemLayout {
JanelaSemLayout jsl = new JanelaSemLayout();
}
}
Veja que a classe JanelaSemLayout foi construda sem um gerenciador de layout como
mostra o mtodo janela.setLayout(null);'. Para posicionar os elementos na janela
utilizamos o mtodo 'setBounds(int arg0, int arg1, int arg2, int arg3) onde:
arg0 a posio x do componente na janela
arg1 a posio y do componente na janela
arg2 o comprimento do componente na janela
arg3 a altura do componente na janela
Assim conseguimos colocar os componentes nas posies que queremos na janela.
Os Gerenciadores de Layout
Os gerenciadores de layout so ferramentas escritas na linguagem Java que distribuem
os componentes (boto, radio button, check box, label, input na tela). Raramente
utilizaremos somente um gerenciador de layout para distribuir componentes em uma
janela. Na maioria das vezes utilizaremos uma combinao de layouts para conseguir
distribuir elementos na tela.
A classe GridLayout define uma matriz de componentes com linhas e colunas sendo
tamanho de cada linha e coluna ser o mesmo, cada componente ter as mesmas
dimenses. Cada componente adicionado ao container com o uso de GridLayout fica

posicionado no ndice seguinte da grade. Se a linha no estiver completa, ele
acrescentado prxima coluna, vejamos:
import java.awt.*;

public class ExemploGrid extends JFrame {
private JLabel r1, r2, r3, r4, r5, r6;
private JFrame janela;
public ExemploGrid() {
janela = new JFrame("Gerenciadores de leiaute");
janela.setLayout(new GridLayout(3,2));
r1 = new JLabel("rotulo 1");
janela.add(r1);
janela.add(r2);
janela.add(r3);
janela.add(r4);
janela.add(r5);
janela.add(r6);
janela.setLocation(200,300);
}
}
O cdigo para executar a classe acima est abaixo:

public class MostraExemploGrid{
public static void main(String args[]) {
ExemploGrid grade = new ExemploGrid();
grade.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
A sada do programa acima :

BorderLayout
O gerenciador de leiaute BorderLayout divide a janela em cinco parte sendo elas norte,
sul, leste, oeste e centro. Vejamos um exemplo:
import java.awt.*;
public class ExemploBorder extends JFrame{
private JButton bn, bs, bl, bo, bc;
public ExemploBorder(){
super("Exemplo BorderLayout");
setLayout(new BorderLayout());
bn = new JButton("Norte");
bs = new JButton("Sul");
bl = new JButton("Leste");
bo = new JButton("Oeste");
bc = new JButton("Centro");
add(bn, BorderLayout.NORTH);

add(bs, BorderLayout.SOUTH);
add(bl, BorderLayout.EAST);
add(bo,BorderLayout.WEST);
add(bc, BorderLayout.CENTER);
setLocation(200,300);
setSize(400,200);
setVisible(true);
}
}
O programa abaixo executa a classe ExemploBorderLayout, vejamos:

public class MostraBorder{
ExemploBorder cadastro = new ExemploBorder();
cadastro.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
A sada do programa ser:


No necessrio que voc coloque componentes em todas as partes do gerenciador
BorderLayout. Voc pode por exemplo somente utilizar o centro, sul e o leste. Vejamos
um exemplo:
import java.awt.*;
public class ExemploPartesBorder extends JFrame{
private JButton bn, bs, bl, bo, bc;
public ExemploPartesBorder(){
super("Exemplo Partes BorderLayout");
setLayout(new BorderLayout());
bs = new JButton("Sul");
bl = new JButton("Leste");
bc = new JButton("Centro");
add(bs, BorderLayout.SOUTH);
add(bl, BorderLayout.EAST);
add(bc, BorderLayout.CENTER);
setLocation(200,300);
setSize(400,200);
setVisible(true);
}
}
O cdigo para executar o arquivo acima :
public class MostraExemploPartesBorder{
public static void main (String[] args){
ExemploPartesBorder epb = new ExemploPartesBorder();
}
}
Vejamos a interface que foi criada:

No exemplo acima foi mostrado o gerenciador BorderLayout utilizando apenas botes,
mas podemos adicionar qualquer componente a qualquer gerenciador de leiaute.
FlowLayout
O gerenciador de leiaute FlowLayout organiza os componentes da janela da esquerda
para a direita. FlowLayout so usados para organizar os botes em uma janela. Vejamos
um exemplo: O gerenciador de leiaute FlowLaytou sempre posiciona os elementos no
centro da tela ou do painel (ser visto posteriormente). Para definir o posicionamento do
objeto no gerenciador FlowLayout usamos a constante

int alinha = FlowLayout.LEFT; //CENTER, LEFT ou RIGHT sempre em maisculo
pois uma constante.
Usamos a varivel alinha como parmetro do construtor de FlowLayout. O cdigo
abaixo mostra como utilizar o gerenciador FlowLayout. Uma sugesto voc executar o
exemplo e alinha os componentes a esquerda, direita e centro.
import java.awt.*;
public class MostraFlowLayout extends JFrame{
private JButton b1, b2, b3;
public MostraFlowLayout(){
b1 = new JButton("Gravar");
b2 = new JButton("Cancelar");
b3 = new JButton("Sair");

setLayout(new FlowLayout());
add(b1);
add(b2);
add(b3);
setTitle("FlowLayout");
setSize(300,200);
setVisible(true);
}
}
Para executarmos o cdigo acima temos:
public class ExecutaMostraFlowLayout{
MostraFlowLayout mfl = new MostraFlowLayout();
mfl.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
A sada ser:

Importante
Para alinhar os elementos dentro de um FlowLayout voc poder usar o cdigo abaixo:
import java.awt.FlowLayout;

public class GerenciadorDeLeiaute{
JFrame janela = new JFrame("Teste dos gerenciadores e leiaute");
JButton botao = new JButton("botao");
JTextField texto = new JTextField(25);
JLabel label = new JLabel("Nome:");
GerenciadorDeLeiaute(){
//configura a janela
FlowLayout leiaute = new FlowLayout();//instancia FlowLayout
leiaute.setAlignment(FlowLayout.LEFT);//alinha a esquerda
janela.setLayout(leiaute);//gerenciador da janela
}
public void montaJanela(){
janela.add(label);
janela.add(texto);
janela.add(botao);
}
GerenciadorDeLeiaute gl = new GerenciadorDeLeiaute();
gl.montaJanela();
}
}

Frames internos
Frames internos so janelas que podemos abrir dentro de outras janelas. Vamos ver o
exemplo abaixo:
import java.awt.*;


public class FrameInterno{
private JDesktopPane desktop;
private JTextArea areaTexto;

public FrameInterno()
{
janela = new JFrame("Frames internos");
areaTexto = new JTextArea();
JMenuBar barraMenu = new JMenuBar();
JMenu mnuArquivo = new JMenu( "Arquivo" );
JMenuItem mnuItemNovo = new JMenuItem( "Novo arquivo" );
mnuArquivo.add(mnuItemNovo);
barraMenu.add(mnuArquivo);
janela.setJMenuBar(barraMenu);
desktop = new JDesktopPane();
janela.add(desktop);
mnuItemNovo.addActionListener(new ActionListener(){
public void actionPerformed( ActionEvent event ) {
JInternalFrame frameInterno = new JInternalFrame("Arquivo",
true, true, true, true );
Container container = frameInterno.getContentPane();
frameInterno.add(areaTexto);
frameInterno.setSize(600,200);
desktop.add( frameInterno );
frameInterno.setVisible( true );
}
}

);
janela.setLocation(300, 200);
janela.setSize( 600, 400 );
janela.setVisible( true );
}
public static void main( String args[] )
{
FrameInterno frameinterno = new FrameInterno();
}
}

Exemplo de Mscara de entradas para componentes da interface
grfica
import javax.swing.text.*;
import java.awt.*;
import java.text.*;

public class ExemploJFormatedTextField extends JFrame {

JLabel rotulocep, rotulotel, rotulocpf, rotulodata;
JFormattedTextField cep, tel, cpf, data;

MaskFormatter mascaracep, mascaratel, mascaracpf, mascaradata;

public ExemploJFormatedTextField() {

super("Exemplo com JFormattedTextFied");
Container tela = getContentPane();

tela.setLayout(null);
tela.setBackground(new Color (225, 225, 225));

rotulocep = new JLabel("Cep");
rotulotel = new JLabel("Telefone");
rotulocpf = new JLabel("CPF");
rotulodata = new JLabel("Data");

rotulocep.setBounds(50, 40, 100, 20);
rotulotel.setBounds(50, 80, 100, 20);
rotulocpf.setBounds(50, 120, 100, 20);
rotulodata.setBounds(50,160, 100, 20);

try
{
mascaracep = new MaskFormatter("#####-###");
mascaratel = new MaskFormatter("(##)####-####");
mascaracpf = new MaskFormatter("###.###.###-##");
mascaradata = new MaskFormatter("##/##/####");

mascaracep.setPlaceholderCharacter('_');
mascaratel.setPlaceholderCharacter('_');
mascaracpf.setPlaceholderCharacter('_');
mascaradata.setPlaceholderCharacter('_');

}
catch(ParseException excp){}

cep = new JFormattedTextField(mascaracep);
tel = new JFormattedTextField(mascaratel);
cpf = new JFormattedTextField(mascaracpf);

data = new JFormattedTextField(mascaradata);

cep.setBounds(150, 40, 100, 20);
tel.setBounds(150, 80, 100, 20);
cpf.setBounds(150, 120, 100, 20);
data.setBounds(150, 160, 100, 20);

tela.add(rotulocep);
tela.add(rotulotel);
tela.add(rotulocpf);
tela.add(rotulodata);

tela.add(cep);
tela.add(tel);
tela.add(cpf);
tela.add(data);

setSize(400, 250);
setVisible(true);
}

public static void main (String args[]){
ExemploJFormatedTextField app = new ExemploJFormatedTextField();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Fonte: http://javafree.uol.com.br/topic-863242-jtextfield-com-mascara.html
Dica
Consulte o site da sun em http://java.sun.com/docs/books/tutorial/index.html para ver o
tutorial

Exerccios
1.Para que serve o gerenciador de leiaute?
2. Qual a diferena entre java.awt e javax.swing?
3. Qual a diferena entre um pacote peso leve e peso pesado?
4. Qual a vantagem de utilizarmos os gerenciadores de leiaute?
No Laboratrio
1. Pesquise na API do Java como usamos o JTextField. Escreva um pequeno
programa exemplo em que o JTextField seja aplicado.
2. Escreva um programa para montar uma agenda com o nome e o telefone. Voc
dever inserir botes para inserir contatos, excluir contatos, mostrar contatos e
alterar contatos. No necessrio fazer com que os botes funcionem ainda.


Nota de aula 11

Utilizar painis nas interfaces grficas
Utilizar a classe JScrollPane
Programar menus em Java
Programar submenus em Java
Utilizar a classe JRadioButton
Utilizar a classe JCheckBox
Utilizar a classe JList
Utilizar a classe JPasswordField

Painis
Os painis so componentes importantes na construo de interfaces grficas em Java.
Os painis podem conter gerenciadores de leiaute e so adcionados dentro de
gerenciadores de leiaute.
A figura abaixo mostra como gerenciar painis:

O cdigo abaixo mostra a utilizao de painis e gerenciadores de leiaute.
import java.awt.*;
public class Painel{
private JPanel pnDireito = new JPanel();
private JPanel pnInferior = new JPanel();
private JFrame janela = new JFrame();
private JLabel lblUsuario = new JLabel("Usuarios: ");
private JLabel lblMens = new JLabel("Mensagem: ");
private JTextField tfUsuario = new JTextField(50);
private JTextField tfMens = new JTextField(20);
private JTextArea taTexto = new JTextArea(20,40);
private JButton btoEnviar = new JButton("Enviar");
public Painel(){
//configura o leiaute da janela
janela.setLayout(new BorderLayout());

//configura o leiaute do painel direito
pnDireito.setLayout(new GridLayout(20,1));
//configura o leiaute do painel inferior
pnInferior.setLayout(new FlowLayout());
//adiciona os componentes ao leiaute do painel direito
pnDireito.add(lblUsuario);
//adiciona os componentes ao leiaute do painel inferior
pnInferior.add(lblMens);
pnInferior.add(tfMens);
pnInferior.add(btoEnviar);
//adiciona o painel direito a janela
janela.add(pnDireito, BorderLayout.EAST);
//adiciona o painel inferior a janela
janela.add(pnInferior, BorderLayout.SOUTH);
//adiciona a rea de texto
janela.add(taTexto, BorderLayout.CENTER);
//configura o tamanho da janela
//configura o ttulo da janela
janela.setTitle("Comunicador Java");
//exibe a janela
}
}
O cdigo abaixo mostra como executar a classe acima:
public class ExibePainel{
Painel chat = new Painel();
}
}


JScrollPane
necessrio adicionar na janela acima uma barra de rolagem no objeto TextArea e para
isso usamos a classe JScrollPane que um painel com barra de rolagem. Vejamos como
ficar o cdigo acima:
import java.awt.*;
public class PainelRolagem {
private JTextField tfUsuario = new JTextField(50);

private JScrollPane barraRolagem = new JScrollPane(taTexto);
public PainelRolagem(){
pnInferior.setLayout(new FlowLayout());
//adiciona o painel JScrollPane na posio center
janela.add(barraRolagem, BorderLayout.CENTER);
janela.setTitle("Comunicador Java com barra de rolagem");
//exibe a janela
}
}

Para executar o cdigo fazemos:
public class ExibePainelRolagem{
public static void main(String[]args) {
PainelRolagem chat = new PainelRolagem();
}
}
Vamos ver agora como escrevemos o cdigo para alinharmos esquerda a parte inferior
da janela.
import java.awt.*;
public class PainelRolagem {
private FlowLayout leiautePnInferior = new FlowLayout();
private JScrollPane barraRolagem = new JScrollPane(taTexto);
public PainelRolagem(){
pnInferior.setLayout(leiautePnInferior);
//configura o alinhamento do FlowLayout
leiautePnInferior.setAlignment(FlowLayout.TRAILING);

//configura o alinhamento do pnInferior
pnInferior.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
//a seqncia importnte.
//adiciona o painel JScrollPane na posio center
janela.add(barraRolagem, BorderLayout.CENTER);
janela.setTitle("Comunicador Java com barra de rolagem");
//exibe a janela janela.setVisible(true);
}
}
Para executar o arquivo acima fazemos:
public class ExibePainelRolagem{
PainelRolagem chat = new PainelRolagem();
}
}

Menus em Java
A figura abaixo mostra a hierarquia de classes (estudado em herana) para a construo
de menus em Java.

Escreveremos agora um programa que mostra como construir um menu em Java.
public class Menu{
//define os objetos
private JMenuBar barraMenu;
private JMenu menuArquivo;
private JMenu menuEditar;
private JMenuItem itemNovo;
private JMenuItem itemAbrir;
private JMenuItem itemSair;
private JMenuItem itemCopiar;
private JMenuItem itemColar;
public Menu(){
//instancia os objetos
janela = new JFrame("Janela com menu");

barraMenu = new JMenuBar();
menuArquivo = new JMenu("Arquivo");
menuEditar = new JMenu("Editar");
//adiciona um atalho aos menus
menuArquivo.setMnemonic('A');
menuEditar.setMnemonic('e');
itemNovo = new JMenuItem("Novo");
itemAbrir = new JMenuItem("Abrir");
itemSair = new JMenuItem("Sair");
itemCopiar = new JMenuItem("Copiar");
itemColar = new JMenuItem("Colar");
//adiciona os itens do menu Arquivo
menuArquivo.add(itemNovo);
menuArquivo.add(itemAbrir);
menuArquivo.addSeparator();
menuArquivo.add(itemSair);
//adiciona os itens do menu Editar
menuEditar.add(itemCopiar);
menuEditar.add(itemColar);
//adiciona os menus a barra de menus
barraMenu.add(menuArquivo);
barraMenu.add(menuEditar);
//adiciona a barra de menu a janela
//configurao tamanho da janela
//mostra a janela
}
}

Para executar o programa acima fazemos:
public class ExibeMenu {
Menu m = new Menu();
}
}
As janelas abaixo mostram como ficaro os menus:

Podemos inserir botes de opo ou (da classe RadioButtonMenuItem), botes de opo
e e cones nos menus.
Submenus
Um menu em Java pode conter submenus que so menus dentro de menus. O programa
abaixo exemplifica essa tcnica.
public class SubMenu {
//declara os componentes
private JMenu menu, subMenu;
private JMenuItem itemAbrir, itemSair, itemTexto, itemImagem;
public SubMenu(){
//instancia os componentes
janela = new JFrame("Submenus em java");
menu = new JMenu("Arquivo");

subMenu = new JMenu("Novo");
itemTexto = new JMenuItem("Texto");
itemImagem = new JMenuItem("Imagem");
//adiciona os componentes
subMenu.add(itemTexto);
subMenu.add(itemImagem);
menu.add(subMenu);
menu.add(itemAbrir);
menu.addSeparator();
menu.add(itemSair);
barraMenu.add(menu);
//mostra a janela
}
}
Para executarmos o programa usamos o seguinte cdigo:
public class ExecutaSubMenu {
SubMenu sm = new SubMenu();
}
}

Radio Button
Radio Buttons so grupos de botes que, por conveno, apenas um boto pode ser
selecionado por vez. O Swing d suporte a Radio Buttons com a classe JRadioButton e
ButtonGroup. Vejamos:
import java.awt.*;
public class RadioButton {
private JPanel painel;
private JRadioButton rbMasc, rbFem;
private ButtonGroup grupo;
public RadioButton(){
janela = new JFrame("Janela Radio Button");
painel = new JPanel();
rbMasc = new JRadioButton("Masculino");
rbFem = new JRadioButton("Feminino");
grupo = new ButtonGroup();
grupo.add(rbMasc);
grupo.add(rbFem);
janela.setLayout(new FlowLayout());
painel.setLayout(new FlowLayout());
painel.add(rbMasc);
painel.add(rbFem);

janela.add(painel);
//mostra a janela
}
}
Observe que o componente Radio Button quem foi adicionado ao painel e no o
Button Group.
Para executar o arquivo usamos o cdigo:
public class ExecutaRadioButton {
RadioButton rb = new RadioButton();
}
}

Checkbox
A classe JCheckBox d suporte aos botes de check box. Podemos tambm usar os
check boxes em menus usando a classe JCheckBoxMenuItem.

Check boxes so parecidos com os radio buttons mas eles trabalham de forma diferente.
Os radio buttons permitem que apenas uma opo seja selecionada (ou) e o check box
permite que mais de uma opo seja selecionada (e). Vejamos um exemplo:
import java.awt.*;
public class CheckBox {
private JCheckBox chkArroz, chkFeijao, chkBife, chkBatata;
public CheckBox(){
janela = new JFrame("Janela Check Box");
chkArroz = new JCheckBox("Arroz");
chkFeijao = new JCheckBox("Feijo");
chkBife = new JCheckBox("Bife");
chkBatata = new JCheckBox("Batata frita");
painel.setLayout(new GridLayout(4,1));
painel.add(chkArroz);
painel.add(chkFeijao);
painel.add(chkBife);
painel.add(chkBatata);
janela.add(painel);
//mostra a janela
}
}
O programa para executar a classe acima:

public class ExecutaCheckBox {
CheckBox cb = new CheckBox();
}
}

Listas
A JList mostra como trabalhar com um grupo de itens mostrados em uma ou mais
colunas para serem selecionados. As Lists que tm muitos itens devem ser colocadas em
um JScrollPane. Vejamos o exemplo abaixo:
import java.awt.*;
public class Listas{
private JList minhaLista;
private DefaultListModel modelo;
private JScrollPane rolagem;
public Listas(){
janela = new JFrame("Janela com lista");
modelo = new DefaultListModel();
modelo.addElement("Mouse");

modelo.addElement("Teclado");
modelo.addElement("Monitor");
modelo.addElement("Gabinete");
modelo.addElement("Web Cam");
modelo.addElement("Estabilizador");
modelo.addElement("Microfone");
//cria a lista e adiciona o modelo
minhaLista = new JList(modelo);
//configura a lista
minhaLista.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
minhaLista.setSelectedIndex(0);
minhaLista.setVisibleRowCount(4);
//adiciona barras de rolagem
rolagem = new JScrollPane(minhaLista);
painel.add(rolagem);
janela.add(painel);
//mostra a janela
}
}
Para executar o arquivo fazemos:
public class ExecutaListas {
Listas l = new Listas();
}
}

A sada ser:

Password
A classe JPasswordField que uma subclasse de JTextField disponibiliza campos textos
especializados para entrada de senhas. Por questes de segurana o campo de senha no
exibe o que foi digitado e sim smbolos que representam os caracteres que realmente
foram digitados. Vejamos:
import java.awt.*;
public class Password {
private JPasswordField pswSenha;
private JLabel lblSenha;
public Password(){
janela = new JFrame("Campo senha");
pswSenha = new JPasswordField(20);
lblSenha = new JLabel("Senha:");
painel.add(lblSenha);
painel.add(pswSenha);

janela.add(painel);
//mostra a janela
}
}

Para executar o cdigo:
public class ExecutaPassword {
Password p = new Password();
}
}
A sada ser:

ComboBox
A classe JComboBox permite que o usurio escolha uma das vrias opes listadas. Isso
pode ser feito de duas formas diferentes. A forma padro escolher uma opo em um
campo no editvel que formada por uma lista suspensa de valores e um boto. A
segunda forma, chamada de combo box editvel formada por um campo texto com um
pequeno boto em que o usurio pode escrever o texto ou pressionar o boto para que
uma lista suspensa seja mostrada. Vejamos um exemplo:
import java.awt.*;
public class ComboBox{
//declara a janela

public JFrame janela;
//declara o painel
JPanel painel;
//declara o comboBox
JComboBox listaNomes;
public ComboBox(){
//instancia a janela
janela = new JFrame("Exemplo Combo Box");
//instancia o painel
//Carrega um vetor de Strings
String[] nome = {"Maria", "Joo", "Gustavo", "Ana", "Mrcia"};
//Instancia o combo box e atribui os nomes
listaNomes = new JComboBox(nome);
//Deixa como selecionado o 2 item da lista
listaNomes.setSelectedIndex(2);
//adiciona o combo box ao painel
painel.add(listaNomes);
//adiciona o painel a janla
janela.add(painel);
//configura o tamenho da janela
//mostra a janela
}
}
O cdigo para executar o a classe acima :
public class ExecutaComboBox{
ComboBox cb = new ComboBox();

}
}

Exerccios
1. Escreva um programa para fazer a matrcula de um aluno em um dos cursos que
a escola.Escola X oferece (5 cursos). O aluno dever ter uma senha para fazer
um acesso posterior.
2. Construa o tradicional jogo da velha utilizando a interface grfica de Java.


Nota de aula 12

Utilizar o gerenciador de leiaute miglaytout

Usando o MigLayout
O MigLayout um gerenciador de leiaute que torna mais fcil a distribuio de
componentes em uma janela de uma aplicao Java.
Primeiro necessrio baixar o miglayout-4.0-swing.jar e adicionar na pasta do projeto.
Para isso:
1. Baixe o arquivo
2. copie-o para o projeto que est dentro da workspace
3. Clique com o boto direito do mouse em cima do nome do projeto > Build Path
> Add External Archives...
4. Selecione o arquivo que voc gravou dentro da workspace.
Com o miglayout podemos:
Adicionar componentes em uma grade
panel.add(comp1)
panel.add(comp2)
panel.add(comp3, "wrap") //quebra a prxima linha
panel.add(comp4)
Veja abaixo como ser a sada

Se quisermos que sempre seja quebrada a linha na coluna 3 usamos o seguinte
comando:
JPanel pnPainel = new JPanel(new MigLayout("wrap 3"));

Mesclar e dividir clulas
Para mesclar colunas usamos o comando
panel.add(comp1)
panel.add(comp2, "span 2") // Este componente ir ocupar duas colunas.
panel.add(comp3, "wrap") // quebra linha
panel.add(comp4, "span") // Mescla todas as linhas.
Veja como ser a sada

Podemos mesclar tambm linhas e colunas.
panel.add(comp1);
panel.add(comp2, "span 2 2"); // O componente ir ocupar 2 linhas e duas colunas.
panel.add(comp3, "wrap"); // quebra a linha
panel.add(comp4);
panel.add(comp5, "wrap"); // quebra a linha.
panel.add(comp6);
panel.add(comp7);

Veja como ser a sada

Usando coordenadas absolutas
Podemos usar coordenadas de clulas para posicionar elementos dentro de uma grade.
panel.add(comp1, "cell 0 0"); // "cell coluna linha"
panel.add(comp2, "cell 1 0");
Veja abaixo como ser a sada

tambm possvel mesclar colunas utilizando coordenadas de clulas
panel.add(comp2, "cell 1 0 2 1"); // "cell coluna linha largura altura"
panel.add(comp4, "cell 0 1 4 1");
Mais sobre miglayout pode ser encontrado em
http://www.miglayout.com/QuickStart.pdf
Exemplo

import net.miginfocom.swing.MigLayout;

public class TerceiroExemploMigLayout {
JLabel lblNome = new JLabel("Nome: ");
JLabel lblTel = new JLabel("Telefone: ");
JLabel lblEnd = new JLabel("Endereo");

JTextField tfNome = new JTextField(30);
JTextField tfTel = new JTextField(15);
JTextField tfEnd = new JTextField(52);

JFrame janela = new JFrame("Agenda telefnica-3");
JPanel pnPainel = new JPanel(new MigLayout());

pnPainel.add(lblNome);
pnPainel.add(tfNome);
pnPainel.add(lblTel);
pnPainel.add(tfTel, "wrap");
pnPainel.add(lblEnd);
pnPainel.add(tfEnd, "span");

janela.add(pnPainel);
}
}
Exerccios
1. Escreva um programa que possua uma janea com os campos nome, e-mail e
telefone. Posicione-os utilizando miglayout.


Nota de aula 13

Utilizar classes internas
Programar manipuladores de eventos para JButton
Programar manipuladores de eventos para JTextField
Programar manipuladores de eventos para JMenuItem
Programar manipuladores de eventos para JList
Programar manipuladores de eventos para JComboBox
Programar manipuladores de eventos para JRadioButton
Programar manipuladores de eventos para JCheckBox

Manipuladores de Eventos em Java
Evento para JButton
As interfaces grficas de Java so baseadas em eventos, isto , geram eventos quando o
usurio interage com o programa. Uma interao comum pode ser mover o mouse,
pressionar um boto, clicar com o mouse, digitar em um campo de texto, selecionar um
item no menu etc..Quando o usurio executa qualquer ao, esta pode ser enviada ao
programa. As informaes de eventos de GUI so armazenadas em um objeto de uma
classe que est no pacote awt.event . Os eventos do pacote java.awt.event.* podem ser
usados tanto para componentes AWT quanto componentes SWING. Os eventos
especficos de componentes SWING esto no pacote javax.swing.event.
O tratamento de eventos consiste em trs partes:
Origem do evento - Objeto com o qual o usurio interage.
Objeto evento - Encapsula as informaes sobre o evento.
Ouvinte do evento (listener) - Objeto que notificado pela origem do evento.

Para processar um evento da interface grfica preciso que o programador execute duas
tarefas:
1. Registrar um ouvinte de evento para o componente
2. Implementar um mtodo de tratamento de evento (ou conjunto de mtodos)
O objeto "ouvidor" listener de eventos aguarda por tipos especficos de eventos gerados
por origens de eventos (um boto por exemplo). O tratador de eventos um mtodo
chamado em resposta a um tipo de evento em particular. Cada interface listener de
eventos especifica um ou mais mtodos de tratamentos de eventos que devem ser
definidos na classe que implementa a interface listener de eventos.
import java.awt.*;

public class AcaoBotao extends JFrame implements ActionListener{
private JButton b1, b2, b3;

public AcaoBotao(){
//Registra os tratadores de eventos
b1.addActionListener(this);

//configura o leiaute e adiciona os botes
setLayout(new FlowLayout());
add(b1);
add(b2);
add(b3);

setTitle("FlowLayout");
setSize(300,200);
setVisible(true);
}

//implementa o mtodo actionPerformed da interface
//processa eventos de botes
//verifica qual boto foi pressionado
if(e.getSource()== b1){
JOptionPane.showMessageDialog(null, "O boto Gravar foi
pressionado");
}
else if (e.getSource()==b2){
JOptionPane.showMessageDialog(null, "O boto Cancelar foi
pressionado");
}
else if (e.getSource()==b3){
JOptionPane.showMessageDialog(null, "O boto Sair foi
pressionado");
JOptionPane.showMessageDialog(this, "Tchau");
System.exit(0);
}
}
}
public class ExecutaAcaoBotao {
AcaoBotao ab = new AcaoBotao();
}

}
A sada ser:


Uma outra forma de utilizarmos os tratamentos de eventos utilizando uma classe
interna. Vejamos o mesmo exemplo com classe interna:

import java.awt.*;

public class AcaoBotaoClasseInterna {
public JButton b1, b2, b3;
JFrame janela;
public AcaoBotaoClasseInterna(){
janela = new JFrame("Classe Interna");

//instancia a classe interna ClasseEventos
TrataEventos evento = new TrataEventos();

//adiciona um "ouvidor" ao botao
b1.addActionListener(evento);


//configura o leiaute e adiciona os botes

janela.add(b1);
janela.add(b2);
janela.add(b3);
janela.setTitle("Botes em ao");
}
private class TrataEventos implements ActionListener{
if(e.getSource()== b1){
JOptionPane.showMessageDialog(null,"O boto Gravar foi pressionado com
classe interna");
} else if (e.getSource()==b2){
JOptionPane.showMessageDialog(null, "O boto Cancelar foi pressionado com
classe interna");
} else if (e.getSource()==b3){
JOptionPane.showMessageDialog(null, "O boto Sair foi pressionado com classe
interna");
JOptionPane.showMessageDialog(janela, "Tchau");
System.exit(0);
}
}
}
}
Para executar a classe acima fazemos:

public class ExecutaAcaoBotaoClasseInterna {
AcaoBotao ab = new AcaoBotao();
}
}
Se voc executar o programa acima ver que a sada exatamente igual ao do programa
anterior. A diferena est na escrita do cdigo. No primeiro exemplo utilizammos uma
herana de JFrame para a criao da janela e implementamos a interface ActionListener
(pode ver o this em algumas partes do arquivo). No segundo programa a classe JFrame
foi instanciada dentro do programa e a interface ActionListener foi implementada
dentro de uma classe interna chamada ClasseEventos em que os eventos foram
manipulados.
Evento para JTextField
O exemplo abaixo mostra um evento de teclado. Ao pressionar a tecla enter o contedo
do campo JTextField ser enviado para uma janela de mansagem. Vejamos o cdigo
abaixo:
import java.awt.*;
public class AcaoJtextField {
JFrame janela;
JTextField tfNome;
public AcaoJtextField(){
janela = new JFrame("Ao de campo texto");
tfNome = new JTextField(20);
//instancia a classe interna ClasseEvento
ClasseEvento evento = new ClasseEvento();
//registra o evento para o campo texto
tfNome.addActionListener(evento);

//adiciona o campo texto a janela
janela.add(tfNome);
//mostra a janela
}
private class ClasseEvento implements ActionListener{
JOptionPane.showMessageDialog(null, "Digitado:
"+tfNome.getText());
}
}
}
Para executar o programa fazemos:
public class ExecutaAcaoJtextField {
public static void main(String[]args){
AcaoJtextField atf = new AcaoJtextField();
}
}

Evento para JMenuItem
O cdigo abaixo mostra como adicionar eventos s op es de menus. Vejamos o
cdigo:

public class EventoSubMenu {
//declara os componentes
private JMenu menu, subMenu;
private JMenuItem itemAbrir, itemSair, itemTexto, itemImagem;

public EventoSubMenu(){
janela = new JFrame("Submenus com eventos em java");
menu = new JMenu("Arquivo");
subMenu = new JMenu("Novo");
itemTexto = new JMenuItem("Texto");

itemImagem = new JMenuItem("Imagem");
//instancia um objeto da classe interna
TrataEvento te = new TrataEvento();

//registra os eventos para os menus
itemSair.addActionListener(te);
itemTexto.addActionListener(te);
itemAbrir.addActionListener(te);

//adiciona os componentes
subMenu.add(itemTexto);
subMenu.add(itemImagem);
menu.add(subMenu);
menu.add(itemAbrir);
menu.addSeparator();
menu.add(itemSair);
barraMenu.add(menu);
//mostra a janela
}
private class TrataEvento implements ActionListener{
if(e.getSource() == itemSair){
JOptionPane.showMessageDialog(null, "menu sair funcionou");
System.exit(0);
}
if(e.getSource() == itemTexto){
JOptionPane.showMessageDialog(null,"sub menu item texto

funcionou");
}
if(e.getSource() == itemAbrir){
JOptionPane.showMessageDialog(null,"submenu abrir funciona");
}
}
}
}
Para executar o cdigo fazemos:
public class ExecutaEventoSubMenu {
EventoSubMenu sm = new EventoSubMenu();
}
}
A sada ser:

Eventos para JList
O cdigo abaixo mostra como adicionar eventos a um componente JList. Vejamos:
import javax.swing.event.*;
import java.awt.*;

public class AcaoListas {
private JList minhaLista;
private DefaultListModel modelo;
public AcaoListas(){
modelo = new DefaultListModel();
modelo.addElement("Mouse");
modelo.addElement("Teclado");
modelo.addElement("Monitor");
modelo.addElement("Gabinete");
modelo.addElement("Web Cam");
modelo.addElement("Estabilizador");
modelo.addElement("Microfone");
//cria a lista e adiciona o modelo
minhaLista = new JList(modelo);
//configura a lista
minhaLista.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
minhaLista.setSelectedIndex(0);
minhaLista.setVisibleRowCount(4);

//registra o evento para a lista
minhaLista.addListSelectionListener(te);

rolagem = new JScrollPane(minhaLista);

janela.add(painel);
//mostra a janela
}
private class TrataEvento implements ListSelectionListener{
public void valueChanged(ListSelectionEvent e){
JOptionPane.showMessageDialog(null, "Posio:
"+minhaLista.getSelectedIndex());
JOptionPane.showMessageDialog(null, "Nome:"
minhaLista.getSelectedValue());
}
}
}
Para executar a classe acima temos:
public class ExecutaAcaoListas {
AcaoListas al = new AcaoListas();
}
}

Eventos para ComboBox
O programa abaixo mostra como construir eventos para componentes ComboBox.
Vejamos:
import java.awt.*;
public class AcaoComboBox{
//declara a janela
public JFrame janela;
//declara o painel
JPanel painel;
//declara o comboBox
JComboBox listaNomes;
public AcaoComboBox(){

//instancia a janela
janela = new JFrame("Exemplo Combo Box");
//instancia o painel
//Carrega um vetor de Strings
String[] nome = {"Maria", "Joo", "Gustavo", "Ana", "Mrcia"};
//Instancia o combo box e atribui os nomes
listaNomes = new JComboBox(nome);
//Deixa como selecionado o 2 item da lista
listaNomes.setSelectedIndex(2);
//instancia classe interna
//registra o evento para listaNomes
listaNomes.addItemListener(te);
//adiciona o combo box ao painel
painel.add(listaNomes);
//adiciona o painel a janla
janela.add(painel);
//configura o tamenho da janela
//mostra a janela
}
//criao da classe interna para tratamento de eventos
private class TrataEvento implements ItemListener{
public void itemStateChanged(ItemEvent e){
//verifica qual item est selecionado
if(e.getStateChange() == ItemEvent.SELECTED){
JOptionPane.showMessageDialog(null, "Item:"
+listaNomes.getSelectedItem());
}

}
}
}
public class ExecutaAcaoComboBox{
AcaoComboBox cb = new AcaoComboBox();
}
}

Eventos para JRadioButton
Radio Buttons so grupos de botes (opes) que por conveno apenas um boto
(opo) deve ser selecionado. O pacote Swing d suporte a Radio Buttons atrav s das
classes JRadioButton e ButtonGroup. Vejamos o cdigo:
public class AcaoRadioButton {
//define as variveis de instncia
private JRadioButton sxMasculino, sxFeminino;
private ButtonGroup grupo;

//construtor
public AcaoRadioButton() {
janela = new JFrame("Radio buttons exemplo");
sxMasculino = new JRadioButton("Masculino");
sxFeminino = new JRadioButton("Feminino");
//agrupa os botes
grupo = new ButtonGroup();
grupo.add(sxMasculino);
grupo.add(sxFeminino);
//instancia a classe interna de eventos
ClasseEventos evento = new ClasseEventos();
//registra os eventos
sxMasculino.addActionListener(evento);
sxFeminino.addActionListener(evento);
//coloca os radio buttons na janela
janela.add(sxMasculino);
janela.add(sxFeminino);
janela.setLocation(300, 300);
}
//classe interna para tratamento de eventos
public class ClasseEventos implements ActionListener{
public void actionPerformed(ActionEvent e) {
if(sxMasculino.isSelected()){
JOptionPane.showMessageDialog(null, "Escolhido: Masculino");
}

if(sxFeminino.isSelected()){
JOptionPane.showMessageDialog(null, "Escolhido: Feminino");
}
}
}
}
A sada ser:

Eventos para JCheckBox
JCheckBox so parecidos com os JRadioButton mas eles trabalham de forma diferente.
Os JRadioButtons permitem que apenas uma opo seja selecionada (ou) e o
JCheckBox permite que mais de uma opo seja selecionada (e). Vejamos o exemplo:
import java.awt.*;
public class AcaoCheckBox {
private JCheckBox chkArroz, chkFeijao, chkBife, chkBatata;

private JButton botao;
public AcaoCheckBox(){
janela = new JFrame("Janela Check Box");
chkArroz = new JCheckBox("Arroz");
chkFeijao = new JCheckBox("Feijo");
chkBife = new JCheckBox("Bife");
chkBatata = new JCheckBox("Batata frita");
botao = new JButton("Mostrar");
painel.setLayout(new GridLayout(5,1));
painel.add(chkArroz);
painel.add(chkFeijao);
painel.add(chkBife);
painel.add(chkBatata);
painel.add(botao);
TrataEvento evento = new TrataEvento();
//registra os eventos para o botao
botao.addActionListener(evento);
//adiciona o painel a janela
janela.add(painel);
//mostra a janela
}
//classe interna de tratamento de eventos
public class TrataEvento implements ActionListener{
String selecionados = "";

if(chkArroz.isSelected()){
selecionados = selecionados + " " +chkArroz.getText();
}
if(chkFeijao.isSelected()){
selecionados = selecionados + " " +chkFeijao.getText();
}
if(chkBife.isSelected()){
selecionados = selecionados + " " +chkBife.getText();
}
if(chkBatata.isSelected()){
selecionados = selecionados + " " +chkBatata.getText();
}
if(e.getSource() == botao){
JOptionPane.showMessageDialog(janela, "Selecionados:"+
selecionados);
}
}
}
}

Exerccios
1. Quais pacotes podemos utilizar para manipularmos eventos?
2. O tratamento de eventos composto por trs partes. Quais so elas?
3. Para processar um evento da interface grfica preciso que o programador
execute duas tarefas. Quais so elas?
4. O que um tratador de eventos?
5. Quais as duas formas de tratamento de eventos estudadas?
No Laboratrio
1. Escreva um programa que possua todos os objetos estudados bem como seus
eventos.
Mais informaes
Para saber mais sobre interfaces grficas acesse o site oficial da Sun (Oracle)
em:http://download.oracle.com/javase/tutorial/uiswing/components/index.html


Nota de aula 14

Programar manipuladores de eventos para JTable
Alterar dados em um JTable
Inserir e excluir linhas da tabela

Eventos para JTable
Todo objeto de tabela utiliza o objeto modelo de tabela para gerenciar os dados atuais
da tabela. O objeto modelo de tabela deve implementar a interface TableModel que est
no pacote javax.swing.table. Se o programador no fornecer uma implementao para a
interface a JTable automaticamente cria uma instncia de DefaultTableModel.
Devemos implementar um modelo de tabela como uma subclasse da classe
AbstractTableModel. Vejamos o cdigo para criar um modelo para o exemplo atnerior.
import javax.swing.table.*;
import java.awt.*;
public class AcaoJTable{
final private JTable minhaTabela;

public AcaoJTable(){
//configura o modelo de trabalho da tabela
minhaTabela = new JTable(new ModeloTabela());

//configra a janela de sada da tabala
minhaTabela.setPreferredScrollableViewportSize(new
Dimension(500, 50));
//configura o modo de selecao
minhaTabela.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
//adiciona o modo de selecao para a linha
ListSelectionModel selecaoLinha =
minhaTabela.getSelectionModel();
rolagem = new JScrollPane(minhaTabela);
janela.add(painel);
//mostra a janela
//mostra o nmeo de linhas da tabela
JOptionPane.showMessageDialog(null, "Colunas:
"+minhaTabela.getColumnCount());
//mostra o nmero de colunas da tabela
JOptionPane.showMessageDialog(null, "Linhas:
"+minhaTabela.getRowCount());
//mostra o nome das colunas
JOptionPane.showMessageDialog(null,"Coluna
1:"+minhaTabela.getColumnName(0));
JOptionPane.showMessageDialog(null,"Coluna 2:
"+minhaTabela.getColumnName(1));
JOptionPane.showMessageDialog(null,"Coluna 3:
"+minhaTabela.getColumnName(2))

//mostra o valor de uma clula
JOptionPane.showMessageDialog(null,"Clula
2,1:"+minhaTabela.getValueAt(2,1));
//retorna o tipo de objeto de dentro da clula
JOptionPane.showMessageDialog(null,"Tipo
objeto:"+minhaTabela.getColumnClass(2));
//torna a clula 2,1 editvel
minhaTabela.isCellEditable(2,2);
//altera o valor de uma clula
minhaTabela.setValueAt(89,0,2);
}
//cria o modelo da tabela atravs de classe interna
class ModeloTabela extends AbstractTableModel{
private String[] nomeColunas = {"Nome","Endereo","Telefone"};
private Object[][] dados = {
{"Carla","Rua A", new Integer(3198)},
{"Marcos", "Rua K",new Integer(3536)},
{"Gustavo", "Rua S",new Integer(3536)},
{"Claudia", "Rua M", new Integer(459)}
};

//retorna o nmero de colunas da tabela
public int getColumnCount(){
return nomeColunas.length;
}
//retorna o nmero de linhas da tabela
public int getRowCount(){
return dados.length;
}
//retorna o nome da coluna
public String getColumnName(int col){

return nomeColunas[col];
}
//retorna valor de uma cluna
public Object getValueAt(int lin, int col){
return dados[lin][col];
}
//retorna o Objetc.class da coluna
public Class getColumnClass(int c){
return getValueAt(0,c).getClass();
}

//torna a tabela editvel alterando o valor 2
//as colunas tornam-se editveis
public boolean isCellEditable(int lin, int col){
if(col < 2){
return false;
}
else{
return true;
}
}
//permite que os dados sejam alterados
public void setValueAt(Object valor, int lin, int col){
dados[lin][col] = valor;
fireTableCellUpdated(lin, col);
}
}
}
Como a classe AbstractTableModel uma classe abstrata, alguns de seus mtodos
tiveram que ser implementados.

"Ouvindo" as mudanas
O modelo de tabela tem um conjunto de listeners que so notificados quando um dado
na tabela modificado. Listeners so instncias de TableModelListener que esto no
pacote javax.swing.event.
O cdigo abaixo mostra como devemos criar uma classe que tenha um listener(ouvidor)
import javax.swing.event.*;
import javax.swing.table.*;
import java.awt.*;
public class ListenerJTable{
final private JTable minhaTabela;

public ListenerJTable(){
//configura o modelo de trabalho da tabela
minhaTabela = new JTable(new ModeloTabela());
//configra a janela de sada da tabala
minhaTabela.setPreferredScrollableViewportSize(new
Dimension(500, 50));
//configura o modo de selecao
minhaTabela.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
//instancia a classe TrataEvento
//registra o evento para a tabela
minhaTabela.getModel().addTableModelListener(te);
rolagem = new JScrollPane(minhaTabela);

janela.add(painel);
//mostra a janela
}
//cria o modelo da tabela atravs de classe interna
class ModeloTabela extends AbstractTableModel{
private String[] nomeColunas = {"Nome","Endereo","Telefone"};
private Object[][] dados = {
{"Carla", "Rua A", new Integer(3198)},
{"Marcos", "Rua K",new Integer(3536)},
{"Gustavo", "Rua S",new Integer(3536)},
{"Claudia", "Rua M", new Integer(459)}
};
//retorna o nmero de colunas da tabela
public int getColumnCount(){
return nomeColunas.length;
}
//retorna o nmero de linhas da tabela
public int getRowCount(){
return dados.length;
}
//retorna o nome da coluna
public String getColumnName(int col){
return nomeColunas[col];
}
//retorna valor de uma cluna

public Object getValueAt(int lin, int col){
return dados[lin][col];
}
//retorna o Objetc.class da coluna
public Class getColumnClass(int c){
return getValueAt(0,c).getClass();
}
//torna a tabela editvel alterando o valor 2
//a coluns tornam-se editveis
public boolean isCellEditable(int lin, int col){
if(col < 2){
return false;
}
else{
return true;
}
}
//permite que os dados sejam alterados
public void setValueAt(Object valor, int lin, int col){
dados[lin][col] = valor;
fireTableCellUpdated(lin, col);
}
}
//classe interna de tratamento de eventos
private class TrataEvento implements TableModelListener{
public void tableChanged(TableModelEvente){
int lin = e.getFirstRow();
int col = e.getColumn();
TableModel modelo = (TableModel)e.getSource();
String nomeColuna = modelo.getColumnName(col);
Object dado = modelo.getValueAt(lin, col);

//informaes da tabela
JOptionPane.showMessageDialog(null, "Coluna:" +nomeColuna);
JOptionPane.showMessageDialog(null, "linha: " +lin);
JOptionPane.showMessageDialog(null, "coluna: " +col);
JOptionPane.showMessageDialog(null, "Valor atual:" +dado);
}
}
}
public class ExecutaListenerJTable {
ListenerJTable tb = new ListenerJTable();
}
}

Inserindo e excluindo linhas na tabela
JTable no to complicado quanto parece. Existem vrias formas de adicionar um
JTable em uma aplicao e o exemplo abaixo uma forma simplificada. Ao programar
um JTable o importante a criao do objeto JTable.
Devemos configurar o modelo do JTable utilizando o mtodo setModel onde os
parmetros so uma matriz Object e um etor String. Depois de configurado o JTable
podemos utilizar os mtodos:
addRow - adiciona uma linha na tabela
removeRow - remove uma linha da tabela
Um objeto da classe DefaultTableModel o objeto que manipula a insero e excluso
de linhas em uma tabela j que no podemos inserir ou excluir linhas diretamente no
objeto tabela. Vejamos o exemplo:

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JButton;
import javax.swing.JTable;
import java.awt.Dimension;
import javax.swing.border.TitledBorder;
import javax.swing.table.DefaultTableModel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.GridLayout;
import java.awt.FlowLayout;
public class AdicionaExcluiLinhas {
JFrame janela;
JPanel painelTabela;
JPanel painelComandos;
JButton btoAdicionar, btoApagar, btoSair;
JScrollPane rolagem;
JTable tabela;
DefaultTableModel dtm;
public AdicionaExcluiLinhas(){
janela = new JFrame("Adicionar e Remover");
painelTabela = new JPanel();
painelComandos = new JPanel();
btoAdicionar = new JButton("Adicionar");
btoApagar = new JButton("Apagar");
btoSair = new JButton("Sair");
tabela = new JTable();
dtm = new DefaultTableModel();

//configura os painis
painelTabela.setLayout(new FlowLayout());
painelComandos.setLayout(new GridLayout(0,1));
painelTabela.setBorder(new TitledBorder("Tabela"));
//define o modelo da tabela
tabela.setModel(new DefaultTableModel(new Object[][]{}, new
String[]{"","Nome", "Endereo","Telefone"}){});
tabela.getColumnModel().getColumn(0).setPreferredWidth(10);
tabela.getColumnModel().getColumn(0).setResizable(false);
tabela.getColumnModel().getColumn(1).setResizable(true);
tabela.getTableHeader().setReorderingAllowed(false);
tabela.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
//configura a dimenso da tabela
tabela.setPreferredScrollableViewportSize(new Dimension(490,50));
//coloca uma barra de rolagem na tabela
rolagem = new JScrollPane(tabela);
//adiciona a tabela ao painel tabela
painelTabela.add(rolagem);
//adiciona o botao adicionar ao painel de comandos
painelComandos.add(btoAdicionar);
//adicionar o botao apagar ao painel de comandos
painelComandos.add(btoApagar);
//adicionar o botao sair ao painel de comandos
painelComandos.add(btoSair);

//adiciona os painis a janela
janela.add(painelTabela);
janela.add(painelComandos);
//mostra a janela
//instancia a classe interna TrataEvento
//registra um evento para os botes
btoAdicionar.addActionListener(te);
btoApagar.addActionListener(te);
btoSair.addActionListener(te);
}
//classe interna TrataEvento
//verifica se Adicionar foi pressionado
if(e.getSource() == btoAdicionar){
dtm = (DefaultTableModel)
tabela.getModel();
dtm.addRow(new Object[]{" ","","",""});
}
//verifica se Apagar foi pressionado
if(e.getSource() == btoApagar){
int[] linha = tabela.getSelectedRows();
dtm = (DefaultTableModel)
tabela.getModel();
for(int i = (linha.length-1); i >= 0; --i)
dtm.removeRow(linha[i]);
}

//verifica se Sair foi pressionado
if(e.getSource() == btoSair){
System.exit(0);
}
}
}
}
Para executar o exemplo acima fazemos:
public class ExecutaAdicionaExcluiLinhas{
AdicionaExcluiLinhas ael = new AdicionaExcluiLinhas();
}
}

Exerccios
1. Execute o exemplo acima para ver o resultado.
2. Divirta-se agora com palavras cruzadas sobre Programao Orientada a Objetos
clicando aqui


Nota de aula 15

Definir e utilizar excees em Java
Manipular arquivos em Java

Manipulando excees
O tratamento de excees (no de erros) em Java um mecanismo simples mas
poderoso para tratamento de eventos excepcionais durante a execuo de um programa
em Java. Uma exceo algo inesperado que pode acontecer durante a execuo do
programa como por exemplo:
Falhas no tratamento de arquivos (tentar abrir arquivos que no existe, escrever em
aquivo protegido...);
Entrada invlida de dados;
Falhas na comunicao entre processos;
Erros aritmticos;
Estouro de limites de arrays;
Diviso por zero;
etc.
Quando usamos excees podemos destacar claramente a separao entre o fluxo
normal de execuo do programa e o tratamento de condies excepcionais.
Vejamos um exemplo:
...
codErro = 0;
Comandos1
if (!erro1) { //Verifica se aconteceu um erro
Comandos2; //Executa Comandos2 se no aconteceu erro 1

if (!erro2) { //Verifica se aconteceu um outro tipo de erro
Comandos3; //Executa Comandos3 se no aconteceu erro 2 Comandos3
if (!erro3) { //Verifica se aconteceu um outro tipo de erro
... //Caso no tenha acontecido o erro3 executa outros comanos
}
else {
codErro = -3; //Atribui um valor a varivel codErro
}
} else {
codErro = -2; //atribui um valor a varivel codErro
}
} else {
codErro = -1; //atribui um valor a varivel codErro
}
if (codErro < 0) //Verifica o valor atual da varivel codErro
tratarErro(codigoErro); //Trata o erro
...
Podemos observar que o cdigo acima fica bem "poludo" e complicado de se entender
dependendo do tamanho.
Vejamos agora o tratamento de erros utilizando Excees.
...
try {
Comandos1;
Comandos2;
Comandos3;
} catch (erro1) {
//Trata o erro1 capturado pela exceo
} catch (erro2) {

} catch (erro3) {
} finally{
//Comando que SEMPRE ser executado independentemente se ocorreu ou no uma
exceo.
//Um exemplo seria a liberao de recursos (arquivos,conexes....).
}
...
Podemos ver que o cdigo fica muito mais simples com o tratamento de excees. No
bloco iniciado com o comando try colocamos todos os comandos que podem lanar
uma exceo. As excees lanadas so capturadas pelos blocos catch que alm de
capturar a exceo j fazem o tratamento. A clusula finally sempre ser executada
disparando ou no uma exceo. Ela usada para liberao de recursos do sistema
como arquivos, conexes etc.
Caso as excees que compem o sistema no satisfizer o programador, ento ele pode
construir suas prprias. Para construir uma exceo necessrio primeiro construir uma
classe que deve possuir pelo menos um mtodo que ir tratar a exceo. Vejamos o
cdigo:
public class ExcValidaNome{

void validaNome(String nome)throws ExcecaoNome{

String restricao = "1234567890!@#$%&*()-_=+{[^~ }]<>.,:;?/|\'/";

for(int i=0; i<nome.length(); i++){

for(int j=0; j<restricao.length(); j++){

if(nome.charAt(i) == restricao.charAt(j)){

throw new ExcecaoNome();
}
}
}
}
}
Podemos observar no cdigo acima que o mtodo validaNome que est na
classe ExcValidaNome tem como parmetro um valor do tipo String chamado nome e
que ele "arremessa" (throws) uma exceo que est no mtodo validaNome da
classe ExcValidaNomequando o valor de nome tiver um caractere especial. Em outras
palavras, o mtodo validaNome s aceita caracteres de A a Z caso contrrio ele dispara
a exceo que est na classe ExcecaoNome utilizando o mtodo validaNome. Essa
exceo disparada toda vez que o valor de parmetro passado para nome tiver um
caractere especial que est na string restricao.
Devemos agora escrever a classe que tem os mtodos tratadores de exceo
class ExcecaoNome extends Exception {
public String nomeDigitado(){
return "No um nome vlido";
}
}
A classe acima contm o mtodo que ser acionado quando uma exceo acontecer (i.e
quando o nome tiver algum caractere especial). Nesse exemplo uma mensagem de erro
ser emitida ao usurio.
Agora escreveremos a aplicao. Vejamos:
public class AppExcValidaNome {
ExcValidaNome vd = new ExcValidaNome();

try{
vd.validaNome("Gustavo$#");
}catch(ExcecaoNome e){
System.out.println(e.nomeDigitado());
}
}
}
O cdigo acima instancia um objeto da classe ExcValidaNome e invoca o
mtodo validaNome("Gustavo$#"). Essa invocao est entre um bloco try que um
bloco onde colocamos cdigos que so passveis de disparar uma exceo. Como o
valor do parmetro foi "Gustavo$#" que possui caracteres especiais ento uma exceo
disparada e capturada pelo bloco catch.
Podemos ter mais de um mtodo dentro de uma classe que trata excees.

Manipulando arquivos
A leitura e escrita de arquivo em Java fcil. Como Java uma linguagem Orientada a
Objetos ento devemos usar as classes que se tornaro objetos para trabalharmos com
entrada e sada (input/output) ou IO. A linguagem Java trata as Streams que so fluxos
de dados e tem controle sobre ele.
Para utilizarmos as classes que manipulam arquivos em Java devemos importar o pacote
java.io possui as classes que fazem a leitura e gravao de arquivos.
As instncias da classe java.io.File os caminhos para os locais onde o arquivo ser
gravado ou lido no sistema operacional. Vejamos um exemplo onde criada uma
instncia da classe File direcionada para /atenac/arquivos/meuteste.txt.
File arquivo = new File("/atenac/arquivos/teste.txt");
O cdigo abaixo mostra como gravar ou ler um arquivo que est no diretrio corrente.
File arquivo = new File("teste.txt");

O exemplo abaixo mostra como gravar ou ler um arquivo que est no diretrio anterior
ao cdigo do programa.
File arquivo = new File("../teste.txt");
Quando utilizamos o Sistema Operacional Windows devemos utilizar duas barras
invertidas para navegar entre diretrios (pastas).

Escrevendo em arquivos
Uma instncia da classe java.io.FileWrite permite que possamos escrever em um
arquivo. Vejamos:
FileWriter escrever = new FileWriter(new File("teste.txt"),true);
FileWriter escrever = new FileWriter(new File("teste.txt"));
O parmetro true utilizado no exemplo acima indica que podemos adicionar dados a um
arquivo j existente e que o arquivo no ser sobrescrito.
Para escrevermos em um arquivo utilizamos instncias da classe java.io.PrintWriter que
possui os mtodos print e println utilizados para escrever no arquivo. Vejamos a
instncia da classe PrintWriter:
PrintWriter saida = new PrintWriter(escrever);
PrintWriter saida = new PrintWriter(escrever,true);
O parmetro true significa que os dados sero enviados para o arquivo toda vez que
ocorrer uma chamada do mtodo println(). Quando no colocamos o parmetro true
significa que os dados s so enviados quando enviarmos uma quebra de linha,
fecharmos o arquivo ou atualizarmos o arquivo. O cdigo abaixo mostra como devemos
escrever em um arquivo:
escrever.println("Atenac");
escrever.println("desde 2008");
escrever.println("Curso de POO");

Depois de escrever no arquivo, devemos fecha-lo.
saida.close();
escrever.close();
Exemplo
import java.io.*;
public class EscreveArquivo{
try{
FileWriter canal = new FileWriter(new File("meuarquivo.txt"), true);
PrintWriter escreve = new PrintWriter(canal);
escreve.println("aqui tem um texto");
escreve.println("continua o texto aqui");
escreve.close();
canal.close();
}
catch(Exception e){
e.printStackTrace();
}
}
}
O cdigo acima abre um canal de comunicao com um arquivo
chamado meuarquivo.txt utilizando a classe FileWriter atravs da varivel de
referncia canal. A classe PrintWriter instancia uma varivel escreve que ir escrever
no canal de comunicao aberto entre a aplicao e o arquivo em disco. O
mtodo println da classe PrintWriter utilizado para fazer a escrita no arquivo.
Depois de escrito no arquivo devemos fechar a escrita e o canal de comunicao
utilizando o mtodo close(). Todo cdigo deve estar entretry e catch pois vrias
excees podero acontecer durante o processo.

Lendo um arquivo escrito
Para fazermos uma leitura de um arquivo texto devemos utilizar a classe FileReader do
pacote java.io (java.io.FileReader).
Os construtores da classe FileReader so:
FileReader reader = new FileReader(new File(texto.txt));
FileReader reader = new FileReader(texto.txt);
Primeiro devemos instanciar um objeto da classe BurreferedReader
(java.io.BufferedReader) que ir fornecer o mtodoreadLine() que faz a leitura das
linhas do arquivo. Construtores da classe BufferedReader esto abaixo:
BufferedReader leitor = new BufferedReader(reader);
BufferedReader leitor = new BufferedReader(reader,1*1024*1024);
possvel especificar o tamanho do buffer desejado utilizando o construtor da
classe BufferedReader.O buffer utilizado para minimizar o nmero de pedidos
de io para ler blocos de dados maiores do arquivo de uma vez s. A vantagem que se
aumentarmos o nmero, mais dados sero lidos de uma nica vez diminuindo o nmero
de acesso ao disco. A desvantagem que se o nmero for muito alto o consumo de
memria ser muito alto.

Exemplo
import java.io.*;
public class LeArquivo{
public static void main (String[]args){
try{
BufferedReader le = new BufferedReader(new FileReader("meuarquivo.txt"));
while(le.ready()){
String linha = le.readLine();
System.out.println(linha);

}
le.close();
}catch(IOException e){
}
}
}
Exerccios
1. Escreva um programa, utilizando a interface grfica, que faz a leitura de um
nmero qualquer. O nmero aceito pelo sistema apenas o nmero 7. Crie uma
exceo para tratar o valor digitado pelo usurio caso o valor digitado seja
diferente de 7. O tratamento pode ser uma mensagem de erro.
2. Faa um programa para calcular a diviso de dois nmeros quaisquer.
3. Execute o programa e faa a diviso de 79 dividido por 0.
4. Capture a exceo lanada utilizando o mtodo printStackTrace() da classe
Exception.
5. Faa com que o foco seja novamente apontado para o denominador.
6. Escreva um programa para ler o seu nome e endereo e escreve em um arquivo
texto. O programa dever solicitar o nome do arquivo a ser gravado.
7. Escreva um programa para ler o arquivo gravado solicitando o nome do arquivo.


Nota de aula 16

Utilizar drivers para banco de dados
Incluir, consultar, excluir e alterar dados em um banco de dados.

Banco de dados em Java
Ao desenvolver um sistema precisamos ter uma funcionalidade essencial que a
habilidade para comunicar-se com um repositrio de dados. Os Bancos de Dados
constituem o tipo mais simples de repositrio. Java dispe de uma API para acessar
repositrios de dados: a Java DataBase Connectivity API ou JDBC API. A vantagem de
JDBC a portabilidade da aplicao cliente, inerente da linguagem Java.
A JDBC uma especificao para os desenvolvedores de drivers JDBC e os
desenvolvedores de aplicaes clientes que precisem acessar bancos de dados em Java.
Vamos utilizar a IDE Eclipse para construir programas que fazem comunicao com um
banco de dados MySQL.
Siga os passos abaixo:
1. Baixar a ferramenta Eclipse em http://baixaki.ig.com.br/download/eclipse-
sdk.htm


1. Descompacte o arquivo em C:\Eclipse (por exemplo);
2. Baixe o driver do MySQL em http://dev.mysql.com/get/Downloads/Connector-
J/mysql-connector-java-3.1.14.zip/from/pick para que a linguagem Java possa
conectar com o banco de dados;
3. Inicie o eclipse iniciando o arquivo C:\eclipse\eclipse.exe
4. A janela abaixo ser mostrada

1. Indique onde seus cdigos fonte sero gravados;
2. Logo aps a janela do Eclipse ser aberta. A tela inicial mostra a janela de boas
vindas "Welcome". Podemos fechar essa janela para iniciar os trabalhos.
Criando um novo projeto no Eclipse
1. Clique em File > New > Java Project
2. Digite o nome do projeto. Exemplo ProjetoBancoDados.
3. Clique em Finish.
Criando uma classe no Eclipse
1. Clique em File > New > Class
2. Digite o nome da classe. Exemplo Insere.
3. Clique em Finish.

Acessando o MySQL no Eclipse
1. Descompacte o arquivo mysql-connector-java-5.1.6.zip em C:
2. Clique com o boto direito do mouse em cima do nome do projeto criado;
3. Selecione Build Path > Add External Archives...
4. Selecione o arquivo mysql-connector-java-5.1.6-bin.jar;
Vamos escrever um cdigo para verificar se a instalao foi feita com sucesso. Crie um
banco de dados chamado bdTeste que possua uma tabela chamada tbUsusario que tenha
os campos usuario (30) e senha (5). No se esquea de iniciar o XAMPP e iniciar
tambm o MySQL. Logo depois digite o cdigo abaixo:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class Insere{
//Variveis de mtodo
Connection conexao = null;
Statement stm = null;
String msg = "";
ResultSet rs = null;
try {
//faz a conexo jdbc com a base de dados
Class.forName("com.mysql.jdbc.Driver").newInstance();

conexao=DriverManager.getConnection("jdbc:mysql://localhost:3306/bdTeste","root",
"");

//jdbc:mysql://localhost:3306
//jdbc:mysq://localhost onde o banco de dados est hospedado.

//3306 a porta (padro do MySQL) que ser utilizada para a comunicao com o
banco de dados.
//root o usurio padro do MySQL e a senha ficar vazia (padro).
//stm objeto que recebe a conexo
stm = conexao.createStatement();
//Caso no ocorra nenhum erro na conexo uma mensagem de erro ser mostrada.
msg = "Conexao realizada com sucesso";
System.out.println(msg);
//rs recebe o retorno da consulta SQL
rs = stm.executeQuery("select * from tbUsuario");
// Imprime os dados
while (rs.next()){
String nome = rs.getString(1);
String senha = rs.getString(2);
System.out.println(nome);
System.out.println(senha);
}
//O objeto que recebeu a conexo (stm) recebe a instruo de insero
//caso seja efetuado com sucesso a mensagem exibida
stm.executeUpdate("insert into tbUsuario (usuario,senha)values
('Gustavo','be092')");
System.out.println("comando insert executado com exito");
// catch usado para avisar se der algum erro na consulta SQL com um Exception
}catch (Exception e){
msg = "Erro de conexo " + e.getMessage();
System.out.println(msg);
}
}
}
Vamos melhorar a aplicao acima.

Consulta
J fizemos a insero do usurio e da senha no banco de dados. Agora vamos consultar
os dados inseridos.
Cdigo:
import java.sql.SQLException;

class Consulta {
Connection con = null;
try {
con =
DriverManager.getConnection("jdbc:mysql://localhost:3306/bdTeste","root","");
Statement stm = con.createStatement();
String SQL = " Select * from tbusuario";
ResultSet rs = stm.executeQuery(SQL);
while (rs.next()) {
String usuario = rs.getString("usuario");
String senha = rs.getString("senha");
System.out.println(" Usurio: " + usuario);
System.out.println(" Senha: " + senha);
}
} catch (SQLException e) {
} catch(Exception ex){
ex.printStackTrace();
}finally {

try {
con.close();
}catch (SQLException onConClose) {
System.out.println(" Erro no fechamento da conexo ");
onConClose.printStackTrace();
}
}
}
}

Delete
Para apagar um dado da tabela use o mtodo executeUpdate() ao invs do mtodo
executeQuery(). Veja o cdigo abaixo:

class Delete {
try {
con =
String SQL = "DELETE FROM tbusuario";
int rs = stm.executeUpdate(SQL);
} catch (SQLException e) {

}finally {
try {
con.close();
}
}
}
}

Altera
Vamos agora escrever o cdigo para alterar os dados inseridos na tabela. Ateno nas
aspas utilizadas na concatenao da varivel com a string. Aqui voc ir tambm utilizar
o comando executeUpdate() para alterar os dados.

class Altera {
String novoUsuario = "Janete";
String novaSenha = "3333";
String usuarioAtual = "Ana";
String usuario = null;
String senha = null;

try {
//registra o driver jdbc
//abre a conexo com o driver
con =
//cria um statement para executar a query
//fazemos uma consulta para encontrar a linha que queremos alterar
String SQL = "SELECT * FROM tbusuario WHERE usuario ='"+usuarioAtual+"'";
//executamos o comando sql com a Statement.executeQuery
//essa execuo devolve um conjunto de dadoos para o ResultSet
ResultSet rs = stm.executeQuery(SQL);
//mostra os valores encontrados no conjunto de dados retornados.
while (rs.next()) {
usuario = rs.getString("usuario");
senha = rs.getString("senha");
System.out.println(" Usurio: " + usuario);
System.out.println(" Senha: " + senha);
}
//constroi uma string para fazer a alterao
String SQL_ALTERA = "UPDATE bdteste.tbusuario SET usuario =
'"+novoUsuario+"', senha = '"+novaSenha+"' WHERE tbusuario.usuario =
'"+usuario+"' AND tbusuario.senha = '"+senha+"' LIMIT 1 ;" ;
//executa a strint de alterao
stm.executeUpdate(SQL_ALTERA);
//trata as excees capturadas
//faz o fechamento da conexo.

}finally {
try {
con.close();
}
}
}
}

Usando o NetBeans
Para construir aplicaes usando o NetBeans leia o tutorial em
http://www.netbeans.org/kb/docs/ide/mysql_pt_BR.html

Exerccios
1. Escreva um programa para criar uma agenda eletrnica com nome, telefone e e-
mail. O programa dever utilizar interface grfica e fazer as operaes de
incluso, excluso, alterao e consulta.

2. Execute e analise o cdigo abaixo:
ackage classes;
public String nome;

this.nome = n;
}


return this.nome;
}
}
Veja que a classe pessoa est dentro de um pacote chamado classes
package classes;

public class PessoaFisica extends Pessoa{
public boolean isCPF;
public String CPF;

public void setCPF(String cpf){
if (cpf.length() == 11 ) {
int d1, d2;
int digito1, digito2, resto;
int digitoCPF;
String nDigResult;
d1 = d2 = 0;
digito1 = digito2 = resto = 0;

for (int n_Count = 1; n_Count < cpf.length() -1; n_Count++) {
digitoCPF = Integer.valueOf(cpf.substring(n_Count -1, n_Count)).intValue();
d1 = d1 + ( 11 - n_Count ) * digitoCPF;
d2 = d2 + ( 12 - n_Count ) * digitoCPF;
}

resto = (d1 % 11);

if (resto < 2)
digito1 = 0;

else
digito1 = 11 - resto;

d2 += 2 * digito1;

resto = (d2 % 11);

if (resto < 2)
digito2 = 0;

else
digito2 = 11 - resto;

String nDigVerific = cpf.substring(cpf.length()-2, cpf.length());

nDigResult = String.valueOf(digito1) + String.valueOf(digito2);

this.isCPF = nDigVerific.equals(nDigResult);
this.CPF = cpf;
}

}

public String getCPF(){
return this.CPF;
}
}
O cdigo acima faz a validao do cpf
package InterfaceGrafica;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import classes.*;

public class Cadastro {
JFrame janela;
JLabel lblCpf;
JTextField jtCpf;
JButton jbGravar;
PessoaFisica pf;

public void MostraJanela(){
//instancia a classe PessoaFisica
pf = new PessoaFisica();

//instancia os objetos grficos
janela = new JFrame("Cadastro");
lblCpf = new JLabel("CPF: ");
jtCpf = new JTextField(11);
jbGravar = new JButton("Gravar");

//configura os objetos quanto a posio
janela.setLayout(null);
lblCpf.setBounds(10,20,30,25);
jtCpf.setBounds(40, 20, 80, 25);
jbGravar.setBounds(10, 50, 90, 25);

//adiciona um evento ao boto jbGravar

jbGravar.addActionListener(te);

//adiciona os componentes na janela
janela.add(lblCpf);
janela.add(jtCpf);
janela.add(jbGravar);

//mostra a janela

}

//cria a classe para tratamento do evento

public void actionPerformed(ActionEvent e) {
if(e.getSource() == jbGravar){
//pega o que est escrito no JTextField e passa para o mtodo setCPF
pf.setCPF(jtCpf.getText());

JOptionPane.showMessageDialog(janela, "CPF: "+pf.getCPF());
}
}
}
}
A classe abaixo executa a aplicao exemplo:

package classes;

import InterfaceGrafica.*;

public class AppPessoaFisica {

Cadastro cadastro = new Cadastro();
cadastro.MostraJanela();
}
}
Bom trabalho!!!


REFERNCIAS
[1] Deitel, H.M., Java, como programar, 4.ed. Porto Alegre: Bookman, 2003.
[2] Sierra, K., Bates, B., Certificao Sun para progrmador java 5: Guia de estudo,
4.ed. Rio de Janeiro: AltaBooks, 2006.
[3] Puga, S., Rosseti, G. Lgica de programao e estrutura de dados, com aplicaes
em Java, So Paulo: Prentice Hall, 2003.
[4] Barnes, D.J., Klling, M., Programao orientada a objetos com java: Uma
introduo utilizando o Blue J., S o Paulo: Pearson Prentice Hall, 2004.
[5] Thompson, M.A., Java 2 & banco de dados: aprenda na pratica a usar java e SQL
para acessar banco de dados relacionais., So Paulo: rica, 2002.
[6] Keogh, J., Giannini, M., OOP Desmystified, McGraw-Hill/Osborne, 2004.
[7] Leopoldino, F. L., Instalando o J2SE 5.0 JDK no Windows 2000/XP, site na
internet no
endereo:http://www.guj.com.br/content/articles/installation/j2sdkinstall.pdf acessado
em 16/06/2007.
[8] Wikipdia, site na internet acessado em
16/06/2007 http://pt.wikipedia.org/wiki/Orienta%C3%A7%C3%A3o_a_objetos.
[9] - Caelum: Ensino e Solues em Java, site na internet no endereo:
www.caelum.com.br, acessado em 19 de Dezembro de 2007.

Apostila Poo

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Apostila Poo

Transféré par

Droits d'auteur :

Formats disponibles

Programaa o

Vous aimerez peut-être aussi