Moving Eyes by Gilbert Le Blanc

This is a short example of a Java Swing GUI with drawing and simple animation. The eyeballs in the GUI follow the mouse cursor as you move the cursor in the drawing area of the GUI.

Introduction

I used Windows 10 and Java 7 to create this GUI. My screen capture software doesn’t recognize the narrow borders of a Windows 10 window.

I wrote 4 Java classes for this simple example. I put the 4 Java classes together to paste as a single example. You should put these classes in separate files when you create your Swing GUI.

I used the model / view / controller model when creating this Swing GUI. This means that:

  1. The view may read values from the model.
  2. The view may not update the model.
  3. The controller will update the model.
  4. The controller will repaint / revalidate the view.

Basically, the model is ignorant of the view and controller. This allows you to change the view and controller from Swing to a web site, or an Android app.

The model / view / controller pattern allows you to focus on one part of the Swing GUI at a time. In general, you’ll create the model first, then the view, and finally the controllers. You will have to go back and add fields to the model. I guarantee that you’ll come up with something you didn’t think of when you created the first cut of the model classes.

Here’s the code:

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

//http://java-articles.info/articles/?p=788
public class MovingEyes implements Runnable {

    private static final int drawingWidth = 400;
    private static final int drawingHeight = 400;
    private static final int eyeballHeight = 150;
    private static final int eyeballWidthMargin = 125;

    private DrawingPanel drawingPanel;

    private Eye[] eyes;

    private JFrame frame;

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new MovingEyes());
    }

    public MovingEyes() {
        this.eyes = new Eye[2];
        this.eyes[0] = new Eye(new Point(eyeballWidthMargin, eyeballHeight));
        this.eyes[1] = new Eye(new Point(drawingWidth - eyeballWidthMargin,
                eyeballHeight));
    }

    public void run() {
        frame = new JFrame("Moving Eyes by Gilbert Le Blanc");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        drawingPanel = new DrawingPanel(drawingWidth, drawingHeight);
        frame.add(drawingPanel);

        frame.setSize(800, 600);
    
        frame.setLocationRelativeTo(null);
    
        //frame.setResizable(false);
        // frame.pack();
        // frame.setLocationByPlatform(true);
        frame.setVisible(true);
    }

    public class DrawingPanel extends JPanel {

        private static final long serialVersionUID = -2977860217912678180L;

        private static final int eyeballOuterRadius = 50;
        private static final int eyeballInnerRadius = 20;

        public DrawingPanel(int width, int height) {
            this.addMouseMotionListener(new EyeballListener(this,
                    eyeballOuterRadius - eyeballInnerRadius - 5));
            this.setBackground(Color.WHITE);
            this.setPreferredSize(new Dimension(width, height));
        }

        // images
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);

            g.setColor(Color.BLACK);

            for (Eye eye : eyes) {
                drawCircle(g, eye.getOrigin(), eyeballOuterRadius);
                fillCircle(g, eye.getEyeballOrigin(), eyeballInnerRadius);
            }
        }

        private void drawCircle(Graphics g, Point origin, int radius) {
            g.drawOval(origin.x - radius, origin.y - radius, radius + radius,
                    radius + radius);
        }

        private void fillCircle(Graphics g, Point origin, int radius) {
            g.fillOval(origin.x - radius, origin.y - radius, radius + radius,
                    radius + radius);
        }

    }

    public class Eye {
        private final Point origin;
        private Point eyeballOrigin;

        public Eye(Point origin) {
            this.origin = origin;
            this.eyeballOrigin = origin;
        }

        public Point getEyeballOrigin() {
            return eyeballOrigin;
        }

        public void setEyeballOrigin(Point eyeballOrigin) {
            this.eyeballOrigin = eyeballOrigin;
        }

        public Point getOrigin() {
            return origin;
        }

    }

    public class EyeballListener extends MouseMotionAdapter {

        private final double eyeballDistance;

        private final DrawingPanel drawingPanel;

        public EyeballListener(DrawingPanel drawingPanel, double eyeballDistance) {
            this.drawingPanel = drawingPanel;
            this.eyeballDistance = eyeballDistance;
        }


        // mouse detector
        public void mouseMoved(MouseEvent event) {
            Point p = event.getPoint();
            for (Eye eye : eyes) {
                Point origin = eye.getOrigin();
                double theta = Math.atan2((double) (p.y - origin.y),
                        (double) (p.x - origin.x));
                int x = (int) Math.round(Math.cos(theta) * eyeballDistance)
                        + origin.x;
                int y = (int) Math.round(Math.sin(theta) * eyeballDistance)
                        + origin.y;
                eye.setEyeballOrigin(new Point(x, y));
            }

            drawingPanel.repaint();
        }

    }

}

