Aulas 01a10

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

PROGRAMAÇÃO ORIENTADA A OBJETOS
Oswaldo Borges Peres
Aula 01
Interfaces Gráficas com Swing 
1- Explorar o pacote Swing para desenvolver Interfaces em Java
2- Criar e manipular Menus
3- Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos
4- Aplicar as Interfaces, criando menus em exemplos e exercícios
O Java fornece uma infinidade de funcionalidades para prover comunicação humano-computado. 
 Essas bibliotecas são fornecidas pelo JFC (Java Foundation Classes)
Tipos:
Container
Componentes
3
Interfaces Gráficas 
 java.awt : Abstract Window Toolkit (classes básicas);
 javax.swing : Swing Components – Graphical User Interface
É uma classe abstrata que define as funcionalidades básicas associadas a um container, tais como adicionar e remover componentes, possíveis por meio dos métodos add() e remove(), respectivamente. É possível também estabelecer qual a estratégia de disposição de componentes no container, ou seja, qual o método de gerência de layout, através do método setLayout().
4
Container
É uma classe abstrata que armazena componentes.
Componentes Containers
 JFrame
define objetos que são utilizados para criar aplicativos baseados em GUI. Eles consistem em uma janela com barra de título e uma borda.
JPanel
São elementos que fazem a intermediação entre um container e os demais GUI anexados. Servem para definir grupos de componentes visuais também.
javaawt (Abstract Window Toolkit) - classes básicas: Componentes "pesados" - Para desenhar, utilizava muito do SO, a interface no Windows ficava muito diferente no Linux, por ex. Por conta disso, a partir da extensão AWT, foi desenvolvida a API swing 
Suporta outro componente dentro – 
Armazena COMPONENTES
As constantes SwingConstants, que definem o posicionamento de vários componentes GUI e aqui, são apropriadas ao terceiro argumento, determinam a locação do ícone em relação ao texto São elas:
• SwingConstantsNORTH,
• SwingConstantsSOUTH,
• SwingConstantsEAST,
• SwingConstantsWEST,
• SwingConstantsTOP,
• SwingConstantsBOTTOM,
• SwingConstantsCENTER,
• SwingConstantsHORIZONTAL,
• SwingConstantsVERTICAL,
• SwingConstantsLEADING,
• SwingConstantsTRAILING,
• SwingConstantsNORTH EAST,
 
• SwingConstantsNORTH WEST,
• SwingConstantsSOUTH WEST,
• SwingConstantsSOUTH EAST,
• SwingConstantsRIGHT,
• SwingConstantsLEFT
Jbutton: Simula um botão. 
JCheckBox: Dá suporte a caixa de marcação
JRadioButton: Semelhante à caixa de marcação, só que permite apenas um componente marcado por grupo
JTextField: Disponibiliza uma linha para inserção ou exibição de texto
5
Componentes
JPasswordField: Disponibiliza 1 linha para inserção de texto para senhas
JTextArea: Disponibiliza edição de múltiplas linhas com a mesma fonte. 
JComboBox: 2 comportamentos: Edição de texto ou lista de elementos.
JScrollPane, Jslider... Ver planilha.
Componentes atômicos (Não suportam outros componentes dentro. Botões, labels, textFields, sliders, check boxes, scrollbars...
JLabel - Rótulos estáticos que, geralmente, apresentam funcionalidades de outros componentes GUI, como campos de texto, ícones etc Também serve para apresentar um pequeno texto As instruções são mostradas por meio de uma linha de texto: somente leitura, uma imagem ou ambas O construtor mais elaborado é JLabel (String, Icon, int) Os argumentos: o rótulo a ser exibido, um ícone e o alinhamento, respectivamente. Também, é possível a exibição de ícones em muito dos componentes Swing. Para JLabels, basta especificar um arquivo com extensão png, gif ou jpg no segundo argumento do construtor do JLabel, ou utilizar o método setIcon(Icon). O arquivo da imagem deve encontrar-se no mesmo diretório do programa, ou especifica-se corretamente a estrutura de diretórios até ele. 
Criar uma tela de Cadastro de clientes para receber:
Nome
Email
Senha
Sexo
Estilo de Leitura
Time de Futebol
O botão envia os dados para um objeto a ser criado. Limpar os campos.
6
Passo a Passo
Os menus, que são instanciados a partir da classe JMenu, são anexados a uma barra de menus com o método add(JMenu) de JMenuBar, sendo que instâncias dessa última classe comportam-se como containers para menus. A classe JMenuBar fornece os métodos necessários ao gerenciamento da barra onde os menus são anexados. A ordenação dos mesmos depende da ordem em que foram adicionados, sendo que são “empilhados” horizontalmente da esquerda para a direita
7
Menus
Instancie um JMenuBar. Ele é o responsável pela estrutura do menu.
Adicione tantos JMenu’s quantos forem necessários para as opções.
Dentro de cada JMenu, coloque o JMenuItem, que é o responsável pela opção a ser escolhida.
8
Passo a Passo
PRÁTICA - AULA 01
 
import javaxswingJFrame; import javaxswingJLabel; // swing
import javaxswingJPanel;import javaxswingJTextField;
import javaxswingJPasswordField; import javaxswingJRadioButton;
import javaxswingJCheckBox;import javaxswingJComboBox;
import javaxswingJButton;import javaxswingButtonGroup;
import javaxswingImageIcon; import javaxswingborderTitledBorder;
import javaxswingborderLineBorder;
import javaawtFont; import javaawtColor; //awt
import javaawteventActionEvent;
import javaawteventActionListener;import javaawtImage;
public class TelaCadastro extends JFrame implements ActionListener{
private JLabel lblTitulo = null; private JLabel lblNome = null;
private JLabel lblEmail = null; private JLabel lblSexo = null;
private JLabel lblSenha = null; private JLabel lblEstilo = null;
private JLabel lblTimeFut = null;
private JTextField txtNome = null;
private JTextField txtEmail = null;
private JPasswordField pwdSenha;
private JRadioButton rdbMasculino = null;
private JRadioButton rdbFeminino = null;
private JCheckBox chkEsportes = null;
private JCheckBox chkEducacao = null;
private JCheckBox chkCulinaria = null;
private JComboBox cmbTimesFut = null;
private JButton btnEnviar = null;
private ButtonGroup tipoSexo = null;
public TelaCadastro() {null;private JButton btnEnviar = null; pri
inicializaComponentes();
@SuppressWarnings("unchecked") // <editor-fold defaultstate="collapsed" desc="Generated Code">
private void inicializaComponentes() {
JPanel TelaCadastro = new javaxswingJPanel();
Color CORFUNDO = new Color(153, 255, 153);
JFrame formulario = new JFrame();
Font fTit = new Font("Arial", FontBOLD, 16);
formulariosetLocation(400, 100);
formulariosetSize(450, 450); formulariosetDefaultCloseOperation(JFrameEXIT_ON_CLOSE);
JLabel imgLogo= new JLabel(); imgLogosetBounds(2,2,58, 58);
imgLogosetHorizontalAlignment(JLabelCENTER);
imgLogosetBackground(CORFUNDO); //
ImageIcon logoJava = new ImageIcon( TelaCadastroclassgetResource("/imagens/Java_Logopjpg"));
Image lJava =logoJavagetImage()getScaledInstance(imgLogo getWidth(),imgLogogetHeight(),ImageSCALE_SMOOTH);
imgLogosetIcon(new ImageIcon(lJava));
JLabel txtTitulo=new JLabel ("Cadastro de Clientes");//Titulo
txtTitulosetBounds(0,25,450,20);
txtTitulosetFont(fTit);
txtTitulosetHorizontalAlignment(JLabelCENTER);
JLabel lblNome = new JLabel("Nome:");
lblNomesetBounds(30,100,100,20);
lblNomesetHorizontalAlignment(JLabelRIGHT);
JTextField txtNome = new JTextField();
txtNomesetBounds(135,100,180,20);
JLabel lblEmail = new JLabel("e-mail:");
lblEmailsetBounds(30,125,100,20);
lblEmailsetHorizontalAlignment(JLabelRIGHT);
JTextField txtEmail = new JTextField();
txtEmailsetBounds(135,125,180, 20);
JLabel lblSenha = new JLabel("Senha:");
lblSenhasetBounds(30,150,100, 20);
lblSenhasetHorizontalAlignment(JLabelRIGHT);
JPasswordField pwdSenha = new JPasswordField();
pwdSenhasetBounds(135,150,180, 20);
JLabel lblSexo = new JLabel("Sexo:"); lblSexosetBounds(30,175,100, 20);
lblSexosetHorizontalAlignment(JLabelRIGHT);
JRadioButton rdbMasculino = new JRadioButton("Masculino", false);
rdbMasculinosetBounds(131,175,100, 20);
JRadioButton rdbFeminino = new JRadioButton("Feminino", false);
rdbFemininosetBounds(240,175,100, 20);
ButtonGroup tipoSexo = new ButtonGroup();
tipoSexoadd(rdbMasculino); tipoSexoadd(rdbFeminino);
JLabel lblEstilo = new JLabel("Estilo de Leitura:");
lblEstilosetBounds(30,210,100, 20);
lblEstilosetHorizontalAlignment(JLabelRIGHT);
JCheckBox chkEsportes = new JCheckBox("Esportes", false);
chkEsportessetBounds(131,210,150, 20);
JCheckBox chkEducacao = new JCheckBox("Educação", false);
chkEducacaosetBounds(131,235,150, 20);
JCheckBox chkCulinaria = new JCheckBox("Culinária", false);
chkCulinariasetBounds(131,260,150, 20);
JLabel lblTimeFut = new JLabel("Time de Futebol:");
lblTimeFutsetBounds(30,300,100, 20);
lblTimeFutsetHorizontalAlignment(JLabelRIGHT);
JComboBox cmbTimesFut = new JComboBox();
cmbTimesFutsetModel(new javaxswingDefaultComboBoxModel<>(new String[] {"", "Flamengo", "Fluminense", "Botafogo", "América", "Vasco" }));
cmbTimesFutsetBounds(133,300,178, 20);
JButton btnEnviar= new JButton("Enviar"); // Botão Enviar
btnEnviaraddActionListener(this);
btnEnviarsetBounds(330,350, 70, 20);
formulariosetLayout(null); // Adicionando ao Layout
formularioadd(imgLogo); formularioadd(txtTitulo);
formularioadd(lblNome); formularioadd(txtNome);
formularioadd(lblEmail); formularioadd(txtEmail);
formularioadd(lblSenha); formularioadd(pwdSenha);
formularioadd(lblSexo); // RadioButton
formularioadd(rdbMasculino);
formularioadd(rdbFeminino);
formularioadd(lblEstilo); //CheckBox
formularioadd(chkEsportes); formularioadd(chkEducacao);
formularioadd(chkCulinaria);
formularioadd(lblTimeFut); formularioadd(cmbTimesFut); //ComboBox
formularioadd(btnEnviar); formulariosetVisible(true); pack(); } //</editorfold>
public void actionPerformed(ActionEvent e) {
txtNomesetText(""); txtEmailsetText(""); pwdSenhasetText("");
tipoSexoclearSelection(); chkEsportessetSelected(false);
chkEducacaosetSelected(false); chkCulinariasetSelected(false);
}
private void chkEsportesActionPerformed(javaawteventActionEvent evt) { }
private void chkEducacaoActionPerformed(javaawteventActionEvent evt) { }
private void chkCulinariaActionPerformed(javaawteventActionEvent evt) { }
private void cmbTimesFutActionPerformed(javaawteventActionEvent evt) { }
private void btnEnviaActionPerformed(javaawteventActionEvent evt) { }
private void jTextField_$NomeActionPerformed(javaawteventActionEvent evt) { }
public static void main(String args[]) {
new TelaCadastro()setVisible(true);
}}
9
Ex 1 – Aula 1
public static void main(String[] args) {
 // TODO code application logic here
 JFrame formulario = new JFrame();
 JLabel rotulo = new JLabel("Exemplo de Label");
 formulario.setLocation(100, 100);
 formulario.setSize(500, 200);
 formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 formulario.add(rotulo);
 formulario.setVisible(true);
 }
}
OK.
Aula 02
Gerenciadores de Layouts
Gerenciadores de Layouts
Organizam os componentes GUI em um Container de objetos.
Sua função é facilitar a vida do designer na construção de interfaces
Método: setLayout()
11
CONSTANTES
EFEITO
FlowLayout.CENTER
alinha aocentrode cada linha de componentes
FlowLayout.LEFT
Alinha a partir damargem esquerdado gerenciador.
FlowLayout.RIGHT
Alinha a partir damargem direitado gerenciador.
FlowLayout.LEADING
Alinhajustificadamentepara ocanto principalda orientação do gerenciador
FlowLayout.TRAILING
Alinhajustificadamentepara opróximo cantoda orientação do gerenciador
FlowLayout
Dispõe os componentes sequencialmente na janela.
Comumente usado para arrumar botões em painéis.
12
O método setAlignment(int align) permite definir o alinhamento.
Alterando o Alinhamento
GridLayout
Dispõe os componentes em um grid. O tamanho dos componentes será ajustado automaticamente à medida que a janela é redimensionada.
13
CONSTRUTOR
FUNÇÃO
new GridLayout();
Cria umagrade com apenas uma linhae onúmero de colunas necessárias para colocar todos os componentes, um em cada coluna.
newGridLayout(int rows, int cols);
Cria uma grade com onúmero de linhas e colunas definidos pelos parâmetros.
newGridLayout(int rows, int cols, int hgap, int vgap);
Cria uma grade com o número de linhas e colunas definidos pelos parâmetros.
Além disso, informamos oespaçamento horizontal e verticalentre os componentes.
BorderLayout
Dispõe os componentes GUI em cinco áreas: norte (parte superior), sul (parte inferior), leste (lado direito), oeste (lado esquerdo) e centro.
Constantes:
BorderLayout.NORTH, 
BorderLayout.SOUTH, 
BorderLayout.EAST, 
BorderLayout.WEST
BorderLayout.CENTER.
14
GridBagLayout
Semelhante a GridLayout, mas diferente por podermos variar o tamanho dos componentes, além de adicionar em qualquer ordem. Cada objeto do GridBagLayout mantém uma grade de células retangulares. 
15
O contêiner é dividido numa grade de
células formadas por linhas e colunas
O alinhamento do componente dentro
da célula pode ou não manter suas 
dimensões originais quando houver 
redimensionamento da janela.
Em cada célula pode haver apenas um componente a ser expandido de forma a ocupar uma área correspondente a uma ou mais linhas e/ou colunas.
Passo a passo
Montando a tela ao lado com 3 colunas e vários componentes em cada coluna
16
Aula 03
Desenvolvendo 
Interfaces Mais Ricas
1 - Controlar aspectos visuais.
2 - Construir Menus para usuários.
3 - Manipular Caixas de informações e diálogos.
4 - Apresentar componentes de trabalho, como campos e botões.
5 - Apresentar campos de interfaces como listas e caixas de opção.
Para se utilizar de uma fonte que está instalada no seu computador, podemos listar todas as fontes instaladas. Para isso, temos o comando:
String listaDeFontes[ ] = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames( );
Como exemplo de utilização, faremos um exemplo para apresentar etiquetas com o nome das fontes, 
todas com tamanho 14 e texto normal. O texto da etiqueta será o nome da fonte.
Ao desenvolver uma Interface, é fundamental interferir em seus componentes visuais como:
Fontes
Cursores
Bordas
Cores
Nas fontes
No segundo plano – fundo
18
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GraphicsEnvironment;
import javax.swing.JLabel;
/** @author Eduardo */
public class JFrameFontes extends javax.swing.JFrame {
/** Creates new form JFrameFontes */
public JFrameFontes() {
super("Teste das Fontes ");
initialize();
}
FlowLayout layout;
private void initialize() {
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setPreferredSize(new Dimension(400, 200));
String listaDeFontes[ ] =GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames( );
int i = listaDeFontes.length;
layout = new FlowLayout();
setLayout(layout);
getContentPane().setLayout(layout);
JLabel jb;
Font f;
for (int j=0; j<i; j++){
jb = new JLabel("XX - "+listaDeFontes[j]+" -XX"); //Cria o label
f=new Font(listaDeFontes[j],Font.PLAIN, 14); // cria a fonte
jb.setFont(f); //define a fonte do label
add(jb); //adiciona o label
}
pack();
}
/** This method is called from within the constructor to initialize the form. * WARNING: Do NOT modify this code. The content of this method is always regenerated by the Form Editor. */
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE));
layout.setVerticalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 300, Short.MAX_VALUE));
pack();
}// </editor-fold>
/** @param args the command line arguments */
public static void main(String
args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new JFrameFontes().setVisible(true);
}
});
}
// Variables declaration - do not modify
// End of variables declaration
}
19
Exemplo package projaula3pooead;
 Fontes
