Linguagem Java Entrada e Saída de Dados

Especialização Avançada em Sistemas

Distribuídos - EASD

Módulo VII – Linguagem Java

Entrada e Saída de Dados
Marcela Santana e
Sérgio Gorender

Universidade Federal da Bahia

 Linguagem Java Entrada e Saída de Dados

Console Padrão
• Saída de Dados
Para que possamos mostrar informações no console padrão (vídeo), é
necessário usar o objeto System.out em conjunto com o método
println().
System.out.println(“Meu primeiro exemplo executável”);

• Entrada de Dados
O Java só permite a entrada de Strings, desta forma, para que
possamos informar valores numéricos é necessário fazer uma conversão
de String para o tipo numérico desejado. A leitura de dados é feita
utilizando um objeto da classe InputStream (fluxo de entrada), ou suas
classes derivadas.
 Linguagem Java Entrada e Saída de Dados

Console Padrão
• Entrada de Dados
Para que seja obtido um valor do teclado em um programa Java é necessário
declarar um local de armazenamento. Para que isso seja realizado é
necessário que o programa crie um objeto do tipo BufferedReader, como
pode ser visto (b é um objeto da classe BufferedReader que irá armazenar um
InputStream – fluxo de entrada – lido do console padrão – teclado – como um String):
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));.

A classe BufferedReader tem um método que retorna o valor digitado no

teclado como uma String (métodos read são bloqueantes).
b.readLine();

Quando este valor tem de ser convertido para um tipo primitivo usa-se os
métodos de conversão, como exemplificado a seguir.
int idade = Integer.valueOf( b.readLine() ).intValue();
 Linguagem Java Entrada e Saída de Dados

Console Padrão

Todo o programa que se utiliza de entrada e saída de dados do console

padrão deve utilizar o package java.io.*. Ele contêm as classes
responsáveis pelas entradas e saídas de dados e tratamento de
exceções.
Toda a entrada de dados fica sujeita a erros.
A subclasse que trata os erros de entrada e saída é a IOException,
dessa forma é indispensável o seu uso.
import java.io.* // para importar o pacote de entrada e saída
throws java.io.IOException // para tratamento de exceções
 Linguagem Java Entrada e Saída de Dados

Console Padrão

• Exemplo de uma classe com entrada de dados pela console padrão

import java.io.*;
public class Palavra {
private String valor;
public void setValor()throws java.io.IOException {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Digite a palavra ");
valor = bf.readLine();
}
public int retornaNumeroLetras(){
return valor.length();
}
public static void main(String[] args) throws java.io.IOException{
Palavra p = new Palavra();
p.setValor();
System.out.println("Esta palavra tem "+p.retornaNumeroLetras()+" letras.");
}
}
 Linguagem Java Entrada e Saída de Dados

Interface Gráfica - Swing

• O Swing, faz parte da biblioteca Java Foundation Classes (JFC).

• AWT (Abstract Windows Toolkit) é o antigo conjunto de ferramentas
para interface gráfica em java. O JFC oferece uma interface muito mais
rica.
• É precisa importar java.awt e javax.swing para usar JFC.
• O Swing permite a criação de um programa Java com uma interface que
utiliza o estilo do sistema operacional nativo.
• Todos os componentes do Swing são subclasses da classe JComponent.
 Linguagem Java Entrada e Saída de Dados

O primeiro passo de um aplicativo Swing é gerar uma classe que seja uma
subclasse de JFrame (um Frame é uma janela de alto nível).

import java.awt.event.*;
import javax.swing.*;
public class Framework extends JFrame{
public Framework( ){
}
public static void main (String args[]){ Inclui os componentes aqui
JFrame frame = new Framework();
WindowListener l = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
}; Tratamento de eventos
frame.addWindowListener(l);
frame.pack(); Redimensionar para conter
frame.setVisible(true); todos componentes e tornar
} visível o quadro
}
 Linguagem Java Entrada e Saída de Dados

• Um objeto JFrame é subdividido em vários painéis diferentes.

• O painel principal é o painel de conteúdo, que representa a área total
de um quadro, ao qual podem ser adicionados componentes. Neste caso
não existe preocupação com o layout dos componentes.
• Para adicionar um componente em um painel de conteúdo é necessário:
1) Criar um objeto JPanel
2) Adicionar todos os componentes ao JPanel, usando o método
add(componente);
3) Transformar esse JPanel no painel de conteúdo, usando o
método setContentPane(panel).
 Linguagem Java Entrada e Saída de Dados

