Interface Gráfica

Prévia do material em texto

INTERFACE GRÁFICA
Interface (diferente de Interface gráfica)
Pode ser visto como a especialização de um serviço que pode ser realizado por uma ou mais classes.
A utilização do mecanismo de interface possibilita a especialização à outra classe.
Definição de Interface - implementação
Utilizar a palavra reservada implements
Superclasses de componentes
Os componentes possuem classes que definem quais serão seus estados e comportamentos. Veja como é a hierarquia dessas classes na Figura 1.
 
Figura 1: Hierarquia das classes que contém os componentes GUI
Classe Container
Faz parte do pacote java.awt sendo uma subclasse de Component anexados aos Containers. Os Containers são janelas que podem ser usados para organizar e exibir outros componentes na tela, pelo Container ser um Component, podemos colocar Containers dentro de outros Containers para facilitar a organização.
Classe JComponent
Está dentro do pacote javax.swing sendo uma subclasse de Container, mas é a superclasse que declara os atributos e comportamentos para todos os componentes Swing. Por ser a subclasse de Container, todos os componentes Swing acabam sendo Containers.
Alguns recursos comuns do JComponent incluem aparência e comportamento plugáveis, teclas de atalho, dicas de ferramenta, suporte para tecnologias de apoio a deficientes e suporte para localização de interface com o usuário, ou seja, é essa classe que abriga os componentes principais que são usados nas janelas.
Interfaces gráficas em Java
• GUI (Graphic User Interface)
• AWT e Swing
• Containers e componentes
• Layouts
Interface GUI
Conhecida como Interface Gráfica com Usuário (Graphical User Interface – GUI), é onde os resultados são apresentados em modo gráfico.
Essa interface é formada através de componentes GUI, conhecidos por controles ou widgets. Esses componentes são objetos que fazem a interação com usuário por teclado, mouse ou outros dispositivos que venham a servir para entrada de dados.
Componentes
Os componentes GUI Swing estão dentro do pacote javax.swing que são utilizados para construir as interfaces gráficas. Alguns componentes não são do tipo GUI Swing e sim componentes AWT. Antes de existir o GUI Swing, o Java tinha componentes AWT (Abstract Windows Toolkit) que faz parte do pacote javax.awt.
A diferença entre o GUI Swing e AWT, é na aparência e comportamento dos componentes, ou seja, quando criado por AWT, a aparência e comportamento de seus componentes são diferentes para cada plataforma e enquanto feito por GUI Swing, a aparência e comportamento funcionam da mesma forma para todas as plataformas. Os componentes AWT são mais pesados, pois requerem uma interação direta com o sistema de janela local, podendo restringir na aparência e funcionalidade, ficando menos flexíveis do que os componentes GUI Swing.
Eis abaixo alguns componentes com suas respectivas descrições:
	COMPONENTE
	DESCRIÇÃO
	JLabel
	Exibe texto não editável ou ícones
	JTextField
	Permite ao usuário inserir dados do teclado. Também pode ser utilizado para exibir texto editável ou não editável.
	JButton
	Desencadeia(libera) um evento quando o usuário clicar nele com o mouse.
	JCheckBox
	Especifica uma opção que pode ou não ser selecionada. 
	JComboBox
	Fornece uma lista drop-down de itens a partir da qual o usuário poder fazer uma seleção clicando em um item ou possivelmente digitando na caixa para procurar.
	JList
	Fornece uma lista de itens a partir do qual o usuário pode fazer uma seleção clicando em um item na lista. Múltiplos elementos podem ser selecionados.
	JPanel
	Fornece uma área em que os componentes podem ser colocados e organizados. Também pode ser utilizado como uma área de desenho para imagens. (É a área onde abriga e organiza os componentes inseridos).
	JOptionPane
	Mostra janelas de mensagens, confirmação e erros, permite entrada de dados, entre outras.
	JFrame
	Cria uma interface gráfica.
	JFileChooser
	A classe  é a responsável por mostrar uma janela de escolha de arquivos. É possível indicar o diretório inicial, os tipos de arquivos a serem mostrados, selecionar um ou vários e muitas outras opções.