You can use the JFrame and DrawingPanel code as a base for any Swing GUI where you need to draw.

Model

The Eye class is a Java object that holds the origin of the eye (circle) and the origin of the eyeball. The Eye class is the model in this simple example.

View

The MovingEyes class is the class that defines the JFrame. The MovingEyes class is part of the view. The main method of this class invokes the SwingUtilities invokeLater method to ensure that the Swing components are defined and modified on the Event Dispatch thread.

We use a JFrame. We do not extend a JFrame. The only time you extend a Swing component, or any Java class, is when you want to override one of the class methods. We’ll see this when I talk about the DrawingPanel.

The constructor of the MovingEyes class defines 2 instances of the Eye class. The run method defines the JFrame. The code in the run method will be similar for all Swing GUIs.

The DrawingPanel class makes up the rest of the view. The DrawingPanel class extends JPanel because we want to override the paintComponent method. The constructor of the DrawingPanel class sets the preferred size of the drawing area, and adds the mouse motion listener. The mouse motion listener is the controller of this Swing GUI.

The paintComponent method of the DrawingPanel class first calls the super paintComponent method. This maintains the Swing paint chain, and should always be the first statement of the overwritten paintComponent method.

The rest of the code in the paintComponent method of the DrawingPanel class draws the eyes. We only have drawing (painting) code in the paintComponent method. Control code belongs in the controller.

Controller

The EyeballListener class is the controller class. You can have more than one controller class in a more complicated Swing GUI.

The EyeballListener class extends the MouseMotionAdapter. You can implement the MouseMotionListener. I’m overriding one method, so the code is shorter when I extend the MouseMotionAdapter.

The mouseMoved method of the EyeballListener class fires a MouseEvent when the mouse is moved. We calculate a new position for the center of an eyeball by finding the theta angle from the center of the eye to the mouse position. The theta angle is used to calculate the new center of the eyeball.

Each Eye instance is updated separately in the for loop. After both eyes are updated, the drawing panel is repainted. This happens so fast that there’s no need for an animation loop in a separate thread.

An animation loop updates the model, draws the view, and waits for a specified period of time. You would use a separate thread for the animation loop, so that the GUI on the Event Dispatch thread stays responsive. If your GUI is not responsive, you’re probably doing too much work on the Event Dispatch thread.

Site: http://java-articles.info/articles/?p=788
Java archive: Moving Eyes by Gilbert Le Blanc.jar
Link: https://www.4shared.com/file/Qm-sr08-ei/Moving_Eyes_by_Gilbert_Le_Blan.html

Padrão De Arquitetura De Software MVC

Aqui vai uma dica bem legal depois de alguns dias sem postar nada, de ferias kkkk Aqui vai uma dica pra quem esta precisando, uma aula que encontrei postada por Rodrigo Rebouças de Almeida em um site citado logo abaixo como a fonte desse poste. Lá você vai encontra a materia original aqui eu modifiquei algumas coisas, sugiro que estude as duas compare ambas.

O Rodrigo ele fez uma Enquete em Java usando os padrões de arquitetura de software MVC (Model-View-Controller). Um sistema de votação.

EnqueteVotaçãoPorcentagem

Objetivo