A classe Font (java.awt.Font) representa as fontes que são utilizadas para apresentar os textos nas Interfaces gráficas. 
Resumo dos construtores:
Font (String nome, int estilo, int tamanho);
 
Cria uma fonte específica (nome), com o estilo e o tamanho em pontos.
20
As fontes precisam ser criadas para serem utilizadas
Fontes também são OBJETOS que precisam ser criados, ESTANCIADOS, para poderem ser manipulados.
 Cursores
A classe Cursor (java.lang.Object) encapsula a representação do bitmap do cursor do mouse.
Para alterar o comportamento dos cursores, basta definir o novo tipo de cursor com:
21
this.setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
Neste caso, estamos definindo o cursor para cursor de movimento. Podemos definir os cursores com eventos como clique do botão, passar com o mouse por cima de algum componente, passar o mouse em uma área pré-definida ou outro evento que queira. 
public class JFrameCursores2 extends javax.swing.JFrame {/** Creates new form JFrameCursores2 */
public JFrameCursores2() {initComponents();}
/** This method is called from within the constructor to initialize the form. * WARNING: Do NOT modify this code. The content of this method is always regenerated by the Form Editor. */
@SuppressWarnings("unchecked") // <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
jButton1 = new javax.swing.JButton();jButton2 = new javax.swing.JButton();jButton3 = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();jButton5 = new javax.swing.JButton();jButton6 = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("Teste de Cursores");
jButton1.setText("Mão");
jButton1.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton1ActionPerformed(evt);}});
jButton2.setText("Aguarda");
jButton2.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton2ActionPerformed(evt);}});
jButton3.setText("Texto");
jButton3.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton3ActionPerformed(evt);}});
jButton4.setText("Cruz");
jButton4.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton4ActionPerformed(evt);}});
jButton5.setText("Movimento");
jButton5.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton5ActionPerformed(evt);}});
jButton6.setText("Cursor Normal");
jButton6.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton6ActionPerformed(evt);}});
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(22, 22, 22)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
.addComponent(jButton1)
.addComponent(jButton5)
.addComponent(jButton4)
.addComponent(jButton3)
.addComponent(jButton2))
.addContainerGap(305, Short.MAX_VALUE))
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addContainerGap(289, Short.MAX_VALUE)
.addComponent(jButton6)
.addContainerGap())
);
layout.setVerticalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
	.addGap(65, 65, 65)
	.addComponent(jButton1)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.	addComponent(jButton2)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
	.addComponent(jButton3)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
	.addComponent(jButton4)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
	.addComponent(jButton5)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED,29, Short.MAX_VALUE)
	.addComponent(jButton6)
