Módulo VII – Linguagem Java Entrada e Saída de Dados

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{
public Framework( ){
String nome ="Botao de exemplo";
JButton meuBotao1 = new JButton(nome);
JPanel painel = new JPanel();
painel.add(meuBotao1);
setContentPane(painel);
}
...
Objeto JButton é criado
com um nome
Objeto Jpanel é criado
e o botão é adicionado
a ele
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);
Criação de um label e
JPanel painel = new JPanel();
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
JTextArea de 10 linhas e
setContentPane(painel);
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
apenas um dos itens seja
JPanel painel = new JPanel();
selecionado. Em seguida
painel.add(sexo);
adiciona os objetos
painel.add(homem);
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){
Sobre: (JButton,
// código de tratamento
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();
}