Separar dados ou lógica de negócios (Model) da interface do usuário (View) e do fluxo da aplicação (Control)
A idéia é permitir que uma mesma lógica de negócios possa ser acessada e visualizada através de várias interfaces.
Na arquitetura MVC, a lógica de negócios (chamaremos de Modelo) não sabe de quantas nem quais interfaces com o usuário estão exibindo seu estado.
Com as diversas possibilidades de interfaces que conhecemos hoje, a MVC é uma ferramenta indispensável para desenvolvermos sistemas.

PASSO 1:

1-Isole o “Business Logic” de seu sistema. Para pequenas aplicações, crie um pacote separado para armazenar as classes que representam o modelo do seu sistema.
2-A camada “Model” pode estar armazenada em um SGBD, pode ser uma aplicação J2EE, ou até um simples pacote isolado contendo as classes de negócio.
3-Atenção! As classes que compõem o modelo de negócio não podem conhecer NADA do ambiente externo! Não deve haver referencias para o mundo fora do negócio.

PASSO 2:

1-As classes que compõem o modelo de negócio não devem conhecer nada sobre as camadas de interface que exibem suas informações.
2-Como fazer com que o modelo informe mudanças em seu estado para as interfaces, sem conhecê-las?
3-Aplicaremos então o padrão Observer! O nosso modelo de negócio será o gerador de eventos para as interfaces, as quais serão “listeners”!

PASSO 3:

1-Fazer com que as telas interessadas em exibir o estado atual do modelo implementem o EnqueteListener.

PASSO 4:

1-Implemente o controlador, ou seja, a classe que receberá os eventos da interface e transformará estes eventos em ações no modelo.
2-No nosso exemplo, o controlador é uma classe simples que atende aos eventos executados pelos botões da classe TelaVotacao e incrementa os votos no modelo.
3-Perceba que esta classe é fortemente ligada ao modelo.
4-Algumas documentações sobre o MVC indicam que a classe controladora possui referências tanto da tela quanto do modelo. Essa abordagem “amarra” o controlador à interface! Não queremos isso!

PASSO 5:

1-Junte os pedaços de sua aplicação!
2-Isso pode ser feito via programação de uma classe ou através de um deployment através de XML, por exemplo.

Conseqüências:

Alguns problemas que o MVC pode causar:
Se tivermos muitas visões e o modelo for atualizado com muita freqüência, a performance do sistema pode ser abalada.
Se o padrão não for implementado com cuidado, podemos ter casos como o envio de atualizações para visões que estão minimizadas ou fora do campo de visão do usuário.
Ineficiência: uma visão pode ter que fazer inúmeras chamadas ao modelo, dependendo de sua interface.

Fonte: http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/arqu/mvc/mvc.htm
http://rodrigor.com/

1ª Classe essa estar no pacote enquete:

package enquete;

import view.TelaResultado;
import view.TelaResultadoPercentual;
import view.TelaVotacao;
import model.EnqueteSimples;
import controller.TelaVotacaoCtrl;

//http://yuskaaguiar.wikidot.com/mvc-codigo
public class Tela {

private static final long serialVersionUID = 1L;

public static void main(String[] args) {

// Modelo
EnqueteSimples enquete = new EnqueteSimples();

// Controlador da Interface "TelaVotacao"
TelaVotacaoCtrl ctrl = new TelaVotacaoCtrl(enquete);

// Interface que altera o estado do modelo
TelaVotacao votacao = new TelaVotacao(ctrl);

// votacao.setLocation(50, 50);
// Tamanho fixo do programa, sem alteração
votacao.setResizable(false);

// Deixa o programa no meio da tela, centralizado
votacao.setLocationRelativeTo(null);

// Interface que exibe o resultado absoluto da votacao
TelaResultado resultado = new TelaResultado(votacao);
resultado.setLocation(400, 570);

// Interface que exibe o resultado percentual da votacao
TelaResultadoPercentual resultadoPerc = new TelaResultadoPercentual(
votacao);
resultadoPerc.setLocation(660, 570);

// Adicionando as interfaces interessadas na mudança do estado do modelo
enquete.addEnqueteListener(votacao);
enquete.addEnqueteListener(resultado);
enquete.addEnqueteListener(resultadoPerc);

// Povoando o modelo
enquete.addOpcao("Java");
enquete.addOpcao("C#");
enquete.addOpcao("Object Pascal");
enquete.addOpcao("PHP");

// Exibindo as interfaces
votacao.setVisible(true);
resultado.setVisible(true);
resultadoPerc.setVisible(true);

}

}