.addGap(24, 24, 24))
);
pack();
}// </editor-fold>
private void jButton6ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here:
this.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
}
private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here:
this.setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here:
this.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
}
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here:
this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
}
private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here:
this.setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR));
}
private void jButton5ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here:
this.setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
}
/** @param args the command line arguments */
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {public void run() {new JFrameCursores2().setVisible(true);}});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JButton jButton5;
private javax.swing.JButton jButton6;
// End of variables declaration
22
Exemplo package projaula3pooead;
 Bordas
Por meio do método setBorder de JComponent, o pacote Swing permite a criação de bordas envolvendo os componentes 
23
 Tipos de Bordas - Simple
Define as bordas simples, que podem ser:
em relevo, 
apenas uma linha, encravada, 
sem borda.
24
 Tipos de Bordas - Matte
Você define quantos pixels serão utilizados e qual figura será utilizada.
25
 Tipos de Bordas - Title
Coloca uma borda com um texto 
26
 Tipos de Bordas - Compound
Podemos compor duas bordas com este estilo.
27
 Cores
28
A escala de cor varia de 0 até 255, sendo que em 0 o canhão está desligado e 255 ligado no máximo. Quando temos os três canhões desligados, teremos o preto, que indica ausência de luz, se ligamos todos os canhões no máximo, teremos o branco.
O Sistema RGB pode ser entendido como objetos que emitem luz, como monitores, televisão ou o sol, sobrepondo ou somando os comprimentos de onda.
Podemos definir e manipular as cores em Java através da classe Color. Esta classe encapsula as cores do sistema RGB (Red, Green and Blue). 
A composição dos três canhões de luz (R, G e B) produz todo o espetro de cor visível. É função do programador definir as intensidades de cada canhão para determinar a cor desejada.
Cores pré-definidas:
white, black, blue, cyan, darkGray, gray, lightGray, green, magenta, orange, pink, red, yellow 
 Manipulando Cores
Cores de Fontes
Para definirmos as cores das fontes dos componentes, basta definir a propriedade Foreground com a cor desejada. É possível utilizar cores predefinidas ou definir na hora.
Ex.:
jLabel6.setForeground(Color.blue);
Color vermelhoEscuro = new Color(235,50,50);
jLabel5.setForeground(vermelhoEscuro);
29
Cores de Fundo
Para definirmos as cores de fundo, utilizamos a propriedade Background. O detalhe é que esta propriedade só funciona
para componentes que sejam opacos. Então, é necessário definir a opacidade como verdadeiro.
Ex.:
 jLabel7.setOpaque(true);
 jLabel7.setBackground(Color.green);
A ordenação dos mesmos depende da ordem em que foram adicionados, sendo que são “empilhados” horizontalmente da esquerda para a direita. Evidentemente, só pode-se anexar menus a janelas da classe JApplet, JDialog, JFrame e JInternalFrame, e faz-se isso usando-se o método setJMenuBar(JMenuBar). A classe JMenuItem capacita a criação de itens de menu que, por sua vez, devem ser anexados a um menu. Pode-se usar um item de menu para executar alguma ação ou para gerir o acionamento de um submenu, o qual fornece mais itens que estão relacionados por alguma característica comum.
Menus
30
Os menus talvez sejam os componentes que mais aparecem nas 
ferramentas computacionais. 
Geralmente encontrados no topo da janela da aplicação, de onde 
dão suporte à organização e agrupamento de funções afins em um
mesmo contexto visual, o que facilita muito a localização e 
entendimento por parte do usuário, já que a estrutura de cada 
menu está delineada pelas características dos itens. 
Os menus, que são instanciados a partir da classe JMenu, são anexados a uma barra de menus com o método add(JMenu) de JMenuBar, sendo que instâncias dessa última classe comportam-se como containers para menus. 
A classe JMenuBar fornece os métodos necessários ao gerenciamento da barra onde os menus são anexados.
Menus - Montagem
31
Passo a passo para montagem de um menu em barras em Java:
Instancie um JMenuBar. 
	Ele é o responsável pela estrutura do menu.
2. Adicione tantos JMenu’s quantos forem necessários para as opções.
	Dentro de cada JMenu, coloque o JMenuItem, que é o 	responsável pela opção a ser escolhida.
Listas e Caixa de Opção
32
As listas permitem apresentar um vetor de Strings na tela. 
Podemos usar dois objetos implementados, um na AWT – List e outro no Swing – Jlist. Ambos têm funcionalidades muito semelhantes. Na classe List da AWT, podemos inserir e retirar elementos diretamente, enquanto que na Jlist, teremos que fazer através de um modelo. 
Caixas de Opção
São caixas de seleção onde o usuário escolhe opções. Podem ser exclusivas ou não exclusivas.
Utilizamos o objeto Checkbox. Este objeto recebe três parâmetros, sendo o primeiro uma String com o texto que será apresentado, o segundo com o grupo da seleção e o terceiro se a opção está ou não marcada. O grupo de seleção define se a caixa será Exclusiva ou não Exclusiva.
Não exclusivas
Definimos o parâmetro do grupo como null e o usuário poderá marcar quantas opções quiser.
Exclusivas
Para criar um grupo de opções, temos que criar um objeto de grupo, chamado CheckboxGroup. Criamos um objeto deste tipo e no segundo parâmetro dos objetos deste grupo, utilizaremos o objeto criado.
private void initialize() {
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setPreferredSize(new Dimension(400, 200));
layout = new GridBagLayout(); // setLayout(layout);
getContentPane().setLayout(layout);
String[] itens = {"Um", "Dois", "Tres", "Quatro", "Cinco"};
JList lEsq = new JList(itens); //Cria uma lista de valores String Com Multiplas opções
lEsq.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
GridBagConstraints restricoes = new GridBagConstraints();
restricoes.gridx = 0; restricoes.gridy = 0; restricoes.gridwidth = 1; restricoes.gridheight = 3;
restricoes.fill = GridBagConstraints.VERTICAL;
add(lEsq, restricoes);
Checkbox checkbox1 = new Checkbox("Escolha 1", null, false); Checkbox checkbox2 = new Checkbox("Escolha 2", null, false);
Checkbox checkbox3 = new Checkbox("Escolha 3", null, false); Checkbox checkbox4 = new Checkbox("Escolha 4", null, false);
Insets margens = new Insets(4, 3, 4, 3);
restricoes.gridx = 1; restricoes.gridy = 0; restricoes.gridwidth = 1; restricoes.gridheight = 1;
restricoes.fill = GridBagConstraints.BOTH;
restricoes.ipadx = 2; restricoes.ipady = 2; restricoes.insets = margens;
add(checkbox1, restricoes); restricoes.gridy = 1; add(checkbox2, restricoes); restricoes.gridy = 2; add(checkbox3, restricoes); restricoes.gridy = 3; add(checkbox4, restricoes);
CheckboxGroup grupo = new CheckboxGroup();
Checkbox checkbox10 = new Checkbox("Escolha 1", grupo, false); Checkbox checkbox20 = new Checkbox("Escolha 2", grupo, false); 
Checkbox checkbox30 = new Checkbox("Escolha 3", grupo, false); Checkbox checkbox40 = new Checkbox("Escolha 4", grupo, false);
restricoes.gridx = 2; restricoes.gridy = 0;
add(checkbox10, restricoes); restricoes.gridy = 1; add(checkbox20, restricoes); restricoes.gridy = 2; add(checkbox30, restricoes); restricoes.gridy = 3; add(checkbox40, restricoes); 
pack();
}
/** This method is called from within the constructor to initialize the form. WARNING: Do NOT modify this code. The content of this method is always regenerated by the Form Editor. */
@SuppressWarnings("unchecked") // <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
 jScrollPane1 = new javax.swing.JScrollPane();
 jList1 = new javax.swing.JList();
 setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
 jList1.setModel(new javax.swing.AbstractListModel() {
 String[] strings = { "Item 1", "Item 2", "Item 3", "Item 4", "Item 5" };
 public int getSize() { return strings.length; }
 public Object getElementAt(int i) { return strings[i]; }
 });
 jScrollPane1.setViewportView(jList1);
 javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
 getContentPane().setLayout(layout);
 layout.setHorizontalGroup(
 layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
 .addGroup(layout.createSequentialGroup()
 .addGap(46, 46, 46)
 .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 101, javax.swing.GroupLayout.PREFERRED_SIZE)
 .addContainerGap(253, Short.MAX_VALUE))
 );
 layout.setVerticalGroup(
 layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
 .addGroup(layout.createSequentialGroup()
 .addGap(38, 38, 38)
 .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 107, javax.swing.GroupLayout.PREFERRED_SIZE)
 .addContainerGap(155, Short.MAX_VALUE))
 );