Componentes

JLabel

JTextField

JTextArea

JCheckBox

JButton

JComboBox

JOptionPane
 Linguagem Java Entrada e Saída de Dados

• Um botão é implementado no Swing através de um objeto JButton. Um

botão pode receber um texto ou imagens.

import java.awt.event.*;
import javax.swing.*;
public class Framework extends JFrame{
Objeto JButton é criado
public Framework( ){ com um nome
String nome ="Botao de exemplo";
JButton meuBotao1 = new JButton(nome); Objeto Jpanel é criado
JPanel painel = new JPanel(); e o botão é adicionado
painel.add(meuBotao1); a ele
setContentPane(painel); setContentPane é utilizado
} para transformar o painel
em painel de conteúdo do
...
quadro (Frame)
 Linguagem Java Entrada e Saída de Dados

• Os rótulos são implementados no Swing como a classe JLabel. São

utilizados para identificar o objetivo de outros componentes em uma
interface.
• Os campos de texto são implementados em Swing com a classe
JTextField, que pode receber como argumento o tamanho do campo de
texto e um valor default.

public Framework( ){
JLabel identificador = new JLabel("Digite seu nome");
JTextField texto = new JTextField(20);
JPanel painel = new JPanel(); Criação de um label e
de um objeto de campo de
painel.add(identificador);
texto (JTextField).
painel.add(texto); Adiciona o label e depois o
setContentPane(painel); objeto TextField no painel
} que é um JPanel
...
 Linguagem Java Entrada e Saída de Dados

• As áreas de texto são implementadas no Swing com a classe

JTextArea. Pode receber como argumento o número de linhas
e colunas e também um texto default.

public Framework( ){
JPanel painel = new JPanel();
JLabel idArea = new JLabel("Escreva sua reclamação");
JTextArea area = new JTextArea(10,10);
painel.add(idArea);
painel.add(area); Criação de um objeto
setContentPane(painel); JTextArea de 10 linhas e
} 10 colunas. Foi necessário
criar também um rótulo
(label) para identificar o
objetivo do objeto
 Linguagem Java Entrada e Saída de Dados

• A classe JCheckBox é a implementação das caixas de seleção no Swing.

public Framework( ){
JCheckBox opcao1 = new JCheckBox("Negrito");
JCheckBox opcao2 = new JCheckBox("Itálico", true);
JPanel painel = new JPanel();
painel.add(opcao1);
painel.add(opcao2);
setContentPane(painel);
} Criação de dois objetos
JCheckBox sendo que o
objeto opcao2 será por
default selecionado.
 Linguagem Java Entrada e Saída de Dados

• Os grupos de caixa de seleção são implementados no Swing com a

classe ButtonGroup. Neste caso apenas um componente pode ser
selecionado.

public Framework( ){
ButtonGroup opcao = new ButtonGroup();
JCheckBox homem = new JCheckBox("Masculino", true);
JCheckBox mulher = new JCheckBox("Feminino", false);
opcao.add(homem);
opcao.add(mulher); Cria um objeto ButtonGroup
JLabel sexo = new JLabel("Sexo :"); para que este controle que
JPanel painel = new JPanel(); apenas um dos itens seja
painel.add(sexo); selecionado. Em seguida
painel.add(homem); adiciona os objetos
JCheckBox ao objeto
painel.add(mulher);
ButtonGroup.
setContentPane(painel);
}
 Linguagem Java Entrada e Saída de Dados

• As listas de escolha representam uma das possíveis implementações

da classe JComboBox.

public Framework ( ){
JComboBox lista = new JComboBox();
lista.addItem("Casado");
lista.addItem("Solteiro");
lista.addItem("Divorciado");
lista.addItem("Viuvo");
lista.setEditable(false);
JPanel painel = new JPanel();
painel.add(lista);
setContentPane(painel);
Método que garante que
}
apenas os valores
existentes serão
selecionados
 Linguagem Java Entrada e Saída de Dados

• As barras de rolagem são implementadas no Swing com a classe

JScrollBar. Estas aparecem quando o objeto contém mais itens do que
pode ser apresentado. JScrollPane basicamente consiste em
JScrollBars e um Jviewport conforme pode ser visto no desenho
abaixo.
 Linguagem Java Entrada e Saída de Dados

public Framework( ){
JPanel painel = new JPanel();
JLabel identificadorArea = new JLabel("Escreva sua reclamação");
JTextArea area = new JTextArea(10,10);
JScrollPane areaRolagem = new JScrollPane(area);
identificadorArea.setLabelFor(areaRolagem);
painel.add(identificadorArea);
painel.add(areaRolagem);
setContentPane(painel);
}

Passa o JTextArea como

parâmetro para criação
do JScrollPane e
adiciona este objeto ao
Pane.
 Linguagem Java Entrada e Saída de Dados

JComboBox – Principais métodos

public int getItemCount()
Retorna a quantidade de itens no JComboBox.
public void addItem(String)
Adiciona uma String ao final do JComboBox.
public object getItemAt(int)
Retorna o Objeto na posição indicada por int. Para transformar esse
objeto em uma String use. Ex: (String)Obj.getItemAt(3)
public void insertItemAt(String, int)
Insere a String na posição int.
public object getSelectedItem()
Retorna o objeto selecionado. Para transformar esse objeto em uma
String use. Ex: (String)Obj.getSelectedItem().
 Linguagem Java Entrada e Saída de Dados

JLabel – Principais métodos

public void setText(String)
Define a String de informação do rótulo.
JTextField – Principais métodos
public void setText(String)
Define a String do campo de texto.
public String getText()
Lê a String presente no campo de texto.
JCheckBox – Principais métodos
public boolean isSelected()
Determina se a caixa de seleção está Selecionado ou Não.
public void setSelected(boolean)
Marca ou desmarca a caixa de seleção.
ButtonGroup – Principais métodos
public void add(JComponent)
Adiciona o componente ao grupo de botões
 Linguagem Java Entrada e Saída de Dados

JTextArea– Principais métodos

public void setText(String)
Define a string da área de texto.
public String getText()
Retorna todas as linhas de uma área de texto como uma única String.
Junta as Linhas; o começo de uma nova linha está sempre no fim da linha anterior.
public void append(String s)
Adiciona a String s ao final da área de texto.
public int getLineCount()
Retorna a quantidade de linhas existente no objeto JTextArea.
JOptionPane– Principais métodos
public static JOptionPane.showMessageDialog(null, String, String,
JOptionPane.ERROR_MESSAGE)
 Linguagem Java Entrada e Saída de Dados

Algoritmos de Layout
• Controlam posicionamento e dimensão de componentes.
• Podem ser combinados para obter qualquer configuração.
• Podem ser criados implementando a interface LayoutManager.
• É impossível controlar tamanho e posição de componentes se um
LayoutManager estiver sob controle.

Gerenciadores de Layout
• Um gerenciador de layout determina como os componentes serão
organizados.
• É possível desligar layouts e, neste caso, é preciso definir posição e
tamanho de cada componente.
painel.setLayout(null)
componente.setBounds(x,y, largura, altura)
 Linguagem Java Entrada e Saída de Dados

Gerenciadores de Layout - A classe FlowLayout

• Esta classe permite que os componentes fluam da esquerda para a
direita, na ordem em que eles forem inseridos. Quando não há mais
espaço então uma nova linha de componentes começará imediatamente
abaixo da primeira e na ordem da esquerda para a direita, exceto se for
especificado diferente.
• Elementos são apresentados centralizados.
• O “preferred size” é respeitado para todos os componentes.
FlowLayout objetoexemplo = new FlowLayout ();
setLayout(objetoExemplo);
 Linguagem Java Entrada e Saída de Dados

Gerenciadores de Layout - A classe GridLayout

• Este gerenciador organiza os componentes em uma grade de linhas e
colunas (elementos de uma tabela). Os componente são incluídos
primeiramente na linha superior da grade, começando da esquerda para
a direita. Quando todas as células estão preenchidas, o próximo
componente será inserido na célula mais a esquerda na segunda linha, se
houver uma segunda linha.

GridLayout objetoexemplo = new GridLayout (3, 2);

setLayout(objetoExemplo);

Linhas e
colunas
 Linguagem Java Entrada e Saída de Dados

Gerenciadores de Layout - A classe GridLayout

• Cada célula aceita um componente. Se houver mais células que
componentes, células não preenchidas ficarão em branco.
• Qualquer componente adicionado ocupa toda a célula.
• Ele ignora o “preferred size” dos componentes. Ele estica o
componente até o tamanho da célula.
• Para manter o “preferred size” de um componente, pode-se adicioná-
lo em um componente que o respeita (por exemplo, um que use
FlowLayout) e adicionar este componente em GridLayout.
 Linguagem Java Entrada e Saída de Dados

Gerenciadores de Layout - A classe BorderLayout

• Esta classe divide o contêiner em cinco seções: North, South, East,
West, Center.
• As áreas do BorderLayout só aceitam um componente por vez. Se for
necessário mais de um componente é preciso primeiro adicioná-los
dentro de um único componente que então poderá ser adicionado na área
especifica.
• Permite controle detalhado de espaçamento.
BorderLayout objetoexemplo = new BorderLayout (5, 8);
setLayout(objetoExemplo);
 Linguagem Java Entrada e Saída de Dados

Gerenciadores de Layout - Classe CardLayout

• Este gerenciador difere dos anteriores porque ele pode ocultar
alguns componentes, mostrando apenas um por vez.

Gerenciadores de Layout - Classe GridBagLayout

• É o mais flexível e complexo dos gerenciadores de Layout. Um
componente pode ocupar mais de uma célula na grade e as proporções
entre as linhas e colunas não precisam ser iguais.
• É um gerenciador de layout mais sofisticado, com amplo controle.

Combinação de Layouts
• Componentes podem ser combinados em recipientes (como JPanel)
para serem tratados como um conjunto.
 Linguagem Java Entrada e Saída de Dados

Eventos

• Para transformar uma interface Java em um programa Java que

funcione é necessário tornar a interface receptiva aos eventos do usuário.
• O Swing utiliza um conjunto de classes chamadas de receptores de
eventos.
• Se uma classe quer responder a um evento de usuário no sistema de
tratamento de eventos então é necessário implementar a interface que
trata de eventos. Cada receptor (ouvinte – listener) trata de um tipo
específico de evento e uma classe pode implementar quantos deles forem
necessários.
 Linguagem Java Entrada e Saída de Dados

Eventos
• Eventos em Java são objetos da subclasse de java.util.EventObject.
• Todo evento tem um objeto que é sua fonte.
Object fonte= evento.getSource();
• Métodos de ouvintes (listeners) que desejam tratar eventos, recebem
eventos como argumento. argumento
public void actionPerformed(ActionEvent e) {
Object obSource = e.getSource();
System.out.println(“O evento ocorreu em ” + obSource.toString());
}
• Ouvintes precisam ser registrados nas fontes.
botao.addActionListener(ouvinte);
/*neste caso o ouvinte deve ter o método da interface ActionListener,
public void actionPerformed(ActionEvent e) implementado. */
 Linguagem Java Entrada e Saída de Dados

Eventos
• Divididos em categorias.
• ActionEvent (fonte: componentes de ação)
• MouseEvent (fonte: componentes afetados pelo mouse)
• ItemEvent (fonte: checkboxes e similares)
• TextEvent (fonte: componentes de texto)
• WindowsEvent (fonte: janelas)
• FocusEvent (fonte: componentes em geral)
• KeyEvent (fonte: componentes afetados pelo teclado)
• e outros
 Linguagem Java Entrada e Saída de Dados

Eventos
• Cada evento tem uma interface Listener correspondente que possui
métodos padrão para tratá-lo.
• ActionEvent : Interface ActionListener
• MouseEvent : Interface MouseListener
• ItemEvent : Interface ItemListener
• TextEvent : Interface TextListener
• WindowsEvent : Interface WindowsListener
• FocusEvent : Interface FocusListener
• KeyEvent : Interface KeyListener
(segue um padrão)
• XXXEvent : Interface XXXListener
 Linguagem Java Entrada e Saída de Dados

Eventos - interface Listener

1) ActionListener - Eventos de ação, que são gerados por um usuário
agindo sobre um componente, como um clique de mouse em um botão.
2)FocusListener - Eventos de foco de teclado, como um campo de texto
que recebe ou perde foco.
3) ItemListener - Eventos de item, como um item de caixa de seleção é
alterado.
4) KeyListener - Eventos de teclado quando um usuário digita texto no
teclado.
 Linguagem Java Entrada e Saída de Dados

