Você está aqui: Java ::: Java Swing - Jogos e Aplicações Úteis ::: Animação, Animações, Técnicas de Animação

Como criar um relógio analógico em Java Swing - Código completo com variáveis e comentários em português

Quantidade de visualizações: 1490 vezes
Nesta dica mostrarei um código para a criação de um relógio analógico completo em Python, com comentários detalhados e fácil de entender. Veja a imagem:



Por simplicidade, eu mantive a mesma cor para todos os elementos da animação e deixei somente o básico mesmo, para que você possa se concentrar nas partes mais importantes.

Neste código você aprenderá como definir o tamanho, título e cor de fundo para uma janela do Java Swing. Aprenderá também como criar um Timer em Java e usá-lo para controlar o tempo de atualização dos elementos de uma animação.

Por fim, o código mostra como calcular o ângulo dos ponteiros das horas, minutos e segundos e efetuar o desenho das retas saindo do centro do círculo. Você sabia, por exemplo, que o ângulo de 45 graus corresponde exatamente à hora 1:30hs?

Em vários exemplos de relógios analógicos na internet, o ponteiro das horas fica preso à uma determinada hora, aguardando o ponteiro dos segundos completar um giro completo. No código que apresento aqui, eu obtive a hora atual como um decimal, o que faz com que o ponteiro das horas mostre a posição real das hora, como um relógio analógico do mundo real.

Para estudantes de matemática, engenharia e física, este código é uma boa aplicação da técnica de se converter coordenadas polares para coordenadas cartesianas.

Eis o código completo para o relógio analógico em Java Swing. Boa diversão.

Código para a classe RelogioDigital.java:

package estudos;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.time.LocalTime;
import javax.swing.JPanel;
import javax.swing.Timer;

class RelogioDigital extends JPanel {
  // algumas variáveis de configuração
  int largura_painel = 600;
  int altura_painel = 400;
  int raio = 150; 
  int x_inicial = 300;
  int y_inicial = 200;
  int distancia_aro = 20;
  
  // construtor da classe
  public RelogioDigital(){
    // definimos o tamanho do JPanel
    this.setPreferredSize(new Dimension(largura_painel, altura_painel));
    // definimos a cor de fundo
    this.setBackground(Color.WHITE);
 
    // iniciamos o Timer com intervalo de 1 segundo
    new Timer(1000, (ActionEvent e) -> {
      // redesenha o painel
      this.repaint();
    }).start();
  }
  
  @Override
  public void paintComponent(Graphics gg) {
    super.paintComponent(gg);
    // vamos obter o objeto Graphics2D
    Graphics2D g = (Graphics2D) gg;
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
      RenderingHints.VALUE_ANTIALIAS_ON);
    
    // vamos definir a fonte para desenhar os números do relógio
    g.setFont(new Font("TimesRoman", Font.PLAIN, 20));
    
    // desenha o círculo do relógio
    g.drawOval(x_inicial - raio, y_inicial - raio, raio * 2, raio * 2);
    // desenha o círculo interno do relógio
    g.fillOval(x_inicial - 4, y_inicial - 4, 8, 8);
    
    // vamos desenhar os números do relório (1-12)
    for(int i = 1; i < 13; i++){
      // calcula o ângulo dessa hora
      double angulo = Math.toRadians((i * (360 / 12)) - 90);
      // agora convertemos o ângulo e o raio para coordenadas cartesianas
      int x = (int)(Math.cos(angulo) * (raio - distancia_aro)) + x_inicial - 5;
      if(i > 9){
        x = (int)(Math.cos(angulo) * (raio - distancia_aro)) + x_inicial - 10;
      }
      int y = (int)(Math.sin(angulo) * (raio - distancia_aro)) + y_inicial + 5;
      g.drawString(Integer.toString(i), x, y);
    }
    
    // agora vamos obter as horas, minutos e segundos
    LocalTime time = LocalTime.now();
    double horas = time.getHour();
    int minutos = time.getMinute();
    int segundos = time.getSecond();
    // ajustamos as horas para tratar a hora decimal (com frações de horas)
    horas = horas + (minutos * (1 / 60)) + (segundos * (1 / 3600));
    
    // vamos desenhar o ponteiro das horas
    double angulo_horas = Math.toRadians((horas * (360 / 12)) - 90);
    // agora convertemos o ângulo e o raio para coordenadas cartesianas
    int x = (int)(Math.cos(angulo_horas) * (raio - 75)) + x_inicial - 5;
    int y = (int)(Math.sin(angulo_horas) * (raio - 75)) + y_inicial + 5;
    g.drawLine(x_inicial, y_inicial, x, y);
    
    // desenha o ponteiro dos minutos
    double angulo_minutos = Math.toRadians((minutos * (360 / 60)) - 90);
    // agora convertemos o ângulo e o raio para coordenadas cartesianas
    x = (int)(Math.cos(angulo_minutos) * (raio - 45)) + x_inicial - 5;
    y = (int)(Math.sin(angulo_minutos) * (raio - 45)) + y_inicial + 5;
    g.drawLine(x_inicial, y_inicial, x, y);
    
    // desenha o ponteiro dos segundos
    double angulo_segundos = Math.toRadians((segundos * (360 / 60)) - 90);
    // agora convertemos o ângulo e o raio para coordenadas cartesianas
    x = (int)(Math.cos(angulo_segundos) * (raio - 35)) + x_inicial - 5;
    y = (int)(Math.sin(angulo_segundos) * (raio - 35)) + y_inicial + 5;
    g.drawLine(x_inicial, y_inicial, x, y);
  }
}

Código para a classe principal Estudos.java:

package estudos;

import java.awt.BorderLayout;
import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;

public class Estudos extends JFrame{
  // construtor da classe
  public Estudos(){
    super("Relógio Analógica em Java Swing");
     
    Container c = getContentPane();
    c.setLayout(new BorderLayout());
    
    // vamos adicionar o JPanel na tela principal
    RelogioDigital relogio = new RelogioDigital();
    this.add(relogio, BorderLayout.CENTER);
    this.setResizable(false);
    this.pack();
    
    // vamos centralizar a janela na tela
    this.setLocationRelativeTo(null);
    // mostra a janela principal 
    this.setVisible(true);
  }
  
  public static void main(String args[]){
    SwingUtilities.invokeLater(() -> {
      Estudos app = new Estudos();
      app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }); 
  }
}


Link para compartilhar na Internet ou com seus amigos:

Desafios, Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

E-Books em PDF

E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 20 usuários muito felizes estudando em nosso site.