dh-Materialien
Java Projekte
// JavaProject AnalogClock
AnalogClock

AnalogClock.java   Timer.java

// 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);
        }
    }

    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();
    }
}

Download AnalogClock