pack();
}// </editor-fold> Apresentamos apenas um trecho do código que contempla a criação da lista e das caixas de seleção.
Listas e Caixa de Opção
33
Aula 04
Tratamento de Eventos 
em Interfaces Gráficas
Tratamentos de Eventos em Java
Quase todos os componentes propagam eventos. Estes eventos devem ser tratados em algum ponto do código da aplicação. Os eventos nunca são tratados no próprio componente. Para ligar o código do tratamento de eventos ao componente existem, no Java, um conjunto de interfaces chamadas listeners. Um listener é uma interface que especifica os métodos que uma aplicação deve ter para ser notificada da ocorrência de um determinado evento. Os componentes que geram eventos permitem que sejam adicionados ou removidos listeners em qualquer altura. 
35
Quem detecta o evento é o SO.
Funcionamento do tratamento de eventos
O componente que produz eventos possui métodos especiais do tipo addXXListener(XXListener) que permite adicionar ou remover listeners. XX representa o nome do evento. O método addXXListener recebe por parâmetro o objeto que implementa a interface XXListener; 
A implementação do método addXXListener no componente apenas adiciona o objeto passado por parâmetro a uma lista interna. Sempre que ocorrer um evento (ex. botão pressionado), o componente percorre a lista e invoca, para cada elemento, o método definido na interface XXListener. 
36
Hierarquia dos Eventos
37
Eventos Prontos
38
AÇÃO DO USUÁRIO
Evento disparado
LISTENER
Clicarem um botão -JButton
ActionEvent
ActionListener
Abrir, minimizar
ou fechar uma janela -JFrame
WindowEvent
WindowListener
Clicarem um componente–Jcomponent
MouseEvent
MouseListener
Alteração de texto em um campo de texto –JTextField
TextEvent
TextListener
Digitaruma tecla
KeyEvent
KeyListener
Clicarem um item de escolha -Checkbox
ItemEvent
ItemListener
No botão, adicionamos um listener (“escutador” de eventos), que é um objeto criado neste momento. Este objeto possui o seu tratamento, que é o actionPerformed para o evento em questão. Este método é chamado toda vez que o ActionListener detecta o evento que o botão foi pressionado. Para manter uma programação mais elegante, criamos um método de tratamento que será chamada dentro do actionPerformed(). Este método pode ser escrito em qualquer parte da sua classe e reaproveitado quantas vezes você quiser. Com isso, tratamos o evento Action. Os outro eventos funcionam analogicamente.
Passo a Passo
Vamos implementar um programa simples para incrementar um valor numérico. Quando apertamos o botão Incrementar, o valor incrementa e quando apertamos o botão Zerar, o valor volta para zero.
Para isso, precisamos de um JFrame, dentro dele teremos um JLabel, um JTextField e dois JButton.
39
Abaixo, o código pronto: 
jButton1.addActionListener(new java.awt.event.ActionListener() { 
public void actionPerformed(java.awt.event.ActionEvent evt) {                
trataEventoBt1ActionPerformed(evt); //método de tratamento            
}        
});
 A Interface ActionListener 
Esta interface disponibiliza o tratamento através do método ActionPerformed.
Este tratamento é feito da seguinte forma:
● Adicionamos o ActionListener ao objeto em questão;
● Criamos o objeto que irá tratar este evento instanciando um objeto ActionListener para implementar o método de tratamento;
● Implementamos o método actionPerformed, que é o método de tratamento.
40
 Interface WindowListener
41
Métodos
Função
windowActivated( WindowEvent e)
Invocada quando a janela recebe o foco
windowClosed( WindowEvent e)
Invocado quando a janela foi fechada
windowClosing( WindowEvent e)
Invocado quando a janela está fechando
windowDeactivated( WindowEvent e)
Invocado quando a janela perde o foco
windowDeiconified( WindowEvent e)
Invocado quando a janela é maximizada
windowIconified( WindowEvent e)
Invocado quando a janela éminimizada
windowOpened( WindowEvent e)
Invocado quando a janela éaberta
public class Tela extends JFrame implements WindowListener {
 private JTextField textField = null;
 public Tela() {
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 textField = new JTextField(20);
 addWindowListener(this);
 add(textField, BorderLayout.NORTH);
 pack();
 setLocationRelativeTo(this);
 }
 @Override
 public void windowOpened(WindowEvent e) { //trata abertura da janela
 JOptionPane.showMessageDialog(rootPane, "windowOpened");
 }
 @Override
 public void windowClosing(WindowEvent e) {//trata confirmação de fechamento da janela
 JOptionPane.showMessageDialog(rootPane, "windowClosing");
 }
 @Override
 public void windowClosed(WindowEvent e) {//trata fechamento da janela
 }
 @Override
 public void windowIconified(WindowEvent e) {//trata iconização da janela (encolhimento)
 JOptionPane.showMessageDialog(rootPane, "windowIconified");
 }
 @Override
 public void windowDeiconified(WindowEvent e) {//trata deiconização da janela (voltar ao tamanho normal)
 JOptionPane.showMessageDialog(rootPane, "windowDeiconified");
 }
 @Override
 public void windowActivated(WindowEvent e) {//trata ativação da janela
 }
 @Override
 public void windowDeactivated(WindowEvent e) {//trata desativação da janela
 }
}
 Interface WindowListener
42
Código para o tratamento destes principais eventos em nosso exemplo anterior. Nesta alteração, foi colocado um campo Jlabel com o nome de jLblMsg onde colocamos o estado da janela.
 Interface MouseListener
43
Métodos
Função: invocada quando...
mouseClicked( MouseEvent e)
Botãoé pressionado e solto sobre o componente
mouseEntered( MouseEvent e)
Mouseentra na região gráfica do componente
mouseExited( MouseEvent e)
Mousesai da região gráfica do componente
mousePressed( MouseEvent e)
Botãodo mouse é apertado
mouseReleased( MouseEvent e)
Botãodo mouse é solto
mouseDragged( MouseEvent e)
Mousese movimenta e o seu botão principal está apertado
mouseDragged( MouseEvent e)
Botãoé pressionadoemovimentado com o componente
mouseMoved( MouseEvent e)
Mousese moveu para a região gráfica do componente sem nenhum dos botões pressionados
Disponibiliza 14 métodos de tratamento para os diferentes comportamentos possíveis para as funções do mouse. Os principais são:
Disponibiliza 2 métodos de tratamento para os diferentes comportamentos possíveis para a janela. 
 public Tela() {
 setTitle("Simple Frame");
 setLayout(new BorderLayout());
 setSize(450, 200);
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 lblMensagem = new JLabel("Mensagem: ");
 lblCoordX = new JLabel("X");
 lblCoordY = new JLabel("Y");
 painelSul = new JPanel();
 addMouseListener(this);
 painelSul.add(lblMensagem);
 painelSul.add(lblCoordX);
 painelSul.add(lblCoordY);
 add(painelSul, BorderLayout.SOUTH);
 setLocationRelativeTo(null);
 }
 public void mouseClicked(MouseEvent e) {
 setMensagem("Mouse foi clicado nas coordenadas: ", e.getX(), e.getY());
 }
 public void mouseEntered(MouseEvent e) {
 setMensagem("Mouse entrou nas coordenadas: ", e.getX(), e.getY());
 }
 public void mouseExited(MouseEvent e) {
 setMensagem("Mouse saiu nas coordenadas: ", e.getX(), e.getY());
 }
 public void mousePressed(MouseEvent e) {
 setMensagem("Mouse esta sendo pressionado nas coordenadas: ", e.getX(), e.getY());
 }
 public void mouseReleased(MouseEvent e) {
 setMensagem("Mouse solto nas coordenadas: ", e.getX(), e.getY());
 }
 private void setMensagem(String msg, int x, int y) {
 lblMensagem.setText(msg);
 lblCoordX.setText("X" + x);
 lblCoordY.setText("Y" + y);
 }
}
 Interface MouseListener
44
Acrescentando o tratamento de evento para o mouse para o componente Botão Zerar no programa, teremos:
Aula 05
Tratamento de Eventos de Manipulação de Textos
Tratamentos de Eventos em Java
46
Quase todos os componentes propagam eventos. Estes eventos devem ser tratados em algum ponto do código da aplicação. Os eventos nunca são tratados no próprio componente. 
Para ligar o código do tratamento de eventos ao componente existem, no Java, um conjunto de interfaces chamadas listeners. Um listener é uma interface que especifica os métodos que uma aplicação deve ter para ser notificada da ocorrência de um determinado evento. Os componentes que geram eventos permitem que sejam adicionados ou removidos listeners em qualquer altura. 
Eventos Prontos
47
Ação do Usuário
Evento disparado
Listener
Clicar em um botão -JButton
ActionEvent
ActionListener
Abrir, minimizar ou fechar uma janela -JFrame
WindowEvent
WindowListener
Clicar em um componente -JComponent
MouseEvent
MouseListener
Alteração de texto em um campo de texto –AWT
TextEvent
TextListener
Digitar uma tecla
KeyEvent
KeyListener
Clicar em um item de escolha –Checkbox
ItemEvent
ItemListener
Interface TextListener
48
Métodos
Função
textValueChanged( TextEvent e)
Invocado quando o texto do componente AWT sofre alguma alteração
Este tratamento é feito da seguinte forma:
Adicionamos o TextListener no objeto texto, que é um TextField;
Criamos o objeto que irá tratar este evento, instanciando um objeto TextListener para implementar o método de tratamento;
Implementamos o método textValueChanged, que é o método de tratamento invocado.
Interface KeyListener
49
Métodos
Função
KeyTyped( KeyEvent e)
Invocado quando uma tecla é apertada e o componente está no foco
KeyPressed( KeyEvent e)
Invocado quando uma tecla é apertada e o componente está no foco
KeyReleased( KeyEvent e)
Invocado quando uma tecla é solta e o componente está no foco
Interface ItemListener
50
Interface FocusListener 
Métodos
Função
itemStateChanged( ItemEvent e)
Invocada quando um componente de seleção muda de estado.
Métodos
Função
focusGained( FocusEvent e)
Invocada quando o componente ganha o foco
focusLost( FocusEvent e)
Invocado quando o componente perde o foco
Tratamento da mudança de estados
51
private void trataMudancaEstado(ItemEvent e) {
  Object[] i = jCheckBox2.getSelectedObjects();
 if(i!=null)
 jLabel2.setText("Caixa de Texto Está selecionada");
 else
 jLabel2.setText("Caixa de Texto não está selecionada");
 }
JComboBox
52
É um componente que combina um botão ou um campo de edição com uma caixa de lista tipo drop-down. 
As principais características são:
Podemos editar ou não seu texto;
Definimos a lista de elementos da lista;
Validando Expressões
53
Java fornece um conjunto de classes para validar expressões regulares, como telefone, CEP, email, etc. São muito úteis para validar entrada de dados, principalmente quando é necessário efetuar a crítica. Estas classes são Pattern e Matcher. 
 
