Java – Programação Gráfica
•Uma janela de nível mais alto é chamado de um quadro frame em Java.
• A biblioteca AWT tem uma classe baseada em semelhantes, chamada Frame.
• A versão Swing dessa classe é chamada de JFrame;
•a JFrame estende a classe Frame e é um dos poucos componentes Swing que não é
desenhado em uma ('tela de desenho" chamada canvas.
• Assim, as decorações (botões,.barra de título, ícones etc) são desenhadas pelo sistema
de gerenciamento de janelas do usuário e não pelo Swing.
•Os quadros são exemplos de contêineres.
•Um quadro pode conter outro componentes da interface de usuário, como botões e
campos de texto.
Exemplo : FirstTestjava
import javax.swing.*;
class FirstFrame extends Jframe
{ public FirstFrame ()
{ setTitle('FirstFrame');
setSize(300, 200);
}
}
public class FirstTest
{ public static void main(String[] args)
{ Frame frame = new FirstFrameo;
frame.show ();
}
}
Vamos percorrer esse programa, linha por
linha.
•As classes Swing são colocadas no pacote javax. swing.
•O nome javax do pacote indica um pacote de extensão java, e não um pacote do
núcleo.
•No Java 2, o pacote Swing não é mais uma extensão, mas faz parte de hierarquia do
núcleo. Nas versões beta do Java 2 acomodou-se como javax.swing
•No programa, definimos uma classe FirstFrame, que se comporta exatamente como a
classe JFrame do pacote javax. Swing.
• O construtor de First frame coloca na barra de título a string "FirstFrame" e faz o
tamanho do quadro ser de 300 x 200 pixels. A priore, um quadro tem largura e altura
iguais a 0.
• O método main mostra o quadro e sai. Isso não termina o programa, mas apenas o
subprocesso principal.
• A exibição da janela ativa um subprocesso de interface de usuário que man, têm o
programa "vivo".
Para mostrar realmente um quadro, devem-se executar os seguintes passos:
· Criar o objeto quadro usando operador new.
· Opcionalmente, posicioná-lo na tela do usuário usando o método setlocation.
· Chamar o método show para tomar visível o quadro e trazê-lo para frente se estiver
por trás de outra janela.
• A linha chave no método main do Exemplo é:
JFrame frame = new FirstFrame();
• Essa linha cria um novo FirstFrame fornecendo todas as informações necessárias para
que o sistema de controle de janelas subjacente exiba uma janela.
• A chamada de new não exibe o quadro; como mencionamos. É necessário usar os
métodos show ou setvisible para efetivamente fazer o quadro aparecer na tela.
•O padrão é de quadros visíveis tenham dimensões O x O pixels, antes que se possa ver
um quadro torna-se necessário especificar suas dimensões.
• No Exemplo fizemos 300 pixels de largura por 200 pixels de altura usando o método
setsize no construtor do quadro.
• Finalmente, o quadro vai aparecer no canto superior esquerdo pois não usamos o
método setlocation a fim de reposicioná-lo.
• Podemos ter um código para criar e mostrar o quadro colocado no método main da
própria classe.
public class FirstFrame extends Jframe
{ public FirstFrame ()
{ setTitle('FirstFrame');
setsize (300, 200)
}
public satatic void main(String[] args)
{JFrame freme = new FirstFrame();
frame.show();
}
}
•Usar o método main da classe frame para o código que instancia e exibe o quadro é
mais simples no sentido de que não se precisa introduzir outra classe auxiliar para fazer
isso.
•Alguns programadores consideram esse estilo de código mais confuso e preferem
separar a classe que executa o programa da classe que controla a aparência e o
comportamento do quadro.
Como Encerrar Programas Gráficos
• Há, infelizmente, um sério problema no programa FirstFrame. Se você executar o
programa, vai descobrir que não há como sair dele!
• Não há nada óbvio que permita encerrar esse aplicativo, embora a janela possa ter
sido ocultada. Você vai ver logo como escrever programas Swing que podem ser
encerrados adequadamente.
• Pode-se terminar o programa java pressionando ctrl,c ou dando um clique no botão
Fechar no canto superior direito da janela do console, e, alternativamente, pode-se,,
pressionar CTRL+ALT+DEL.
• O AWT propicia uma classe chamada WindowAdapter .
class Terminator extends WindowAdapter
{
public void windowClosing (windowEvent e)
System.exit(O);
}
Usando a mágica das classes anônimas, podemos até mesmo evitar dar um nome à
addwindowlistener (new WindowsAdapter ( )
{ public void windowClosing(WindowEvent e)
{ System.exit(O);
}
});
import java.awt.event.*;
import javax.swing.*;
class CloseableFrame extends Jframe
{ public CloseableFrame ( )
{ setTitle(“CloseableFrame”);
setSize(300, 200);
addWindowListener(new WindowAdapter ( )
{ public void windowClosing(WindowEvent e)
{
System.exit( );
}
});
}
}
public class CloseableTest
{ public static void main(String[] args)
{
JFrame frame = new CloseableFrame ( )
frame.showo;
}
}
Layout de Quadros
•A classe JFrame, por si mesma, somente tem alguns poucos métodos para alterar a
disposição visual (layout) dos quadros.
•Evidentemente, através da mágica da herança, a maior parte dos métodos para se
trabalhar o dimensionamento e o posicionamento de um quadro vêem das várias
superclasses de JFrame.
O método dispose que fecha a janela e recupera os recursos do sistema usados em su
criação.
- O método setIconImage que especifica um objeto image para ser usado como ícon
quando a janela é minimizada .
-
- O método settitle para mudar o texto da barra de título da janela.
- O método setResizeable, que toma um boolean para determinar se um quadro se
redimensionável pelo usuário.
Exibição de Informações em um Quadro
• Seria possível desenhar a string da mensagem diretamente num quadro, mas esta não
seria considerada uma boa prática de programação.
• Em Java, os quadros são projetados realmente somente para serem contêineres de
componentes como barras de menu e outros elementos de interface de usuário.
• Normalmente desenha-se em outro componente, chamado panel, que é adicionado ao
quadro.
• A estrutura de um JFrame é surpreendentemente complexa.
• A parte que mais interessa aos programadores Swing é a área de conteúdo.
•
Ao projetar um quadro, adicionam-se componentes à área de conteúdo usando
código como o seguinte:
•
Container painelconteudo = f rame. getContentPane ( )
Component c =“ ” ;
painelconteudo.add;
• Em nosso caso, queremos adicionar um único painel à área de conteúdo na qual
vamos desenhar a mensagem.
• Os painéis são implementados pela classe JPanel. Eles são elementos da interface de
usuário com duas propriedades úteis:
•
• Eles têm uma superfície na qual se pode desenhar.
• Eles são, também, recipientes.
•Assim, eles podem conter outros componentes de interface como botões, botões
deslizantes, etc.
•O código completo para adicionar um painel a um quadro é:
Container painelconteudo = frame.getContentPane ( );
JPanel p = new JPanel
painelconteudo. add (p)
javax.swing.JFrame
Container getContentPane ( )
retoma o objeto área de conteúdo deste JFrame.
Objetos Gráficos e o Método paintcomponent
•Sempre que você precisar de um componente de interface de usuário que seja
semelhante a um dos componentes Swing básicos, poderá usar herança para criar uma
nova classe e depois sobrepor ou adicionar métodos para obter a funcionalidade extra
necessária.
• Por exemplo, nossas classes FirstFrame e CloseableFrame derivaram da classe Swing
JFrame.
• Para desenhar em um painel, será necessário:
Definir uma classe que estenda JFrame.
Sobrepor o método paintcomponent dessa classe.
• O método paintcomponent está, na verdade, na classe icomponent, que é uma classe
antecessora de todos os componentes Swing que não são de janela.
• Ele recebe um parâmetro do tipo Graphics. O parâmetro Graphics é semelhante a
um contexto de dispositivo do Windows
• . Ele tem métodos para desenhar padrões, imagens e texto. Eis como fazer um painel
no qual se pode desenhar:
class MyPanel extends JPanel
{
public void paintComponent(Graphics g)
o código para desenhar vai aqui
• Em geral, sempre que se quer colocar mensagens de texto ou gráficos em um painel,
é necessário definir uma nova classe e sobrepor o método paintcomponent.
Como vimos no código básico anterior, o método paintcomponent toma somente um
único parâmetro do tipo Graphics.
Um objeto Graphics lembra uma coleção de especificações para desenhar imagens e
texto, como a fonte definida ou a cor atual.
Toda ação de desenhar em java precisa usar um objeto Graphics. As medidas de um
objeto Graphics para exibir na tela é feita em pixels.
A coordenada (0,0) denota o canto superior esquerdo do componente em cuja
superfície se está desenhando.
NOTA:
Realmente, o argumento de paintcomponent é um objeto do tipo
Graphics2D, uma subclasse da classe Graphics. A classe Graphics2D tem Métodos
adicionais para desenhos mais sofisticados. A classe conceitualmente mais simples,
Graphics, é suficiente para desenhos de linhas retas simples.
•A exibição de texto (geralmente chamada de renderização de texto) é considerada
um tipo especial de desenho.
• Por exemplo, um objeto Graphics tem um método drawstring que usa a sintaxe
seguinte:
• g.drawString(texto, Coordx, Coordy)
• Em nosso caso, queremos desenhar a string 'Not a Hello, World program, em nossa
janela original, aproximadamente a um quarto na horizontal e metade na vertical.
•O primeiro caractere da string vai começar numa posição 75 pixels a direita e 100
pixels para baixo.
•Assim, nosso método paintcomponent ficará assim:
class NotHelloworldPanel extends Jpanel
{
public void paintComponent(Graphics g)
{ .......... rotina de código, ver a seguir
g.drawString('Not a Hello, World program', 75, 100);
}
}
Entretanto, esse método paintcomponent não está completo.
A classe NotHelloWorldPanel estende a classe Tpanel, a qual tem sua própria idéia
sobre como desenhar o painel, que é preenche-lo com a cor de fundo.
Para ter certeza de que a superclasse faz sua parte do trabalho, precisamos chamar
super.paintComponent antes de fazer qualquer desenho por conta própria.
class NotHelloWorldPanel extends Jpanel
{ public void paintComponent(Graphics g)
{ super.paintComponent(g);
g.drawstring(”Not a Hello, World program”, 75, 100);
}
}
Exemplo : NotHelloWorldjava
import java.awt.*;
import java.awt.event.*;
import javax.swing.*,,
class NotHelloworldPanel extends Jpanel
{ public void paintComponent(Graphics g)
{
super.paintComponent(g);
g.drawString('Not a Hello, World program', 75, 100);
}
}
class NotHelloWorldFrame extends Jframe
{
public NotHelloWorldFrame ( )
{ setTitle('NotHelloWorld');
setSize(300, 200);
addWindowListener(new WindowAdaptero
public void windowClosing(WindowEvent e)
{ System.exit(O);
}
});
Container contentpane = getContentPaneo;
contentpane.add(new NotHelloworldPane ( ));
}
}
public class NotHelloWorld
{
public static void main(String[] args)
{ JFrame freme = new NotHelloWorldFrame ( );
frame.show ( ); }