2ª Classe essa esta no pacote controle :

package controller;

/**
* Historico:
*    24/03/2003: rodrigor - Criação da classe
*/

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import model.EnqueteSimples;

/**
* Controlador da Interface "TelaVotacao". Esta classe recebe os eventos gerados
* pela interface e repassa para o modelo do negócio, alterando o estado da
* enquete.
*
* @see view.TelaVotacao
*
* @author <a href="mailto:rodrigor@dsc.ufcg.edu.br">Rodrigo Rebouças de
*         Almeida</a>
* @since 24/03/2003
**/
public class TelaVotacaoCtrl implements ActionListener {

private EnqueteSimples enquete;

public TelaVotacaoCtrl(EnqueteSimples enquete) {
this.enquete = enquete;
}

/**
* Evento lançado pelo clique nos botoes da TelaVotacao
*
* @see java.awt.event.ActionListener#actionPerformed(ActionEvent)
*/
public void actionPerformed(ActionEvent event) {
enquete.votar(event.getActionCommand());

}

}

3ª Classe essa esta no pacote modelo :

package model;

/**
* Historico:
*    24/03/2003: rodrigor - Criação da classe
*/

/**
* Provê uma implementação padrão para a interface EnqueteListener.
*
* @author <a href="mailto:rodrigor@dsc.ufcg.edu.br">Rodrigo Rebouças de
*         Almeida</a>
* @since 24/03/2003
**/
public class EnqueteAdapter implements EnqueteListener {

// @see enquete.model.EnqueteListener#novaOpcao(EnqueteEvent)
public void novaOpcao(EnqueteEvent event) {
}

// @see enquete.model.EnqueteListener#novoVoto(EnqueteEvent)
public void novoVoto(EnqueteEvent event) {
}

}

4ª Classe essa esta no pacote modelo :

package model;

/**
* Historico:
*    24/03/2003: rodrigor - Criação da classe
*    26/03/2003: rodrigor - Criação do construtor que recebe uma opcao e um source
*                           Criação do método getEnqueteSimples()
*                           Criação do método getOpcao();
*    31/03/2003: rodrigor - Criado o método getVotos();
*                              Excluido o método getEnqueteSimples();
*/

import java.util.EventObject;

/**
* Evento gerado pelo modelo da aplicação (classe EnqueteSimples).
*
* @author <a href="mailto:rodrigor@dsc.ufcg.edu.br">Rodrigo Rebouças de Almeida</a>
* @since 24/03/2003
**/
public class EnqueteEvent extends EventObject {

private static final long serialVersionUID = 1L;
private String opcao = null;
//private int votos = 0;

public EnqueteEvent(EnqueteSimples source){
super(source);
}
public EnqueteEvent(EnqueteSimples source,String opcao){
this(source);
this.opcao = opcao;
}

/**
* Retorna a opção associada ao evento gerado.
* A opção pode ser uma nova opção adicionada à EnqueteSimples
* ou a opção escolhida para adicionar um novo voto.
* @return String opção
*/
public String getOpcao() {
return opcao;
}

/**
* Retorna o numero de votos da opcao
* @return int votos
*/
public int getVotos() {
return ((EnqueteSimples)this.source).getVotos(opcao);
}

/**
* Retorna o total de votos da enquete
* @return int
*/
public int getTotalVotos() {
return ((EnqueteSimples)this.source).getTotalVotos();
}

}