Exemplo:
 private boolean validaEmail(String email{
 //Define o padrão da entrada de dados
 Pattern p = Pattern.compile(".+@.+\\.[a-z]+");
 //Valida a cadeia de caracteres com o padrão definido
 Matcher m = p.matcher(email);
 return (m.matches());
 }
 
Passo a Passo
54
Exemplo de cadastro de pessoa
Fazer um programa para cadastrar elementos da classe pessoa, colocando em uma lista de elementos.
Este pequeno programa deverá criticar se existem elementos digitados, o email precisa estar nos padrões corretos (ex.: pessoa@hotmail.com).
A navegação se dará através dos botões Início e Próximo. Ao clicar na caixa Habilita Navegação, os botões serão habilitados e os botões de cadastro desabilitados. 
Passo a Passo
55
Como só podemos autorizar cadastro com emails com a estrutura correta, o botão inclui só ficará habilitado quando a crítica do texto do email estiver correta. Caso o email não esteja no padrão, o usuário terá que informar um email no formato correto. O usuário ficará preso no campo email até digitar um email válido. Para sair do campo, basta limpar a caixa de texto que será autorizado a sair. Observe na imagem que o botão inclui está desabilitado.
private void trataLimpa(java.awt.event.ActionEvent evt) { limpaCampos();} 
private void trataMudancaEstado(java.awt.event.ItemEvent evt) { 
Object[] obj = jCBHabilita.getSelectedObjects(); 
if(obj!=null){ 
habilitaInclusao(true); 
i=pessoas.iterator(); 
mostraElemento(); } 
else 
habilitaInclusao(false); } 
private void trataTeclaApertada(java.awt.event.KeyEvent evt) { jBtLimpa.setEnabled(true);} 
private void verificaEmail(java.awt.event.FocusEvent evt) { 
String email = jTFEmail.getText(); 
Color c = new Color(0,255,0); 
if(validaEmail(email)){ 
c=Color.BLUE; 
jLblValida.setText("Válido"); 
jBtInclui.setEnabled(true); 
jBtInclui.requestFocus(); 
else{ 
c=Color.RED; 
jLblValida.setText("Email Inválido"); 
if(jTFEmail.getText().equals("")) 
jLblValida.setText(""); 
else jTFEmail.requestFocus(); } 
jLblValida.setForeground(c); } 
private void trataInicio(java.awt.event.ActionEvent evt) { 
i=pessoas.iterator(); 
jBtProximo.setEnabled(true); 
jLblMsg.setText(""); 
mostraElemento(); } 
private void trataProximo(java.awt.event.ActionEvent evt) { mostraElemento(); } 
private boolean validaEmail(String email){//Define o padrão da entrada de dados 
Pattern p = Pattern.compile(".+@.+\\.[a-z]+"); //Valida cadeia de caracteres c/ padrão definido 
Matcher m = p.matcher(email); 
return (m.matches()); } 
private void habilitaInclusao(boolean b) { 
jBtAnterior.setEnabled(b); 
jBtProximo.setEnabled(b); 
jBtInclui.setEnabled(!b); 
jBtLimpa.setEnabled(!b); 
limpaCampos(); } 
private void limpaCampos(){ 
jTFNome.setText(""); 
jTFEmail.setText(""); 
jLblValida.setText(""); 
jBtLimpa.setEnabled(false); 
jBtInclui.setEnabled(false); 
jRBMasc.setSelected(true); } 
private void mostraElemento() { 
Pessoa auxPessoa; 
if(i.hasNext()){ auxPessoa = (Pessoa) i.next(); 
jTFNome.setText(auxPessoa.getNome()); 
jTFEmail.setText(auxPessoa.getEmail()); 
if(auxPessoa.isSexo()) {jRBMasc.setSelected(true); 
else jRBFem.setSelected(true); } 
else { jLblMsg.setText("Não existe mais elemento"); jBtProximo.setEnabled(false); } } 
public static void main(String args[]) {/** * @param args the command line arguments */ 
java.awt.EventQueue.invokeLater(new Runnable() { 
public void run() { new CadastroPessoa().setVisible(true); } }); } 
private javax.swing.ButtonGroup buttonGroup1; // Variables declaration - do not modify 
private javax.swing.JButton jBtAnterior; 
private javax.swing.JButton jBtInclui; 
private javax.swing.JButton jBtLimpa; 
private javax.swing.JButton jBtProximo; 
private javax.swing.JCheckBox jCBHabilita; 
private javax.swing.JLabel jLabel1; 
private javax.swing.JLabel jLabel2; 
private javax.swing.JLabel jLabel3; 
private javax.swing.JLabel jLblMsg; 
private javax.swing.JLabel jLblValida; 
private javax.swing.JRadioButton jRBFem; 
private javax.swing.JRadioButton jRBMasc; 
private javax.swing.JTextField jTFEmail; 
private javax.swing.JTextField jTFNome; // End of variables declaration } 
Passo a Passo
56
Classe Pessoa: package Modelo; /** @author Eduardo */ 
public class Pessoa { 
private String nome; 
private String email; 
private boolean sexo; 
public String getNome() { return nome; } /** * @return the nome */ 
public void setNome(String nome) { this.nome = nome; } /** @param nome to set */ 
 public String getEmail() { return email; } /** @return the email */ 
public void setEmail(String email) { this.email = email; } /** @param email to set */ 
public boolean isSexo() { return sexo; } /** @return the sexo */ 
public void setSexo(boolean sexo) { this.sexo = sexo; } /** * @param sexo the sexo to set */ 
} 
Classe CadastroPessoa 
package projaula5pooead; 
import Modelo.Pessoa; import java.awt.Color; import java.util.ArrayList; 
import java.util.Iterator; import java.util.List; import java.util.regex.Matcher; 
import java.util.regex.Pattern; /** @author Eduardo */ 
public class CadastroPessoa extends javax.swing.JFrame { 
List pessoas; 
Iterator i; 
public CadastroPessoa() {/** Creates new form CadastroPessoa */ 
initComponents(); 
pessoas = new ArrayList(); } 
/** This method is called from within the constructor to initialize the form. */
@SuppressWarnings("unchecked") 
// <editor-fold defaultstate="collapsed" desc="Generated Code"> 
private void initComponents() { 
buttonGroup1 = new javax.swing.ButtonGroup(); 
jLabel1 = new javax.swing.JLabel(); 
jTFNome = new javax.swing.JTextField(); 
jRBMasc = new javax.swing.JRadioButton(); 
jRBFem = new javax.swing.JRadioButton(); 
jLabel2 = new javax.swing.JLabel(); 
jLabel3 = new javax.swing.JLabel(); 
jTFEmail = new javax.swing.JTextField(); 
jLblValida = new javax.swing.JLabel(); 
jBtInclui = new javax.swing.JButton(); 
jBtLimpa = new javax.swing.JButton(); 
jBtAnterior = new javax.swing.JButton(); 
jBtProximo = new javax.swing.JButton(); 
jCBHabilita = new javax.swing.JCheckBox(); 
jLblMsg = new javax.swing.JLabel(); 
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 
setTitle("Exercício Cadastro"); 
jLabel1.setText("Nome:"); 
jTFNome.addKeyListener(new java.awt.event.KeyAdapter() { 
public void keyTyped(java.awt.event.KeyEvent evt) { trataTeclaApertada(evt); } }); 
buttonGroup1.add(jRBMasc); 
jRBMasc.setSelected(true); 
jRBMasc.setText("Masculino"); 
buttonGroup1.add(jRBFem); 
jRBFem.setText("Feminino"); 
jLabel2.setText("Sexo:");
jLabel3.setText("email:"); 
jTFEmail.addFocusListener(new java.awt.event.FocusAdapter() { 
public void focusLost(java.awt.event.FocusEvent evt) { verificaEmail(evt); } }); 
jTFEmail.addKeyListener(new java.awt.event.KeyAdapter() { 
public void keyTyped(java.awt.event.KeyEvent evt) { trataTeclaApertada(evt); } }); 
jBtInclui.setText("Inclui"); 
jBtInclui.setEnabled(false); 
jBtInclui.addActionListener(new java.awt.event.ActionListener() { 
public void actionPerformed(java.awt.event.ActionEvent evt) { trataInclui(evt); } }); 
jBtLimpa.setText("Limpa"); 
jBtLimpa.setEnabled(false); 
jBtLimpa.addActionListener(new java.awt.event.ActionListener() { 
public void actionPerformed(java.awt.event.ActionEvent evt) { trataLimpa(evt); } }); 
jBtAnterior.setText("Início"); 
jBtAnterior.setEnabled(false); 
jBtAnterior.addActionListener(new java.awt.event.ActionListener() { 
public void actionPerformed(java.awt.event.ActionEvent evt) { trataInicio(evt); } }); 
jBtProximo.setText("Próximo"); 
jBtProximo.setEnabled(false); 
jBtProximo.addActionListener(new java.awt.event.ActionListener() { 
public void actionPerformed(java.awt.event.ActionEvent evt) { trataProximo(evt); } }); 
jCBHabilita.setText("Habilita Navegação"); 
jCBHabilita.addItemListener(new java.awt.event.ItemListener() { 
public void itemStateChanged(java.awt.event.ItemEvent evt) { trataMudancaEstado(evt); } }); 
jLblMsg.setFont(new java.awt.Font("Tahoma", 3, 12)); // NOI18N 
jLblMsg.setHorizontalAlignment(javax.swing.SwingConstants.CENTER); 
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); 
getContentPane().setLayout(layout); 
layout.setHorizontalGroup( 
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
.addGroup(layout.createSequentialGroup() 
.addGap(2, 2, 2) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRA ILING) 
.addComponent(jLblMsg, javax.swing.GroupLayout.PREFERRED_SIZE, 254, javax.swing.GroupLayout.PREFERRED_SIZE) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEA DING) 
.addGroup(layout.createSequentialGroup() 
.addGap(2, 2, 2) ;.addComponent(jCBHabilita).addGap(18, 18, 18) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEA DING) 
.addGroup(layout.createSequentialGroup().addComponent(jBtInclui) 
.addGap(18, 18, 18) .addComponent(jBtLimpa)) 
.addGroup(layout.createSequentialGroup().addComponent(jBtAnterior) 
.addGap(49, 49, 49) 
.addComponent(jBtProximo)))) 
.addGroup(layout.createSequentialGroup() 
.addGap(85, 85, 85) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRA ILING) 
.addComponent(jLabel3).addComponent(jLabel1).addComponent(jLabel2)) 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEA DING, false) 
.addComponent(jRBFem).addComponent(jRBMasc) 
.addComponent(jTFNome, javax.swing.GroupLayout.DEFAULT_SIZE, 132, Short.MAX_VALUE).addComponent(jTFEmail)) 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) 
.addComponent(jLblValida, javax.swing.GroupLayout.PREFERRED_SIZE, 86, javax.swing.GroupLayout.PREFERRED_SIZE)))) 
.addGap(50, 50, 50)) ); 
layout.setVerticalGroup( 
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
.addGroup(layout.createSequentialGroup() 
.addGap(57, 57, 57) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BAS ELINE) 
.addComponent(jLabel1) 
.addComponent(jTFNome, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BAS ELINE) 
.addComponent(jRBMasc).addComponent(jLabel2)) 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
.addComponent(jRBFem).addGap(8, 8, 8) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BAS ELINE) 
.addComponent(jLabel3).addComponent(jTFEmail, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE).addComponent(jLblValida, javax.swing.GroupLayout.PREFERRED_SIZE, 20, javax.swing.GroupLayout.PREFERRED_SIZE)).addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 45, Short.MAX_VALUE)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BAS ELINE) 
.addComponent(jBtInclui).addComponent(jBtLimpa)) 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) 
.addComponent(jLblMsg, javax.swing.GroupLayout.PREFERRED_SIZE, 20, javax.swing.GroupLayout.PREFERRED_SIZE) 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BAS ELINE) 
.addComponent(jBtProximo).addComponent(jCBHabilita).addComponent(jBtAnterior)) 
.addGap(14, 14, 14)) ); 
pack(); }// </editor-fold> 
private void trataInclui(java.awt.event.ActionEvent evt) { 
Pessoa p = new Pessoa(); 
p.setNome(jTFNome.getText()); 
p.setEmail(jTFEmail.getText()); 
p.setSexo(jRBMasc.isSelected()); 
pessoas.add(p); 
limpaCampos(); 
jTFNome.requestFocus(); 
i=pessoas.iterator(); } 
Aula 06
Introdução ao JDBC
JDBC
Java Database Connectivity define um conjunto de classes e interfaces para escrever programas ou sistemas em Java que utilizem Banco de Dados. Estas classes e interfaces efetuam as conexões entre a aplicação e o Sistema Gerenciador de Banco de Dados (SGBD).
Ao utilizar o JDBC, podemos enviar comandos SQL ou PL/SQL para quase todos os bancos de dados relacionais.
58
Principais Características
Disponibiliza ao programador de aplicações Java abrir conexões em um SGBD, consultando ou modificando algum dado de um determinado BD, utilizando comandos SQL.
Implementa o isolamento entre a aplicação e os dados, baseado na abordagem da Microsoft para a sua API ODBC.
 