Componentes atômicos
São elementos ou componentes que não permitem conter outros elementos. Podemos citar, dentre outros, botões, labels, textFields, sliders, check boxes, scrollbars, etc.
Root pane (Pasta de raiz)
Em geral, você não cria diretamente um objeto JRootPane. Em vez disso, você obtém um JRootPane (quer você quer ou não!) Quando instanciar JInternalFrame ou um dos recipientes Swing de nível superior, como JApplet, JDialog e JFrame.
layered pane (Painel em camadas)
Um painel em camadas é um recipiente Swing que fornece uma terceira dimensão para componentes de posicionamento: profundidade, também conhecida como ordem Z. Ao adicionar um componente a um painel em camadas, você especifica sua profundidade como um número inteiro. Quanto maior o número, mais perto o componente é para a posição "superior" dentro do recipiente. Se os componentes se sobrepõem, os componentes "mais próximos" são desenhados em cima dos componentes em uma profundidade menor. A relação entre os componentes na mesma profundidade é determinada pelas suas posições dentro da profundidade.
O pacote AWT (Abstract Windows Toolkit) possui os primeiros componentes gráficos que surgiram no java. Como janelas (Container, Frame, Panel...), alguns botões (Button, RadioButton, CheckBox...), Rótulos (Label), campos de texto (TextField), Listas (Choice, List,...) entre outros componentes. Esses componentes eram muito utilizados quando ainda não existia o pacote Swing. Eles possuem uma aparência mais "padrão", são mais quadrados e não possuem muitos efeitos gráficos.
O pacote Swing é uma evolução do pacote AWT. Além de seus próprios componentes, esse pacote possui quase todos os componentes que já existiam no pacote AWT, porém com uma interface gráfica mais evoluída e com maiores efeitos. Os componentes Swing começam com a letra "J", assim um botão que no AWT se denomina Button, no Swing é JButton. Como dito antes, o pacote Swing possui componentes próprios, esses componentes  estão entre telas mais aperfeiçoadas (JTabbedPane, JToolBar, JInternalFrame, JColorChooser...), novos botões e campos para dispor as informações na aplicação (JFormattedTextField, JProgressBar, JSpeener, JPasswordField, JTextPane, JTextArea...) e menus (JMenuBar, JMenu...).
As classes Swing são parte de um conjunto mais genérico de capacidades gráficas, chamado de Java Foundation Classes, ou JFC.
• JFC suporta:
– definição de botões, menus, etc.
– desenho 2D (java.awt.geom)
– funcionalidades drag-and-drop (java.awt.dnd)
– API com acessibilidade a usuários (javax.accessibility)
Swing é mais flexível que java.awt porque é implementada toda em Java, enquanto que java.awt é implementada em código nativo.
OBS. Java Foundation Classes (JFC). O JFC, além do Swing, contém API de acessibilidade, API 2D, etc.
API (Application Programming Interface) padrão Java. O API é um grupo de programas de suporte destinados a cumprir funções específicas que é dividido em diferentes partes funcionais chamadas pacotes (o que nós denominamos bibliotecas).
Look And Feel
Look-and-Feel (ou LaF) é o nome que se dá à "cara" da aplicação (suas cores, formatos e etc). Por padrão, o Java vem com um look-and-feel próprio, que se comporta exatamente da mesma forma em todas as plataformas suportadas.
O look-and-feel do Swing é único em todas as plataformas onde roda, seja ela Windows, Linux, ou qualquer outra. Isso implica que a aplicação terá exatamente a mesma interface (cores, tamanhos etc) em qualquer sistema operacional.
Mas, às vezes, esse não é o resultado desejado. Quando rodamos nossa aplicação no Windows, por exemplo, é bastante gritante a diferença em relação ao visual das aplicações nativas. Por isso é possível alterar qual o look-and-feel a serusado em nossa aplicação.
Além do padrão do Java, o JRE 5 da Sun ainda traz LaF nativos para Windows e Mac OS, além do Motif e GTK. E, fora esses, você ainda pode baixar diversos LaF na Internet ou até desenvolver o seu próprio.
Java Runtime Environment (JRE) significa Ambiente de Tempo de Execução Java, e é utilizado para executar as aplicações da plataforma Java. É composto por bibliotecas (APIs) e pela Máquina virtual Java (JVM).
Veja esses screenshots da documentação do Swing mostrando a mesma aplicação rodando com 4 LaF diferentes:
 
 
O Swing traz muitos componentes para usarmos como: 
botões, entradas de texto, tabelas, janelas, abas, scroll, árvores de arquivos, Tratamento de Eventos e muitos outros. 
Atualmente, o Java suporta, oficialmente, dois tipos de bibliotecas gráficas: AWT e Swing. A AWT foi a primeira API para interfaces gráficas a surgir no Java e foi, mais tarde, superada pelo Swing (a partir do Java 1.2), que possui diversos benefícios em relação a seu antecessor.
A biblioteca do Swing está no pacote javax.swing (inteira, exceto a parte de acessibilidade, que está em javax.accessibility).
As bibliotecas gráficas são bastante simples no que diz respeito a conceitos necessários para usá-las. A complexidade no aprendizado de interfaces gráficas em Java reside no tamanho das bibliotecas e no enorme mundo de possibilidades; isso pode assustar, em um primeiro momento.
AWT e Swing são bibliotecas gráficas oficiais inclusas em qualquer JRE (Ambiente de Tempo de Execução Java) ou JDK. Além destas, existem algumas outras bibliotecas de terceiros, sendo a mais famosa, o SWT - desenvolvida pela IBM e utilizada no Eclipse e em vários outros produtos.
Portabilidade
As API´s de interface gráfica do Java favorecem, ao máximo, o lema de portabilidade da plataforma Java. 
Grande parte da complexidade das classes e métodos do Swing está no fato da API ter sido desenvolvida tendo em mente o máximo de portabilidade possível. Favorece-se, por exemplo, o posicionamento relativo de componentes, em detrimento do uso de posicionamento fixo, que poderia prejudicar usuários com resoluções de tela diferentes da prevista.
Com Swing, não importa qual sistema operacional, qual resolução de tela, ou qual profundidade de cores: sua aplicação se comportará da mesma forma em todos os ambientes.
Começando com Swing - Mensagens
A classe mais simples do Swing é a JOptionPane que mostra janelas de mensagens, confirmação e erros, entre outras.
	JOptionPane.showMessageDialog é um método stático para exibir um diálogo de mensagem.
	Um diálogo de entrada de dados só pode ser inserido STRINGS. Isso é comum na maioria dos componentes GUI. Ao contrário do SCANNER, que pode ser utilizado para inserir valores de vários tipos no teclado. (H. M. Deitel e p. j. Deitel, 6. ed.).
	O método static parseInt da classe Integer converte um argumento String em um valor inteiro.
	O valor null indica que o diálogo deve aparecer no centro da tela do computador.
	O argumento é a mensagem a ser exibida.
	
