// JavaProject AnalogClock
Die aktuelle Uhrzeit kann mittels Zifferblatt und „analogen“
Zeigern abgelesen werden. Unter Benutzung des dreiparametrigen
Konstruktors der Klasse BasicStroke werden die Werte
festgelegt, welche die Linienstärke (i) bzw. das Aussehen der
Linienenden (cr und jr) der drei Uhrzeiger sowie der Indizes
bestimmen. Diese Werte werden in einem ArrayList-Objekt gespeichert, das
durch strokes referenziert wird.
Der Aufruf canvas.renewSize();
innerhalb der Methode run ist wichtig für den Fall,
dass bei laufender Uhr die Größe des Programmfensters geändert werden
sollte.
Der Aufruf g2d.dispose();
// AnalogClock.java
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.BasicStroke;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Image;
import java.awt.Toolkit;
import java.util.ArrayList;
class Canvas extends JPanel {
private static final long serialVersionUID = 0L;
int width, height;
int xm, ym;
private Timer t;
Color colbgr = new Color(238,238,238);
Color colhrs = new Color(80,80,80);
Color colmin = new Color(80,80,80);
Color colsec = new Color(150,20,20);
Color colind = new Color(120,120,120);
int cr = BasicStroke.CAP_ROUND;
int jr = BasicStroke.JOIN_ROUND;
ArrayList<BasicStroke> strokes; //
ArrayList
public Canvas() {
strokes = new ArrayList<>();
for (int i=0; i<6; i++) strokes.add(new BasicStroke(i, cr, jr));
t = new Timer();
}
double cos(double angle) {
return Math.cos(Math.toRadians(angle));
}
double sin(double angle) {
return Math.sin(Math.toRadians(angle));
}
private void defineRendering(Graphics2D g) {
RenderingHints rh;
rh = new RenderingHints (
RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON
);
g.setRenderingHints(rh);
}
protected void renewSize() {
width = getBounds().width;
height = getBounds().height;
xm = (int) (width/2);
ym = (int) (height/2);
}
private void drawHourIndices(Graphics2D g) {
int x0, x1, y0, y1;
double angle;
g.setColor(colind);
g.setStroke(strokes.get(3));
for (int i=0; i<360; i+= 30) {
angle = i;
x0 = (int) (xm + 0.70*xm*cos(angle));
y0 = (int) (ym + 0.70*ym*sin(angle));
x1 = (int) (xm + 0.85*xm*cos(angle));
y1 = (int) (ym + 0.85*ym*sin(angle));
g.drawLine(x0, y0, x1, y1);
}
}
private void drawMinuteIndices(Graphics2D g) {
int x0, x1, y0, y1;
double angle;
g.setColor(colind);
g.setStroke(strokes.get(2));
for (int i=0; i<360; i+= 6) {
angle = i;
x0 = (int) (xm + 0.80*xm*cos(angle));
y0 = (int) (ym + 0.80*ym*sin(angle));
x1 = (int) (xm + 0.85*xm*cos(angle));
y1 = (int) (ym + 0.85*ym*sin(angle));
if (i%5 != 0) g.drawLine(x0, y0, x1, y1);
// arithmetische Operatoren
}
}
private void drawHand(Graphics2D g, Color c, int s, double angle, double d) {
g.setColor(c);
g.setStroke(strokes.get(s));
int x = (int)(xm + d*xm*cos(angle));
int y = (int)(ym + d*ym*sin(angle));
g.drawLine(xm, ym, x, y);
}
private void drawHourHand(Graphics2D g) {
double angle = 30*t.hrs - 90 + (t.min + t.sec/60.0)/2.0;
drawHand(g, colhrs, 5, angle, 0.5);
}
private void drawMinuteHand(Graphics2D g) {
double angle = 6*t.min - 90;
drawHand(g, colmin, 2, angle, 0.785);
}
private void drawSecondHand(Graphics2D g) {
double angle = 6*t.sec - 90;
drawHand(g, colsec, 1, angle, 0.785);
g.fillOval(xm-6, ym-6, 12, 12);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g;
defineRendering(g2d);
g2d.setBackground(colbgr);
drawHourIndices(g2d);
drawMinuteIndices(g2d);
drawHourHand(g2d);
drawMinuteHand(g2d);
drawSecondHand(g2d);
g2d.dispose();
}
}
class Frame extends JFrame {
private static final long serialVersionUID = 0L;
Image icon;
public Frame() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(349, 301);
setLocationRelativeTo(null);
setTitle(" ");
icon = Toolkit.getDefaultToolkit().getImage("dh.png");
setIconImage(icon);
}
}
class Clockwork implements Runnable {
Frame frame;
Canvas canvas;
Thread thread;
public Clockwork() {
frame = new Frame();
canvas = new Canvas();
frame.add(canvas);
frame.setVisible(true);
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
while (true) {
canvas.renewSize();
canvas.repaint();
try {
Thread.sleep(10);
}
catch (InterruptedException e) { }
}
}
}
public class AnalogClock {
public static void main(String[] args) {
new Clockwork();
}
}
// Timer.java
import java.util.Calendar;
import java.util.GregorianCalendar;
public class Timer implements Runnable {
GregorianCalendar calendar;
int hrs, min, sec, msc;
Thread thread;
@Override
public void run() {
while (true) {
getActualTime();
try {
Thread.sleep(1000);
}
catch (InterruptedException e) { }
}
}
public void getActualTime() {
calendar = new GregorianCalendar();
hrs = calendar.get(Calendar.HOUR_OF_DAY);
min = calendar.get(Calendar.MINUTE);
msc = calendar.get(Calendar.MILLISECOND);
sec = (int) Math.round(calendar.get(Calendar.SECOND)+msc/1000.0);
}
public Timer() {
thread = new Thread(this);
thread.start();
}
}