Características: 
Portabilidade 
API independente do Banco de Dados utilizado 
Permite o desenvolvimento de aplicações independente do banco de dados escolhido 
Implementa a Estrutura em Camadas 
59
Estrutura de Acesso ao Banco de Dados através do JDBC
Fornece um conjunto de API’s de acesso para executar comandos SQL 
É implementado no pacote padrão java.sql, que é fornecido no SDK 
Funciona para qualquer tipo de Banco de Dados relacional que seu fabricante disponibilizou o Driver específico
Interface foi baseada no X/OPEN SQL / CLI 
É independente de API ou da Linguagem proprietária dos fabricantes de SGBD 
60
Arquitetura JDBC
61
Aplicação Java
Gerenciador de Drivers JDBC
Ponte JDBC - ODBC 
Driver ODBC
SGBD
SGBD
Driver JDBC
A Responsabilidade do JDBC
Estabelecer conexão com o SGBD
Enviar comandos SQL
Receber os resultados
Processar os resultados
62
Carregar os drivers JDBC 
Obter uma conexão
Criar os comandos SQL
Enviar comandos SQL
Receber os resultados
Processar os resultados
A Classe Driver
Para efetuar conexão à um SGBD, é necessário carregar o driver compatível. Estas classes não estão incluídas e precisam ser obtidas com o fabricante do banco de dados.
63
Registrando um Driver
É utilizado o método estático:
Class.forName(<nome_da_classe_driver>);
O nome da classe driver consta na documentação do mesmo.
SGBD
DRIVER
JDBC-ODBC:
sun.jdbc.odbc.JdbcOdbcDriver
mySQL:
com.mysql.jdbc.Driver
PostGresql:
org.postgresql.Driver
Oracle:
oracle.jdbc.driver.OracleDriver
SqlServer:
com.jnetdirect.jsql.JSQLDriver
DB2:
com.ibm.db2.jdbc.app.DB2Driver
É possível registrar vários drivers em uma mesma aplicação. O Driver Manager gerencia cada um deles.
java.sql.DriverManager 
Provê serviços básicos para gerenciar diversos drivers JDBC 
java.sql.Connection 
Representa uma conexão estabelecida com o BD. 
java.sql.Statement 
Representa sentenças onde são inseridos os comandos SQL 
Permite realizar
todo o tratamento das consultas (select) e dos comandos de atualizações (insert, delete, update)
Interface JDBC
O JDBC pode ser visto como um conjunto de interfaces cuja implementação deve ser fornecida por fabricantes de SGBD. 
Cada fabricante deve fornecer implementações de: 
java.sql.Connection 
java.sql.Statement 
java.sql.PreparedStatement 
java.sql.CallableStatement 
java.sql.ResultSet 
java.sql.Driver 
O objetivo é que fique transparente para o programador qual a implementação JDBC está sendo utilizada.
64
Interface JDBC
java.sql.ResultSet 
Representa o cj de registros resultantes de uma consulta. 
Permite manipular os resultados 
Permite realizar coerção (cast) entre tipos Java e SQL 
Exemplo: 
tipo no banco DateTime, tipo de retorno String 
Colunas de um objeto ResultSet podem ser referenciadas por um número posicional ou pelo nome da coluna do resultado. 
ResultSet rs.getString("Endereco") ou 
ResultSet rs.getString(3)
 
65
A Instalação JDBC
66
O pacote JDBC vêm incluso com as distribuições Java. As suas classes estão no pacote java.sql e javaxsql.
Conectando em um Banco
67
Abrindo uma Conexão
Ponte ODBC-JDBC:
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 
Connection conn = DriverManager.getConnection("jdbc:odbc:db_teste",“usuario","senha"); 
No MySql:
Class.forName("org.gjt.mm.mysql.Driver"); 
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/db_teste“,usuario,senha); 
68
O código acima precisa estar circundado por um try and catch, 
ou ter um throws no método. 
No PostgreSQL
Class.forName("org.postgresql.Driver"); 
Connection conn = DriverManager.getConnection( "jdbc:postgresql:db_teste“,usuario,senha); 
No Oracle
Class.forName("oracle.jdbc.driver.OracleDriver"); 
Connection conn = DriverManager.getConnection( "jdbc:oracle:thin:@127.0.0.1:1521:db_teste", usuario,senha);
import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;
import java.sql.SQLException;import java.sql.Statement;import javax.swing.JButton;import javax.swing.JFrame; import javax.swing.JLabel;import javax.swing.JOptionPane;
public class Tela extends JFrame implements ActionListener {
 private JButton btnConectar = null; private JLabel lblTitulo = null; private JLabel lblMensagemConexao = null; private JLabel lblMensagemSQL = null;
 public Tela() {
 setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); setSize(500, 300); setLayout(null);
 lblTitulo = new JLabel(); lblTitulo.setText("Conectando no Banco"); lblTitulo.setBounds(80, 50, 140, 28); lblMensagemConexao = new JLabel("");
 lblMensagemConexao.setFont(new java.awt.Font("Tahoma", 1, 10)); 
 lblMensagemConexao.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
 lblMensagemConexao.setBounds(20, 150, 450, 28); 
 lblMensagemSQL = new JLabel("xxxxx"); lblMensagemSQL.setFont(new java.awt.Font("Tahoma", 1, 10)); 
 lblMensagemSQL.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
 lblMensagemSQL.setBounds(20, 200, 450, 28); 
 btnConectar = new JButton(); btnConectar.setText("Conectar"); btnConectar.setBounds(280, 50, 140, 28); btnConectar.addActionListener(this);
 add(lblTitulo); add(btnConectar); add(lblMensagemConexao); add(lblMensagemSQL);
 }
 private void conectaBanco() {
 try {
 setMensagem("Vou abrir conexao");
 Class.forName("org.apache.derby.jdbc.ClientDriver");
 Connection con = DriverManager.getConnection("jdbc:derby://localhost:1527/Aula6 ", "aluno", "123");
 lblMensagemConexao.setText("Conexão OK");
 Statement st = con.createStatement();
 String sql = "SELECT * FROM PESSOA";
 ResultSet rs = st.executeQuery(sql);
 lblMensagemSQL.setText("SQL OK");
 rs.close(); st.close(); con.close();
 } 
 catch (ClassNotFoundException e) { lblMensagemConexao.setText(e.getMessage()); } 
 catch (SQLException e) { lblMensagemSQL.setText(e.getMessage()); }
 catch (Exception e) { JOptionPane.showMessageDialog(this, e.getMessage());}
 }
 private void setMensagem(String string) { }
 public void actionPerformed(ActionEvent e) {
 conectaBanco();
 }
}
Passo a passo
69
Não esqueça de instalar o JDBC na pasta Bibliotecas
Aula 07
Acessando os dados através do JDBC 
Manipulando os dados através do JDBC
O JDBC utiliza o SQL para manipular dos dados armazenados no SGBD. 
Cada JDBC fornecido pelo fabricante deverá implementar os mecanismos de execução e de conversão de dados para que seja possível acessar os dados. 
Através de uma conexão estabelecida com o banco de dados, utilizamos a Interface Statement para enviar os comandos SQL ao Banco. 
71
As classes de Manipulação
 O JDBC disponibiliza 
 3 tipos de tratamento para comandos SQL:
Statement
Envia o texto SQL para o SGBD.
Possui duas subinterfaces:
PreparedStatement
Monta o SQL com parâmetros para depois enviar para o SGBD
CallableStatement
Similar ao Prepared Statement, mas permite executar procedimentos SQL
72
Interface Statement
 Objeto usado para executar um comando SQL estático e retornar o resultado produzido. Suas características são:
É criado a partir do método createStatement() da classe Connection.
Só se pode criar um Statement após ter estabelecido uma conexão com o objeto Connection
Pode enviar quantos SQL’s quantos forem necessários através do mesmo Statement.
A partir de uma conexão, pode-se criar quantos objetos Statements forem necessários.
Padrão: cada Statement pode gerar apenas um objeto ResultSet por vez. Não há possibilidade manter mais de um ResultSet’s aberto para o mesmo Statement. 
 Para se trabalhar com mais de um ResultSet simultaneamente, é
 preciso ter mais de um objeto Statement.
73
Existem duas possibilidades para se executar o SQL através do objeto Statement: 
executeUpdate – Efetua modificações na base de dados. Deve ser usado principalmente com os comandos INSERT, UPDATE, DELETE ou outros que alterem a base de dados e não retornem dados. 
executeQuery – Efetua consultas na base de dados. Seu retorno gera um ResultSet.
Os Principais métodos
74
Método
Descrição
ResultSetexecuteQuery(String SQL)
Executa o comando SQL, que retorna um objeto ResultSet
intexecuteUpdate(String SQL)
Executa ocomandoSQL, que deverá ser um INSERT, UPDATE ou DELETE ouumcomando SQL que nada retorna, como SQL do tipo DDL
Boolean execute(String SQL)
Executa o comando SQL, que pode retornar vários resultados
ConnectiongetConnection()
Devolve o objeto Connection que produziu este objeto Statement
ResultSetgetResultSet()
Retorna o objeto ResultSet corrente
intgetMaxRows()
Retorna onº máximode linhas produzido dentro deste ResultSet para este Statement
Ex: 
Connection con = DriverManager.getConnection("jdbc:postgresql:clientes");
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(“SELECT * from CLIENTES”);
st.executeUpdate(“DELETE FROM CLIENTES”);
st.close();
con.close(); 
O objeto Statement criado pode ser reusado várias vezes para executar diferentes comandos SQL. Isto é até recomendado. Porém, o Statement só pode ser liberado com o método close() ao final das execuções de todos os comandos SQL.
Interface ResultSet
Uma tabela de dados que representa o resultado de uma consulta em uma base de dados. Geralmente gerada através de uma consulta enviada pelo objeto Statement.
O objeto ResultSet mantém um cursor apontando para a linha corrente de dados. Inicialmente, este cursor aponta para a linha anterior a primeira. 
O método next movimenta o cursor sempre para a próxima linha. Retornando false quando não existir tal informação. Este método é comumente usado em um laço while para varrer todo
o conjunto de dados.
75
Tipo (java.sql.Types)
Método para recuperar dados
Tipo Java
TINYINT / SMALLINT
getByte() / getShort()
byte / short
INTEGER / BIGINT
getInt() / getLong()
int / long
REAL / FLOAT / DOUBLE
getFloat() / getDouble() / getDouble()
float / float / double
DECIMAL, NUMERIC
getBigDecimal()
java.math.BigDecimal
CHAR, VARCHAR,LONGVARCHAR
getString()
String(java.lang.String)
LONGVARCHAR
getAsciiStream()
String
LONGVARCHAR
getUnicodeStream()
java.io.InputStream
LONGCHAR
InputStream getAsciiStream()
String (java.lang.String)
BINARY, VARBINARY
getBytes()
byte[]
DATE
getDate()
java.sql.Date
TIME / TIMESTAMP
getTime() / getTimestamp()
java.sql.Time / java.sql.Timestamp
LONGVARBINARY
getBinaryStream()
java.io.InputStream
BIT
getBoolean()
boolean
Todos os tipos
getObject()
 
Interface ResultSet
76
Interface PreparedStatement
É um objeto que representa um comando SQL pré-compilado. Utilizado para executar um comando repetidas vezes. Tais comandos podem conter parâmetros a serem definidos em tempo de execução.
O PreperadStatement é um subtipo do Statement. É gerado com o método prepareStatement() da Connection.
Em um comando SQL de um objeto PreparedStatement pode haver parâmetros. Estes parâmetros são identificados como pontos de interrogação. Estes pontos deverão ser definidos com os comandos setXXX, informando nos parâmetros, o número do ponto e seu valor.
77
EX:
Sql=“UPDATE EMPREGADOS SET SALARIO = ? WHERE ID = ?”;
PreparedStatement pst = con.prepareStatement(sql);
pst.setBigDecimal(1, 153850.00);
pst.setInt(2, 110590);pst.executeUpdate(); 
Como a Interface PreparedStatement herda de Statement, todos os métodos explicados anteriormente valem aqui também.
Interface CallableStatement
Quando precisamos executar stored procedures (Comandos SQL armazenados em forma de procedimentos), utilizamos a Interface CallableStatement. Ela é um subtipo de PreparedStatement que, além de permitir a passagem de parâmetros, também permite o retorno de valores.
É válido lembrar que esta interface só estará disponível nos bancos que disponibilizam este tipo de procedimento.
Como é permitido passar parâmetros tanto para entrada IN como para saída OUT, esta Interface funciona exatamente igual para os parâmetros IN e numera os parâmetros de saída que deverão ser definidos.
78
 Diferentemente das outras interfaces Statement, a CallableStatement pode 
 devolver mais de um resultSet. 
 Esta interface exige um conhecimento mais aprofundado de banco de dados
 e não será tratada dentro do escopo deste curso.
Para complementar, “Aprenda Fazendo”. Clique.
Para esta aula sugiro as seguintes tarefas:
Leitura do Capítulo 28 (28.9 até 28.14) do livro Java como programar, 8ª Edição, de H. Deitel e P. Deitel, Editora Pearson Education, 2010.
Resolução dos exercícios de 28.5 até 28.9 do capítulo 28 do livro Java Como Programar – 8ª Edição. 
Passo a Passo
Fornece um conjunto de API’s de acesso Com o exercício feito na aula 6, vamos fazer um CRUD completo para a tabela Cliente no banco de dados dbCliente.
A Interface a ser 
 desenvolvida deverá seguir 
 o padrão apresentado abaixo:
CRUD – Acrônimo para Create,
 Read, Update e Delete, que
 são as 4 operações básicas 
 utilizadas em um banco de dados 
 relacional. 
79
Aula 08
Threads e Concorrência
Para esta aula sugiro as seguintes tarefas:
Leitura do Capítulo 23 (23.1 até 23.5) do livro Java como programar, 
6ª Edição, de H. Deitel e P. Deitel, Editora Pearson Education, 2005. 
Resolução dos exercícios de 23.5 até 23.9 do capítulo 23 do mesmo livro.
Processos
O processamento de hoje ainda é feito na maioria das vezes por um único processador da máquina. Só que na maioria dos sistemas, vários processos são executados no mesmo intervalo de tempo, dando a impressão de simultaneidade de execução. Esta capacidade é chamada de multiprocessamento, e muito estudada em sistemas operacionais. 
Um processo é basicamente um programa em execução. Eles são independentes dos outros.
81
Processos - mais de um núcleo
Processos - um núcleo
Quando temos mais de um núcleo, o SO pode balancear a carga dos núcleos dividindo os processos.
Na tentativa de reduzir o tempo gasto para troca de contexto de processos nas aplicações concorrentes e economizar recursos do sistema, foi criado o conceito de Thread.
Processos - mais de um núcleo
82
Para entender melhor, se atribuirmos um thread para uma longa sequência de cálculos, outro para uma entrada de texto e um terceiro para uma verificação ortográfica, o programa multithreaded pode fazer os cálculos requisitados enquanto o usuário digita o texto. Além disso, enquanto o texto é digitado, a ortografia do mesmo é verificada. Isto é multithreading e a impressão que se tem é de que tudo ocorre ao mesmo tempo.
Threads
São subprocessos no Sistema Operacional. O thread pode ser visto como uma parte de um processo, que permite compartilhar a sua área de dados com o programa ou outros threads. Seu início de execução é muito mais rápido do que um processo, e o acesso a sua área de dados funciona como um único programa.
83
Também podem ser definidos como fluxos sequenciais de execução de um programa. Logo, um programa pode dividir em partes sequenciais não concorrentes de sua execução em threads distintas, implementando paralelismo na sua execução. Com isso, um processo pode ter múltiplos threads que parecem executar ao mesmo tempo. As linguagens Java e Ada possuem funcionalidades MULTITHREADING na própria estrutura da linguagem.
Cada processo tem, no mínimo, um thread. 
 As Vantagens do uso Threads