5ª Classe essa esta no pacote modelo :

package model;

/**
* Historico:
*    24/03/2003: rodrigor - Criação da classe
*/

import java.util.EventListener;

/**
* Interface Listener para receber eventos da EnqueteSimples. Toda classe
* interessada em processar os eventos lançados pela Enquete deve implementar
* esta interface e se cadastrar no objeto EnqueteSimples usando o método
* addEnqueteListener().<br>
* O metodo novoVoto() sera chamado quando um novo voto for contabilizado na
* Enquete. O método novaOpcao() será chamado quando uma nova opção for
* adicionada na Enquete.
*
* @author <a href="mailto:rodrigor@dsc.ufcg.edu.br">Rodrigo Rebouças de
*         Almeida</a>
* @since 24/03/2003
**/
public interface EnqueteListener extends EventListener {

/**
* Infocado quando um novo voto é contabilizado na Enquete.
*
* @param event
*            Evento gerado pela Enquete.
*/
public void novoVoto(EnqueteEvent event);

/**
* Invocado quando uma nova opção é adicionada à Enquete.
*
* @param event
*            Evento gerado pela Enquete.
*/
public void novaOpcao(EnqueteEvent event);
}

6ª Classe essa esta no pacote modelo :

package model;

/**
* Historico:
*    24/03/2003: rodrigor - Criação da classe
*    26/03/2003: rodrigor - Alterado o método disparaNovoVoto() para receber uma opção
*                           Alterado o método disparaNovaOpcao() para receber uma opção
*    23/03/2006: renata - Alterado códico para adicionar Generics do Java 5.0
*/

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.swing.JOptionPane;

/**
* Armazena opções a serem votadas, incrementa votos e retorna os totais da
* votação. Esta classe representa o modelo de negócio no exemplo sobre
* Model-View-Controller
*
* @author <a href="mailto:rodrigor@dsc.ufcg.edu.br">Rodrigo Rebouças de
*         Almeida</a>
* @since 24/03/2003
**/
public class EnqueteSimples {

private Map<String, Integer> opcoes;
private List<EnqueteListener> enqueteListeners = new LinkedList<EnqueteListener>();

public EnqueteSimples() {
opcoes = new HashMap<String, Integer>();
}

/**
* Adiciona uma opção para ser votada na enquete
*
* @param opcao
*            nome da opção
*/
public void addOpcao(String opcao) {
opcoes.put(opcao, new Integer(0));
this.disparaNovaOpcao(opcao);
}

/**
* Retorna um iterador de opções disponíveis na enquete
*
* @return Iterator opções disponiveis na enquete
*/
public Set<String> getOpcoes() {
return opcoes.keySet();
}

/**
* Incrementa um voto para opção
*
* @param opcao
*            opção que receberá voto
*/
public void votar(String opcao) {
int votoAtual = (opcoes.get(opcao)).intValue();
opcoes.put(opcao, new Integer(++votoAtual));
this.disparaNovoVoto(opcao);

JOptionPane.showMessageDialog(null,
"Mais um voto para a linguagem de programação: " + opcao,
"Tela De Votação - Enquete", JOptionPane.INFORMATION_MESSAGE);
}

/**
* Retorna a soma dos votos de todas as opções da enquete
*
* @return int soma dos votos de todas as opções da enquete
*/
public int getTotalVotos() {

int total = 0;

for (Integer votos : opcoes.values()) {
total += votos.intValue();
}
return total;
}

/**
* Retorna a quantidade de votos de uma opção individual
*
* @param opcao
*            opção que se quer o voto
* @return int quantidade de votos da opção
*/
public int getVotos(String opcao) {
return (opcoes.get(opcao)).intValue();
}

/**
* Adiciona um EnqueteListener, um objeto interessado em receber eventos
* lançados pela Enquete
*
* @see EnqueteListener
* @param listener
*            objeto interessado em receber eventos
*/
public synchronized void addEnqueteListener(EnqueteListener listener) {
if (enqueteListeners.contains(listener)) {
return;
}
this.enqueteListeners.add(listener);
}

// Informa aos objetos interessados nos eventos lançados pela Enquete que um
// novo voto foi contabilizado.
private synchronized void disparaNovoVoto(String opcao) {
for (EnqueteListener listeners : this.enqueteListeners) {
listeners.novoVoto(new EnqueteEvent(this, opcao));
}
}

// Informa aos objetos interessados nos enventos lançados pela Enquete que
// uma nova opção foi adicionada.
private synchronized void disparaNovaOpcao(String opcao) {
for (EnqueteListener listeners : this.enqueteListeners) {
listeners.novaOpcao(new EnqueteEvent(this, opcao));
}
}

}