Eventos - interface Listener

5) MouseListener - Eventos de mouse, entrando na área de um
componente e deixando a área de um componente.
6) MouseMotionListener - Eventos de movimento de mouse, que são
usados para controlar toda a movimentação de um mouse sobre
componente.
7) WindowsListener - Eventos de janela, que são gerados por uma janela,
como quando a janela principal é maximizada, minimizada ou fechada.
 Linguagem Java Entrada e Saída de Dados

Eventos
• A classe ouvinte tem de implementar o(s) listener(s) desejado(s).
public class MinhaClasse implements ActionListener, FocusListener {
• A classe ouvinte precisa implementar os métodos das interfaces
Listener que ela declarou.
public void actionPerformed (ActionEvent e) { } Interface ActionListener
public void focusGained (ItemEvent evt ){ } Interface FocusListener
public void focusLost (ItemEvent evt ){ } Interface FocusListener

• Alguns listeners possuem uma classe Adapter que implementa todos os

métodos, sem instruções. Só existe para listeners que tenham mais de um
método.
 Linguagem Java Entrada e Saída de Dados

Eventos
• Depois que um componente que deve receber o evento (fonte) for
criado é necessário que o receptor seja incluído como ouvinte.
Assim, após a criação de um componente (fonte), os seguintes métodos
podem ser associados a ele:
addActionListener( ), addAdjustmentListener( ),
addFocusListener(), addItemListener( ), addKeyListener( ),
addMouseListener( ), addMouseMotionListener( ),
addWindowsListener( ).

O exemplo a seguir cria um objeto JButton e associa um receptor de

evento de ação a ele:
Jbutton botao = new Jbutton(“Nome do botao”);
botao.addActionListener(this); O this indica que a classe atual
é a receptora do evento, ou
seja é a ouvinte
 Linguagem Java Entrada e Saída de Dados

• Se mais de um componente da classe possuir um receptor de evento de

ação, é necessário descobrir qual deles foi usado e então agir de acordo
com as ações do programa.
• O objeto ActionEvent pode ser usado para descobrir detalhes a
respeito do componente que gerou o evento.
• Pode descobrir o tipo do objeto (pelo nome do objeto) ou então o tipo do
componente que foi acionado (JTextField, JButton, etc)
 Linguagem Java Entrada e Saída de Dados

Pelo nome do Objeto

public void actionPerformed(ActionEvent evt){
Objeto src = evt.getSource( );
if (src == nomeObjeto){
// código de tratamento
} else { Exemplos de
// código de tratamento Eventos de Ação
}
}
Pelo tipo do Componente
public void actionPerformed(ActionEvent evt){
Objeto src = evt.getSource( );
if (src instanceof JButton){
// código de tratamento Sobre: (JButton,
JCheckBox, JComboBox,
} else {
JTextField ou
// código de tratamento JRadioButton)
}
}
 Linguagem Java Entrada e Saída de Dados

Eventos - Adapter
• Facilitam a implementação de classes tratadoras de eventos.
• O programador não precisa implementar todos os métodos da
interface.
• Adaptadoras implementam as interfaces, tendo métodos vazios para
cada um dos métodos da interface
• Definir uma subclasse de adapter redefinindo os métodos que
interessam.
• O nome do adapter é semelhante ao do Listener.
MouseListener : MouseAdapter
WindowListener: WindowAdapter, ....
 Linguagem Java Entrada e Saída de Dados

Eventos – Não usando Adapter

interface WindowListener {
public void windowActivated(WindowEvent evt);
public void windowClosed(WindowEvent evt);
public void windowClosing(WindowEvent evt);
public void windowDeactivated(WindowEvent evt);
public void windowDeiconified(WindowEvent evt);
public void windowIconified(WindowEvent evt);
public void windowOpened(WindowEvent evt);
}

Public class MinhaClasse implements WindowListener {

public void windowActivated(WindowEvent evt) {/* código da classe */}
public void windowClosed(WindowEvent evt) {/* código da classe */}
public void windowClosing(WindowEvent evt) {/* código da classe */}
public void windowDeactivated(WindowEvent evt) {/* código da classe */}
public void windowDeiconified(WindowEvent evt) {/* código da classe */}
public void windowIconified(WindowEvent evt) {/* código da classe */}
public void windowOpened(WindowEvent evt) {/* código da classe */}
}
 Linguagem Java Entrada e Saída de Dados

Eventos – Usando Adapter

interface WindowListener {
public void windowActivated(WindowEvent evt);
public void windowClosed(WindowEvent evt); Só interessa ter
public void windowClosing(WindowEvent evt); implementação para
public void windowDeactivated(WindowEvent evt); este método na
public void windowDeiconified(WindowEvent evt); classe MinhaClasse.
public void windowIconified(WindowEvent evt); O uso do Adapter
public void windowOpened(WindowEvent evt); WindowAdapter
} permite isso.
public class MinhaClasse extends Frame {
public MinhaClasse() {
this.setTitle("Usando um Window Adapter");
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent evt) {
System.exit(0);
}
});
this.pack();
this.show();
}