- Torna-se menos custoso em termos de processamento criar um thread que um processo;
- São necessárias poucas variáveis para criação de um thread; 
- Podem compartilhar o mesmo espaço de processo; 
- Podem compartilhar os mesmos recursos de seus processos.
Os estados de uma Thread
A execução de um thread pode passar por quatro estados: novo, executável, bloqueado e encerrado. 
84
O thread está no estado de novo – New Thread, quando é criado, ou seja, quando é alocada área de memória para ele através do operador new. Ao ser criado, o thread passa a ser registrado dentro da JVM, para que o mesmo possa ser executado. 
O thread está no estado de executável - Runnable, quando for ativado. O processo de ativação é originado pelo método start(). É importante frisar que um thread executável não está necessariamente sendo executado, pois quem determina o tempo de sua execução é a JVM ou o Sistema Operacional. 
Estado de bloqueado – Not Runnable, quando for desativado. Para desativar, deve ocorrer uma das quatro operações:
1º Foi chamado o método sleep(long tempo) da thread;  
2º Foi chamado o método suspend() da thread (método em desuso)  
3º O trhead chamou o método wait();
4º O thread chamou uma operação de Entrada / Saída (I/O) que bloqueia a CPU;  
Para o thread sair do estado de bloqueado – Not Runnable - e voltar para o estado de executável, uma das seguintes operações deve ocorrer, em oposição às ações acima:   
1º Retornar após o tempo especificado, caso o thread estiver adormecido;  
2º Retornar através do método resume(), caso o thread tiver sido suspenso (método em desuso);  
3º Retornar com o método notify() (ou notifyAll()), caso o thread estiver em espera;  
4º Retornar após a conclusão da operação de I/O. 
O thread está no estado de encerrado - Dead, quando encerrar a sua execução. Isto pode acorrer pelo término do método run(), ou pela chamada explícita do método stop(). 
Thread em Java
Cada Thread está associado a uma instância da classe Thread. 
A máquina virtual Java permite que uma aplicação tenha diversos fluxos sequencias de execução rodando concorrentemente . Para se utilizar esta funcionalidade, a API Java disponibiliza a classe Thread e a interface Runnable.
A Interface Runnable: define um único método – run – que deve conter o código de execução da thread.
A Classe Thread: Implementa o Runnable, logo seu método run nada faz. Uma aplicação pode herdar de thread fornecendo a sua própria implementação do método run.
85
Observe que em ambos os exemplos o método Thread.start é chamado para iniciar a thread.
Qual devo Usar
Segundo a Sun, “a linguagem de programação Java não permite herança múltipla”, no entanto há uma alternativa para o uso de mais de uma superclasse, que é a utilização de interfaces. Com base neste conceito, desde a API 6.2 existe a interface Runnable, que possui um funcionamento bem semelhante ao da classe Thread, ao exigir a implementação do método run().
É mais comum utilizar a Interface Runnable, pois este objeto pode herdar comportamentos de outra classe, que não a Thread. O segundo exemplo pode ser usado em aplicações mais simples, pois é limitada pelo fato de que a classe precisa ser herdada de Thread. 
86
Leia o texto “Métodos das Threads”
Principais Métodos da classe Thread
run()
 É neste método que definimos o que o thread vai executar. Por esta razão, deve estar presente em todas as threads.
start()
 Destinado a ativar a thread, e a thread passa a um estado RUNNANLE , ou seja, registra a thread no thread scheduler.
getPriority()/setPriority()
Retorna ou configura a prioridade de uma thread.
87
Principais Métodos da classe Thread
yield()
Cede o processamento para outra thread. Isto ocorre porque este método faz com que a thread corrente pause, possibilitando que outra thread seja despachada.
sleep()
Faz com que a thread fique em estado de espera uma quantidade mínima de tempo, em milissegundos, possibilitando a CPU executar outras threads.
join()
Condiciona a continuação da execução de uma thread ao término de uma outra.
88
Principais Métodos da classe Thread
wait()
Utilizado para sincronizar acesso a um objeto. Coloca a thread corrente em estado de espera até que outra thread chame os métodos notify ou notifyAll, liberando o objeto.
notify()
Acorda a thread que, voluntariamente, estava esperando a liberação de um objeto.
notifyAll()
Acorda todas as threads que estavam esperando a liberação de um objeto.
89
Para definirmos a prioridade da thread, usamos os métodos:
void setPriority(int prioridade) – Define a prioridade de execução de uma thread. Os valores de prioridade estão entre 1 e 10; 
int getPriority() – verifica a prioridade de execução
 de um thread; 
public class Tarefa1  extends Thread {
@Override
public void run() {
        for(int i=0; i<1000; i++){ 
        int p = this.getPriority();
}
Prioridades nas Threads
A prioridade de um thread corresponde à preferência que ele terá perante as demais durante sua execução. Quanto maior a prioridade de um thread, maior será sua preferência no uso da CPU. Threads de mesma prioridade costumam partilhar o tempo de CPU igualmente. 
A prioridade é extremamente ligada ao algoritmo de escalonamento de CPU que o sistema operacional utiliza. Para definir a prioridade de um thread, são usados números de 1 a 10. O número 5 define prioridade como normal. 
90
Para garantir que um thread com prioridade 10 tenha prioridade alta tanto em um S.O. cuja prioridade máxima seja 10 quanto em outro que seja 100, a JVM traduz a prioridade especificada no código para a do S.O., logo uma prioridade 10 em Java pode ser traduzida para uma prioridade 100, por exemplo.
A solução para este problema é utilizar um mecanismo de sincronização que permita ao thread acessar a base de dados compartilhada apenas quando os dados estiverem estáveis (outros threads não estejam manipulando estes dados). Java adotou a palavra chave synchronized para informar que um determinado bloco deve estar síncrono com os demais threads. 
Sincronização
Durante a execução de threads, há casos em que eles trabalham independentemente uma do outro, sem necessidade de qualquer comunicação entre eles. Por outro lado, há casos em que eles comunicam-se de alguma forma ou utilizam dados em comum. Este comportamento gera a necessidade de denominar os threads em assíncronos e síncronos, dependendo da forma de trabalho desempenhada. Threads que trabalham independentes no tempo, são assíncronos enquanto aqueles que trocam informações em tempo de execução são síncronos.
Os threads se diferem dos processos por poderem ter áreas de dados comuns. Isto pode facilitar em muito a implementação de programas. Porém, pode causar alguns erros quando a mesma base de dados é alterada por mais de um thread, em momentos inesperados. 
91
Sincronização
O uso de memória compartilhada entre os threads obriga o programador a sincronizar as ações de seus threads.
Java provê monitores ou locks. Imagine um lock como uma permissão para que apenas um thread possa utilizar um recurso por vez.
Cada objeto em Java possui um lock e ele deve ser obtido através do comando synchronized.
Os métodos wait(), notify() e notifyAll() também são muito importantes na sincronização, sendo responsáveis por provocar, respectivamente: uma espera, a liberação de uma ou mais threads em espera
92
O sincronismo gera um bloco atômico (indivisível). Assim, este bloco passa a ser protegido, evitando que o thread atual seja interrompido por outro thread, independente da prioridade. 
public class Principal {
 public static void main(String args[]){
 ExemploThread thread1, thread2, thread3, thread4;
 thread1 = new ExemploThread("Thread 1");
 thread2 = new ExemploThread("Thread 2");
 thread3 = new ExemploThread("Thread 3");
 thread4 = new ExemploThread("Thread 4");
 System.err.println("\n Iniciando as threads");
 thread1.start();
 thread2.start();
 thread3.start();
 thread4.start();
 System.err.println("\n Threads iniciadas\n");
 }
}
Vamos criar um programa para criar threads e colocá-los para dormir com um tempo aleatório entre 0 e 5 segundos. 
Vamos monitorar seu funcionamento, quer dizer, ao criarmos os threads, informaremos quanto tempo cada uma irá dormir. Ao acordar, cada uma deve sinalizar que acordou e terminar.
Observe que os quatro threads foram criados na ordem, com tempos de sono diferentes. A saída da execução de cada thread já tira da ordem normal, visto que foi dada pelo escalonador.
Mas, como o tempo dormindo é bem diferente, o thread 3, que dormiu 493 milissegundos acorda primeiro, seguindo do 1, 2 e finalmente 4. Observe também que o tempo total de execução do programa foi de 3 segundos.
93
public class ExemploThread extends Thread {
 private int tempoDormir;
 public ExemploThread(String nome) {
 super(nome);
 //adormece durante 0 a 5 segundos
 tempoDormir = (int) (Math.random() * 5000);
 System.err.println("Nome: " + getName() + "; dormindo: " + tempoDormir);
 }
 public void run() {
 try {
 System.err.println(getName() + " Indo dormir");
 Thread.sleep(tempoDormir); //entre no estado Not Runnable
 } catch (InterruptedException interruptedException) {
 System.err.println(interruptedException.toString());
 }
 System.err.println(getName() + " Terminando de dormir");
 }
}
Passo a Passo
Aula 09
Threads e Concorrência em Java
Para esta aula sugiro as seguintes tarefas:
Leitura do Capítulo 23 (23.6 até 23.7) do livro Java como programar,
6ª Edição, de H. Deitel e P. Deitel, Editora Pearson Education, 2005.
Resolução dos exercícios de 23.5 até 23.9 do capítulo 23 do mesmo livro.
Os métodos wait(), notify() e notifyAll() também são muito importantes na sincronização, sendo responsáveis por provocar, respectivamente: uma espera, a liberação de uma ou mais threads em espera
Sincronização
Durante a execução de threads, há casos em que elas trabalham independentemente uma da outra, sem necessidade de qualquer comunicação entre elas. Por outro lado, há casos em que elas comunicam-se de alguma forma ou utilizam dados em comum. Este