7ª Classe essa esta no pacote visão :

package view;

/**
* Historico:
*    24/03/2003: rodrigor - Criação da classe
*    26/03/2003: rodrigor - Alterados os métodos novoVoto() e novaOpcao().
*                           Estes métodos foram adaptados às alterações no objeto
*                           EnqueteEvent.
*    23/03/2006: renata - Alterado códico para adicionar Generics do Java 5.0
*/

import java.awt.*;
import java.util.*;
import javax.swing.JFrame;

import model.EnqueteEvent;
import model.EnqueteListener;

//import enquete.model.EnqueteSimples;

/**
* Exibe o status da votação, com valores absolutos da quantidade de votos.
*
* @author <a href="mailto:rodrigor@dsc.ufcg.edu.br">Rodrigo Rebouças de
*         Almeida</a>
* @since 24/03/2003
**/

// Classe que vai contar o número de votos das opções votadas
// public class TelaResultado extends Window implements EnqueteListener {
public class TelaResultado extends JFrame implements EnqueteListener {

private static final long serialVersionUID = 1L;
private Map<String, Label> labels = new HashMap<String, Label>();

public TelaResultado(JFrame parent) {

super("Votação");
//super(parent);

this.setSize(250, 120);
// Grid com qualquer numero
// de linhas e uma coluna
this.setLayout(new GridLayout(0, 2));
this.add(new Label("Votos:"));
this.add(new Label());
}

// @see enquete.model.EnqueteListener#novaOpcao(EnqueteEvent)
public void novaOpcao(EnqueteEvent event) {

String opcao = event.getOpcao();

Label label;
Label votos;

if (!labels.containsKey(opcao)) {
label = new Label(opcao + " : ");
votos = new Label("" + event.getVotos());
votos.setForeground(Color.BLUE);
labels.put(opcao, votos);
this.add(label);
this.add(votos);
}
}

// @see enquete.model.EnqueteListener#novoVoto(EnqueteEvent)
public void novoVoto(EnqueteEvent event) {

String opcao = event.getOpcao();

Label votos;
votos = labels.get(opcao);
votos.setFont(new Font("Ariel", Font.BOLD, 14));
votos.setText("" + event.getVotos());

}

}

8ª Classe essa esta no pacote visão :

package view;

/**
* Historico:
*    24/03/2003: rodrigor - Criação da classe
*    26/03/2003: rodrigor - Alterados os métodos novoVoto() e novaOpcao().
*                           Estes métodos foram adaptados às alterações no objeto
*                           EnqueteEvent.
*    23/03/2006: renata - Alterado códico para adicionar Generics do Java 5.0
*/

import java.awt.*;
import java.util.*;
import javax.swing.JFrame;

import model.EnqueteEvent;
import model.EnqueteListener;

//import enquete.model.EnqueteSimples;

