Aula3

Projeto V (U900005) – Ciências da Computação
Projeto II (U900003) – Engenharia da Computação
Prof. Valdir Gil Pillat
6. Como aplicações gráficas funcionam em Java ?
Todas as aplicações gráficas em Java usam instâncias de classes existentes, que por serem
parte da linguagem podem ser executadas em todas as versões de Java e em todos os
sistemas operacionais. Destas classes, a principal é a classe Frame, que cria uma janela com
borda e barra de título para criação de aplicações.
Podemos usar instâncias da classe Frame de duas maneiras: usando-as diretamente no
programa (possivelmente dentro do método main) ou criando uma classe derivada da classe
Frame e criando instâncias desta classe derivada dentro do programa. Eventualmente alguns
métodos da classe Frame devem ser reescritos para fazer o que queremos, significando que
devemos usar instâncias de classes que estendem ou herdam a classe Frame. A classe
derivada herdará todos os mecanismos da classe Frame, mas alguns métodos deverão ser
reescritos para nossas necessidades. Um exemplo bem básico é mostrado abaixo:
Exemplo 1. Um programa que cria uma instância de uma classe que herda da classe
Frame
1 /* Para podermos usar qualquer operação gráfica devemos incluir a linha abaixo */
2 import java.awt.*;
3
4 /* Criamos uma classe que herda tudo da classe Frame */
5 class minhaFrame extends Frame
6 {
7 minhaFrame(String título) // um construtor que recebe uma String como argumento
8
{
9
// chamo o construtor da classe Frame com o argumento título
10
super(título);
11 // Declaro o tamanho que instâncias desta classe vão ocupar
12
setSize(100,100);
13 // Digo que instâncias desta classe serão visíveis
14 show();
15 } // fim do construtor para a classe minhaFrame
16 } // fim da classe minhaFrame
17
18 // uma classe que declara e usa uma instância da classe minhaFrame
19 class demoFrame
20 {
21 public static void main(String args[])
22
{
23 // Declaro uma nova instância da classe minhaFrame
24 minhaFrame mf = new minhaFrame("Uma Janela !");
25
} // fim do método main
26 } // fim da classe
22/08/2005
http://www.fcc.univap.br/~valdir
e-mail: [email protected]
1
Projeto V (U900005) – Ciências da Computação
Projeto II (U900003) – Engenharia da Computação
Prof. Valdir Gil Pillat
6.1. Adicionando componentes na Frame
Somente a janela de uma instância de classes descendentes de Frame não adiciona utilidade
real aos programas - é necessária a inserção de componentes na janela que terão diversas
utilidades. Botões, áreas de texto, áreas para desenho, etc. são componentes que podem ser
adicionados à instâncias de classes descendentes de Frame que podem aumentar a utilidade
dos programas.
Para adicionar um componente à Frame, devemos usar o método add(Component c), onde c
é uma instância de uma classe descendente da classe Component. Da mesma maneira que
devemos criar classes herdeiras da classe Frame, podemos criar descendentes customizados
da classe Component.
A listagem abaixo mostra um programa que contém uma classe herdeira de Component e
uma classe herdeira de Frame. Para ilustrar conceitos da próxima seção, iremos criar uma
classe que herda da classe Canvas (que por sua vez herda da classe Component).
Exemplo 2. Um programa com instâncias de classes descendentes de Frame e Canvas
1 /* Para podermos usar qualquer operação gráfica devemos incluir a linha abaixo */
2 import java.awt.*;
3
4 /* Criamos uma classe que herda tudo da classe Canvas */
5 class meuCanvas extends Canvas // por enquanto, vazia
6 {
7 }
8
9 /* Criamos uma classe que herda tudo da classe Frame */
10 class minhaFrame extends Frame
11 {
12 minhaFrame(String título) // um construtor que recebe uma String como argumento
13
{
14
// chamo o construtor da classe Frame com o argumento título
15
super(título);
16 // Declaro e inicializo a instância da classe meuCanvas
17 meuCanvas cv = new meuCanvas();
18 // adiciono a instância à classe Frame
19 add(cv);
20 // Declaro o tamanho que instâncias desta classe vão ocupar
21
setSize(400,100);
22 // Digo que instâncias desta classe serão visíveis
23 show();
24 } // fim do construtor para a classe minhaFrame
25 } // fim da classe minhaFrame
26
27 // uma classe que declara e usa uma instância da classe minhaFrame
22/08/2005
http://www.fcc.univap.br/~valdir
e-mail: [email protected]
2
28
29
30
31
32
33
34
35
Projeto V (U900005) – Ciências da Computação
Projeto II (U900003) – Engenharia da Computação
Prof. Valdir Gil Pillat
class demoFrame
{
public static void main(String args[])
{
// Declaro uma nova instância da classe minhaFrame
minhaFrame mf = new minhaFrame("Uma Janela com Canvas !");
} // fim do método main
} // fim da classe
6.2. Criando alguns botões em aplicações gráficas em Java
Botões servem para permitir ao usuário executar uma ação (geralmente uma parte de um
programa em Java). Um botão pode ser criado em um aplicativo com interface gráfica em
Java usando instâncias da classe Button . Um exemplo de programa simples que cria um
botão na instância da classe Frame é mostrado abaixo:
Exemplo 3. Um programa em Java com um botão
1 /* Para podermos usar qualquer operação gráfica devemos incluir a linha abaixo */
2 import java.awt.*;
3
4 /* Criamos uma classe que herda tudo da classe Frame */
5 class minhaFrame extends Frame
6 {
7 /* Para que a instância da classe Button seja visível de todos os métodos da
8
classe minhaFrame, nós a declaramos aqui fora dos métodos */
9 Button b;
10 minhaFrame(String título) // um construtor que recebe uma String como argumento
11
{
12
// chamo o construtor da classe Frame com o argumento título
13
super(título);
14
// adiciono um botão
15 b = new Button("Botão 1");
16 add(b);
17 // Declaro o tamanho que instâncias desta classe vão ocupar
18
setSize(200,100);
19 // Digo que instâncias desta classe serão visíveis
20 show();
21 } // fim do construtor para a classe minhaFrame
22 } // fim da classe minhaFrame
23
24 // uma classe que declara e usa uma instância da classe minhaFrame
25 class demoButton
26 {
27 public static void main(String args[])
28
{
22/08/2005
http://www.fcc.univap.br/~valdir
e-mail: [email protected]
3
Projeto V (U900005) – Ciências da Computação
Projeto II (U900003) – Engenharia da Computação
Prof. Valdir Gil Pillat
29 // Declaro uma nova instância da classe minhaFrame
30 minhaFrame mf = new minhaFrame("Janela com botão !");
31
} // fim do método main
32 } // fim da classe
Alguns métodos interessantes da classe Button são:
•getLabel(): retorna uma String com o título do botão
•setLabel(String nome): usa a String "nome" como o novo título do botão
•setBackground(Color cor): Muda a cor de fundo do botão para a especificada por cor.
•setEnabled(boolean enable): se "enable" for true, permite que o botão aceite eventos
(cliques). Se for false, desabilita temporariamente o botão (cliques não terão efeito).
É possível mudarmos fontes e cores dos Buttons usando os mesmos métodos da classe
Component:
•setForeground(Color cor): Muda a cor de frente (de texto) para a cor especificada por
cor.
•setBackground(Color cor): Muda a cor de fundo para a cor especificada por cor.
•setFont(Font f): Muda a fonte dos caracteres para a fonte especificada por f.
6.3. Processando Eventos provenientes dos botões
Podemos observar que o botão no programa acima funciona (isto é, muda sua aparência
quando pressionado) mas fora este efeito visual, nada ocorre. Isto se deve ao fato de não
havermos registrado nenhum evento que devesse ocorrer quando o botão for pressionado,
ou seja, não explicitamos no programa que ação deve ocorrer caso o botão seja pressionado.
O registro de eventos em Java é feito em dois passos: primeiro, nós registramos o evento
para cada componente da interface que pode disparar um evento (no nosso caso, as
instâncias da classe Button). O registro é feito com o método addActionListener do próprio
componente, e devemos passar para este método um único argumento, que mostra qual é a
classe que vai processar o evento. Na maioria dos casos, a própria classe onde o Button é
inserido processará o evento ocorrido.
O segundo passo para registrar um evento é fazer com que a classe onde o botão está sendo
criado implemente a classe ActionListener .Devemos também criar um método public void
actionPerformed(ActionEvent evt) que processará todos os eventos registrados naquela
classe. O programa abaixo mostra como isto pode ser feito:
Exemplo 4. Um programa em Java com um botão (que funciona !)
1
2
3
4
/* Para podermos usar qualquer operação gráfica devemos incluir a linha abaixo */
import java.awt.*;
/* Para podermos processar qualquer tipo de evento, devemos incluir a linha abaixo */
import java.awt.event.*;
22/08/2005
http://www.fcc.univap.br/~valdir
e-mail: [email protected]
4
Projeto V (U900005) – Ciências da Computação
Projeto II (U900003) – Engenharia da Computação
Prof. Valdir Gil Pillat
5
6 /* Criamos uma classe que herda tudo da classe Frame */
7 class minhaFrame extends Frame implements ActionListener
8 {
9 /* Para que a instância da classe Button seja visível de todos os métodos da
10
classe minhaFrame, nós a declaramos aqui fora dos métodos */
11 Button b;
12 minhaFrame(String título) // um construtor que recebe uma String como argumento
13
{
14
// chamo o construtor da classe Frame com o argumento título
15
super(título);
16
// adiciono um botão
17 b = new Button("Botão 1");
18 add(b);
19 // adiciono um "listener" de evento ao botão
20 b.addActionListener(this);
21 // Declaro o tamanho que instâncias desta classe vão ocupar
22
setSize(200,100);
23 // Digo que instâncias desta classe serão visíveis
24 show();
25 } // fim do construtor para a classe minhaFrame
26
27 /* Já que a classe minhaFrame implementa ActionListener, sou obrigado a
28
criar este método, como public void */
29 public void actionPerformed(ActionEvent evt)
30
{
31 System.out.println("O botão foi pressionado !");
32
}
33
34 } // fim da classe minhaFrame
35
36 // uma classe que declara e usa uma instância da classe minhaFrame
37 class demoButton
38 {
39 public static void main(String args[])
40
{
41 // Declaro uma nova instância da classe minhaFrame
42 minhaFrame mf = new minhaFrame("Janela com botão !");
43
} // fim do método main
44 } // fim da classe
Veja também a apostila 263_curso_java.zip - pág 47 - 65
22/08/2005
http://www.fcc.univap.br/~valdir
e-mail: [email protected]
5
Projeto V (U900005) – Ciências da Computação
Projeto II (U900003) – Engenharia da Computação
Prof. Valdir Gil Pillat
Exercícios da aula 3
1. De onde vieram os métodos setSize e show da classe minhaFrame no exemplo 1?
Teórico
2. O que aconteceria se tirássemos a linha 10 no exemplo 1? E as linhas 12 ou 14 ? Teórico
3. Modifique o exemplo 1 para que o nome da janela (que aparece na barra superior da
janela) seja lido do teclado e passado pelo construtor da classe minhaFrame. Fácil
4. Modifique o exemplo 1 para que instâncias da classe minhaFrame não possam ter seu
tamanho modificado. Fácil
5. Crie uma instância de classe descendente de Frame onde o fundo da janela seja azul.
Fácil
6. O que acontecerá se especificarmos um nome de fonte inexistente (por exemplo,
"Inexistente") no construtor da classe Font ? Fácil
7. Crie um programa onde o fundo seja preto e um texto em caracteres brancos seja escrito.
Fácil
8. Escreva um programa que desenhe o símbolo das olimpíadas na tela. Fácil
9. Considere o exemplo 1. Escreva um programa em Java que crie 5 instâncias da classe
minhaFrame, com os nomes "um", "dois", "três", "quatro" e "cinco", e tamanhos 100x100,
200x100, 100x200, 200x200, 300x100 respectivamente. O construtor da classe
minhaFrame deverá ser modificado. Intermediário
10. Crie uma aplicação em Java com um botão que, ao ser clicado, mude o tamanho da
janela do programa de 100x100 para 200x200. Fácil
11. Crie uma aplicação em Java com um botão que, ao ser clicado, imprima na saída
normal (console de texto) um valor aleatório entre 1 e 6. Fácil
12. Crie uma aplicação em Java com um botão que, ao ser clicado, mude a cor do fundo da
janela para vermelho. Fácil
13. Crie uma aplicação em Java com um botão que, ao ser clicado, mude o tamanho da
janela do programa de 100x100 para 200x200, e ao ser clicado de novo, mude o tamanho
da janela do programa de volta para 100x100. Intermediário
14. Crie uma aplicação em Java com um botão que, ao ser clicado, mude a cor do fundo de
cada um dos dois botões para uma cor aleatória qualquer. Intermediário
15. Crie uma aplicação em Java com um botão que ao ser clicado imprima na saída normal
(console de texto) o código fonte do programa. Intermediário
16. Crie uma aplicação em Java com dois botões de forma que quando um for pressionado,
ele se desabilita (com o comando setEnabled) e habilita o outro botão. Exemplo: quando o
botão um for pressionado, ele se desabilitará e habilitará o botão dois. Quando o botão dois
for clicado, ele se se desabilitará e habilitará o botão um. Intermediário
22/08/2005
http://www.fcc.univap.br/~valdir
e-mail: [email protected]
6