Exemplo: 
import javax.swing.JOptionPane;
public class Interf01 
{ public static void main(String args[])
 {
 JOptionPane.showMessageDialog(null, "Minha mensagem! EDIBERTO MARIANO");
 }
}
SAÍDA
	O terceiro argumento representa a string que será exibida na barra de título do diálogo na parte superior do diálogo.
	 
JOptionPane.showMessageDialog( null, "Soma dos números = " + soma, "Soma
de dois números tipo inteiro", JOptionPane.PLAIN_MESSAGE);
	- O quarto argumento JOptionPane.PLAIN_MESSAGE é o tipo de diálogo de mensagem a ser exibido. (não exibe ícone à esquerda).
TIPOS DE DIÁLOGOS DE MENSAGEM
	- PLAIN_MESSAGE – Um diálogo que contém uma mensagem, mas nenhum ícone.
Exemplo:
import javax.swing.JOptionPane;
public class Interf01 
{ public static void main(String args[])
 { JOptionPane.showMessageDialog(null,"Minha mensagem! EDIBERTO 
 MARIANO", "diálogo sem ícone", JOptionPane.PLAIN_MESSAGE);
 }
}
SAÍDA
	
	- ERROR_MESSAGE – Um diálogo que indica um erro para o usuário.
Exemplo:
import javax.swing.JOptionPane;
public class Interf01 
{ public static void main(String args[])
 { JOptionPane.showMessageDialog(null,"Minha mensagem! EDIBERTO
 MARIANO", "diálogo de ERRO", JOptionPane.ERROR_MESSAGE);
 }
}
SAÍDA
	
	- INFORMATION_MESSAGE – Um diálogo com uma mensagem informativa para o usuário.	
Exemplo:
import javax.swing.JOptionPane;
public class Interf01 
{ public static void main(String args[])
 { JOptionPane.showMessageDialog(null,"Minha mensagem! EDIBERTO
 MARIANO", "Informação para o usuário", JOptionPane.INFORMATION_MESSAGE);
 }
} SAÍDA
- WARNING_MESSAGE – Um diálogo que adverte o usuário de um problema potencial.
Exemplo:
import javax.swing.JOptionPane;
public class Interf01 
{ public static void main(String args[])
 { JOptionPane.showMessageDialog(null,"Minha mensagem! EDIBERTO
 MARIANO", "Adverte ao usuário um problema potencial", 
 JOptionPane.WARNING_MESSAGE);
 }
} SAÍDA
- QUESTION_MESSAGE – Um diálogo que impõe uma pergunta ao usuário. Normalmente, esse diálogo exige uma resposta, como clicar em um botão Yes ou No.
Exemplos:
import javax.swing.JOptionPane;
public class Interf01 
{ public static void main(String args[])
 { JOptionPane.showMessageDialog(null,"Minha mensagem! EDIBERTO MARIANO”,
 "Impõe uma pergunta ao usuário", JOptionPane.QUESTION_MESSAGE);
 }
}
SAÍDA
JOptionPane - encontra-se no pacote javax.swing, e por ser um componente faz parte da Classe JComponent, permitindo ao usuário inserir informações nas caixas de diálogos, podendo exibir informações ou avisos.
Programa de soma utilizando JOptionPane para Entrada e Saída de dados
import javax.swing.JOptionPane;
public class Interf01 
{ public static void main(String args[])
	{ //entrada de dados via teclado
	 String num1 = JOptionPane.showInputDialog( "Digite o primeiro número");
	 String num2 = JOptionPane.showInputDialog( "Digite o segundo número");
	 //converte string em valores tipo inteiro para utilização de um cálculo
	 int n1 = Integer.parseInt(num1);
	 int n2 = Integer.parseInt(num2);
	 int soma = n1 + n2; //soma os dois valores e atribue à variável soma
	 //Exibição do resultado em um diálogo de mensagem JOptionPane
	 JOptionPane.showMessageDialog( null, "Soma dos números = " + soma, 
 "Soma de dois números tipo inteiro", JOptionPane.PLAIN_MESSAGE);	 
 }
}
SAÍDA
 
Exercício 01
Codifique um programa em Java que, permite que seja informado dois números inteiros, calcula e exiba: os dois números informados e a soma dos mesmos em um ambiente gráfico
Exercício 02
Codifique um programa em Java que, Permite que seja informado o salário de dois funcionários, depois exibe-os na tela (em um ambiente gráfico).
Exercício 03
Codifique um programa em Java que:
 * seja informado uma qtde de números tipo inteiro via teclado,
 * calcula e exibe a soma dos números digitados,
 * calcula e exibe a qtde de números digitados.
 * calcula e exibe a media dos números digitados.
 * até que seja digitado um numero = zero.
 * em um ambiente gráfico
 *OBS. O PROGRAMA SERÁ FINALIZADO QUANDO O NÚMERO INFORMADO FOR IGUAL A ZERO
 * CASO O PRIMEIRO NÚMERO INFORMADO FOR IGUAL A ZERO, SERÁ EXIBIDO NA TELA SOMENTE A MENSAGEM NÃO FOI INFORMADO NENHUM NÚMERO VÁLIDO
 * O NÚMERO ZERO NÃO SERÁ CONSIDERADO NÚMERO VÁLIDO, POR ISSO NÃO SERÁ QUANTIFICADOS JUNTO COM OS VÁLIDOS, OU SEJA, DIFERENTES DE ZERO.
Exercício 04
Codifique um programa em Java que:
-	permite que seja informado via teclado uma frase,-	exibe em linhas separadas cada palavra existente na frase
-	calcula e exibe a qtde de palavras que existem na frase digitada
COMPONENTES LEVES E COMPONENTES DE PESO (pesados)
	A maioria dos componentes Swing não está vinculada a componentes GUI reais suportados pela plataforma subjacente em que cada um aplicativo executa. Esses componentes GUI são conhecidos como componentes leves. Os componentes AWT (muitos dos quais são equivalentes dos componentes Swing) são vinculados à plataforma local e chamados de componentes de peso, porque contam com o sistema de janela da plataforma local para determinar sua funcionalidade e sua aparência e comportamento.
Argumentos do método setDefaultCloseOperation:
setDefaultCloseOperation defini o que fazer quando a janela for fechada:
EXIT_ON_CLOSE finaliza o aplicativo
DISPOSE_ON_CLOSE devolve os recursos ao sistema (Destrói a janela).
HIDE_ON_CLOSE oculta a janela (fecha a janela)
DO_NOTHING_ON_CLOSE usuário indica se a janela será fechada (Desabilita opção)
Exemplos SIMPLES de interface gráfica:
import javax.swing.JFrame;
public class Interf02
{ static JFrame f = new JFrame("Minha Primeira Interface Gráfica - PROF. 
 EDIBERTO MARIANO");
	public static void main(String args[ ])
	{
	 f.resize(500,100);//500 de largura e 100 de altura
	 f.show();
 }
} SAÍDA
Ou assim
import javax.swing.JFrame;
public class Interf01
{	public static void main(String args[ ] )
	{	MinhaInterface frame=new MinhaInterface();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
}
class MinhaInterface extends JFrame
{	public MinhaInterface( )
	{ setTitle("Minha Primeira Interface Gráfica - PROF. EDIBERTO MARIANO");
 setSize(500,100);
 // setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); //ou assim
	}
 // public static final int DEFAULT_WIDTH = 400; //ou assim
 // public static final int DEFAULT_HEIGHT = 300; //ou assim
}
Ou assim
import javax.swing.JFrame;
public class Interface00
{ // Objeto Janela
 static JFrame janela = new JFrame("Minha Primeira Interface Gráfica - PROF. 
 EDIBERTO MARIANO");
 public static void main(String args[])
 { 
 janela.setBounds(50, 100, 500, 100); // Seta posicao e tamanho: Coluna 50 
 (do vídeo), Linha 100 (do vídeo), 
 Largura 500, Altura 100
 // janela.setDefaultCloseOperation(WindowConstants,DISPOSE_ON_CLOSE);
 janela.setVisible(true); // Exibe a janela
 }
} SAÍDA
Containers e componentes
• Uma interface gráfica em Java é baseada em dois elementos:
– containers: servem para agrupar e exibir outros componentes.
– componentes: botões, labels, scrollbars, etc.
• Dessa forma, todo programa que ofereça uma interface vai possuir pelo menos um container, que pode ser:
– JFrame: janela principal do programa
– JDialog: janela para diálogos
– JApplet: janela para Applets
• Para construirmos uma interface gráfica em JAVA, adicionamos componentes (Botões, Menus, Textos, Tabelas, Listas, etc.) sobre a área da janela.
• Por essa razão a área da janela é um container, ou seja, um elemento capaz de armazenar uma lista de componentes.
Exemplos com Container e Componentes.
CRIAÇÃO DE UMA INTERFACE GRÁFICA, TAMANHO 500X130, COM DOIS BOTÕES EM JAVA
import javax.swing.*;
public class interface2
{	public static void main(String jan[])
	{	Botao janela=new Botao();
		janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//TAMANHO DA JANELA, LARGURA = 400 PIXELS, ALTURA 130 PIXELS
		janela.setSize(500,130);
		janela.setLayout(null);
		janela.setVisible(true);
	}
}
class Botao extends JFrame
{	public Botao()
	{ super ("Estácio de Sá - PROF. EDIBERTO MARIANO");
		JDesktopPane pan=new JDesktopPane();
		JButton bot1=new JButton("CADASTRO DE CLIENTE");
		JButton bot2=new JButton("CADASTRO DE FORNECEDORES");
 //TAMANHO DOS BOTÕES 
		bot1.setSize(180,30);
		bot2.setSize(280,30);
	 	//POSIÇÕES DOS BOTÕES
		bot1.setLocation(150,10); //COLUNA 150 LINHA 10
		bot2.setLocation(100,50); //COLUNA 100 LINHA 50
		add(bot1);
		add(bot2);
	 add(pan);
	}
} RESULTADO DO PROGRAMA EXECUTADO
CRIAÇÃO DE UMA INTERFACE GRÁFICA, TAMANHO 300X130, COM BOTÕES EM JAVA
JButton (com JFrame)
Criação de botões em uma interface gráfica COM dimensões definidas no programa.
import javax.swing.JFrame;
import javax.swing.JButton;
class Botao01 extends JFrame //OBS SE FOR OUTRA CLASSE COLOCA-SE public NO INÍCIO
{ public Botao01()
 { super("JANELA COM BOTÃO");//Titulo da Janela
 JButton bot1 = new JButton("Cadastro");
 JButton bot2 = new JButton("Relatório");
 bot1.setSize(100,30); //tamanho do botão em pixels, Largura 100, altura 30
 bot2.setSize(100,30); //tamanho do botão em pixels, Largura 100, altura 30
 bot1.setLocation(6,5);//posição do botão Coluna 6, Linha 5
 add(bot1);
 bot2.setLocation(6,40);//posição do botão Coluna 6, Linha 40
 add(bot2);
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 setSize(300,200); //tamanho da janela largura 300, altura 300
 setLayout(null);
 setVisible(true);
 setLocationRelativeTo(null); //centraliza a janela
 }
}
public class Botao00
{ 
 public static void main(String args[])
 { 
 	Botao01 app = new Botao01();
 }
} 
 SAÍDA
Outro exemplo - Button (com JFrame)
import javax.swing.*;
import java.awt.*;
public class Teste
{	public static void main(String jan[])
	{	Botao janela=new Botao();
		janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//TAMANHO DA JANELA, LARGURA = 300 PIXELS, ALTURA 130 PIXELS
		janela.setSize(300,130);
		janela.setLayout(null);
		janela.setVisible(true);
	}
}
class Botao extends JFrame
{	public Botao()
	{	super ("Estácio de Sá");
		JDesktopPane pan=new JDesktopPane();
		JButton bot1=new JButton("UNESA");
		JButton bot2=new JButton("POO II");
 JButton bot3=new JButton("ALUNO");
		JButton bot4=new JButton("PROF");
 //TAMANHO DOS BOTÕES 
		bot1.setSize(80,30);
		bot2.setSize(80,30);
	 bot3.setSize(80,30);
		bot4.setSize(80,30);
	 //POSIÇÕES DOS BOTÕES
		bot1.setLocation(10,10); //COLUNA 10 LINHA 10
		bot2.setLocation(10,50); //COLUNA 10 LINHA 50
		bot3.setLocation(100,10);//COLUNA 100 LINHA 10
		bot4.setLocation(100,50);//COLUNA 100 LINHA 50
	 add(bot1);
		add(bot2);
		add(bot3);
		add(bot4);
		add(pan);
	}
} SAÍDA DO PROGRAMA EXECUTADO
COMBOBOX
package control;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class ExecutaCombo extends JFrame
{
	ExecutaCombo(String title)
	{
		super(title);
	}
 public static void main(String args[]) { 
	 ExecutaCombo obj = new ExecutaCombo("COMBOBOX - PROF. EDIBERTO");
	 obj.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JComboBox combo = new JComboBox();
		JPanel container = new JPanel();
		combo.addItem("--Escolha um Item do COMBOBOX--");
		combo.addItem("Sistema de Informação");
		combo.addItem("Redes de Computadores");
		combo.addItem("Medicina");combo.addItem("História");
		container.add(combo);
		obj.getContentPane().add(container);
		obj.pack();
		obj.setLocationRelativeTo(null);
		obj.setSize(400,200); //tamanho da janela largura 300, altura 300
		obj.setVisible(true);
 }
}
SAÍDA
 
�PAGE �
�PAGE �17