/**
* Janela que exibe o resultado percentual da votação on-line. Esta tela é
* atualizada a cada novo voto a uma opção da enquete.
*
* @author <a href="mailto:rodrigor@dsc.ufcg.edu.br">Rodrigo Rebouças de
*         Almeida</a>
* @since 24/03/2003
*/
// public class TelaResultadoPercentual extends Window implements
// EnqueteListener {
public class TelaResultadoPercentual extends JFrame implements EnqueteListener {

private static final long serialVersionUID = 1L;
private Map<String, Label> labels = new HashMap<String, Label>();

public TelaResultadoPercentual(JFrame parent) {

super("Porcentagem");
//super(parent);

this.setSize(250, 120);
// Grid com qualquer numero
// de linhas e uma coluna
this.setLayout(new GridLayout(0, 2));
this.add(new Label("Percentual:"));
this.add(new Label());
}

// @see enquete.model.EnqueteListener#novaOpcao(EnqueteEvent)
public void novaOpcao(EnqueteEvent event) {

String opcao = event.getOpcao();

Label porcentagem = null;
Label porcentagemVotos = null;

if (!labels.containsKey(opcao)) {
// label = new Label(opcao + " - ");
porcentagem = new Label();
porcentagem.setFont(new Font("Ariel", Font.BOLD, 14));
porcentagemVotos = new Label("" + event.getVotos() + " %");
porcentagemVotos.setForeground(Color.RED);
// votos = new Label(event.getVotos() + "%");
labels.put(opcao, porcentagemVotos);
this.add(porcentagem);
this.add(porcentagemVotos);
}
}

// @see enquete.model.EnqueteListener#novoVoto(EnqueteEvent)
public void novoVoto(EnqueteEvent event) {

String opcao = event.getOpcao();

Label porcentagemVotos;
porcentagemVotos = labels.get(opcao);
porcentagemVotos.setFont(new Font("Ariel", Font.BOLD, 14));
porcentagemVotos.setText(""
+ (event.getVotos() * 100 / event.getTotalVotos()) + " %");
}

}

9ª Classe essa esta no pacote visão :

package view;

/**
* Historico:
*    24/03/2003: rodrigor - Criação da classe
*    25/03/2003: rodrigor - Alteração do construtor: Agora recebe o controller
*    26/03/2003: rodrigor - Alterado o método novaOpcao()
*                           Este método foi adaptado às alterações no objeto
*                           EnqueteEvent.
*    31/03/2003: rodrigor - Alterei o construtor para receber um ActionListener
*    23/03/2006: renata - Alterado códico para adicionar Generics do Java 5.0
*/

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.JFrame;

import model.*;

/**
* Esta janela é usada para efetivar o voto em alguma das opções disponíveis na
* enquete.
*
* @author <a href="mailto:rodrigor@dsc.ufcg.edu.br">Rodrigo Rebouças de
*         Almeida</a>
* @since 24/03/2003
**/
public class TelaVotacao extends JFrame implements EnqueteListener {

private static final long serialVersionUID = 1L;

private Collection<String> botoes = new ArrayList<String>();
private ActionListener controller;

public TelaVotacao(ActionListener controller) {

super("Tela De Votação - Enquete");

this.setSize(600, 400);

// Grid com qualquer numero
// de linhas e uma coluna
this.setLayout(new GridLayout(0, 1));

this.controller = controller;

this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
e.getWindow().setVisible(false);
System.exit(0);
}
});
}

// @see enquete.model.EnqueteListener#novaOpcao(EnqueteEvent)
public void novaOpcao(EnqueteEvent event) {

String opcao = event.getOpcao();
Button botao;

if (!botoes.contains(opcao)) {
botoes.add(opcao);
botao = new Button(opcao);
botao.setActionCommand(opcao);
botao.addActionListener(controller);
//Transforma o mouse em mão
botao.setCursor(new Cursor(Cursor.HAND_CURSOR));
//Fonte dos botões
botao.setFont(new Font("Ariel", Font.BOLD, 28));
this.add(botao);
}

}

// @see enquete.model.EnqueteListener#novoVoto(EnqueteEvent)
public void novoVoto(EnqueteEvent event) {
// Nothing to do
}

}

Aqui vai o link para baixar o aplicativo Enquete.jar 10 KB.

http://www.4shared.com/file/_ijsV7fl/Enquete.html