Clock Display

Class NumberDisplay

 /**  
 * The NumberDisplay class represents a digital number  
 * display that can hold values from zero to a given limit.  
 * The limit can be specified when creating the display. The  
 * values range from zero (inclusive) to limit-1. If used, for  
 * example, for the seconds on a digital clock, the limit  
 * would be 60, resulting in display values from 0 to 59.  
 * When incremented, the display automatically rolls over to  
 * zero when reaching the limit.  
 *  
 * @author Michael Kölling and David J. Barnes  
 * @version 2011.07.31  
 */  
 public class NumberDisplay  
 {  
 private int limit;  
 private int value;  
 /**  
 * Constructor for objects of class NumberDisplay  
 */  
 public NumberDisplay(int rollOverLimit)  
 {  
 limit = rollOverLimit;  
 value = 0;  
 }  
 /**  
 * Return the current value.  
 */  
 public int getValue()  
 {  
 return value;  
 }  
 /**  
 * Set the value of the display to the new specified  
 * value. If the new value is less than zero or over the  
 * limit, do nothing.  
 */  
 public void setValue(int replacementValue)  
 {  
 if((replacementValue >= 0) &&  
 (replacementValue < limit)) {  
 value = replacementValue;  
 }  
 }  
 /**  
 * Return the display value (that is, the current value  
 * as a two-digit String. If the value is less than ten,  
 * it will be padded with a leading zero).  
 */  
 public String getDisplayValue()  
 {  
 if(value < 10) {  
 return "0" + value;  
 }  
 else {  
 return "" + value;  
 }  
 }  
 /**  
 * Increment the display value by one, rolling over to zero if  
 * the limit is reached.  
 */  
 public void increment()  
 {  
 value = (value + 1) % limit;  
 }  
 }  

Class ClockDisplay

 /**  
 * The ClockDisplay class implements a digital clock display  
 * for a European-style 24-hour clock. The clock shows hours  
 * and minutes.  
 * The range of the clock is 00:00 (midnight) to 23:59 (one  
 * minute before midnight).  
 *  
 * The clock display receives "ticks" (via the timeTick  
 * method) every minute and reacts by incrementing the  
 * display. This is done in the usual clock fashion: the hour  
 * increments when the minutes roll over to zero.  
 *  
 * @author Michael Kölling and David J. Barnes  
 * @version 2011.07.31  
 */  
 public class ClockDisplay  
 {  
 private NumberDisplay hours;  
 private NumberDisplay minutes;  
 private String displayString; // simulates the actual display  
 /**  
 * Constructor for ClockDisplay objects. This constructor  
 * creates a new clock set at 00:00.  
 */  
 public ClockDisplay()  
 {  
 hours = new NumberDisplay(24);  
 minutes = new NumberDisplay(60);  
 updateDisplay();  
 }  
 /**  
 * Constructor for ClockDisplay objects. This constructor  
 * creates a new clock set at the time specified by the  
 * parameters.  
 */  
 public ClockDisplay(int hour, int minute)  
 {  
 hours = new NumberDisplay(24);  
 minutes = new NumberDisplay(60);  
 setTime(hour, minute);  
 }  
 /**  
 * This method should get called once every minute - it  
 * makes the clock display go one minute forward.  
 */  
 public void timeTick()  
 {  
 minutes.increment();  
 if(minutes.getValue() == 0) { // it just rolled over!  
 hours.increment();  
 }  
 updateDisplay();  
 }  
 /**  
 * Set the time of the display to the specified hour and  
 * minute.  
 */  
 public void setTime(int hour, int minute)  
 {  
 hours.setValue(hour);  
 minutes.setValue(minute);  
 updateDisplay();  
 }  
 /**  
 * Return the current time of this display in the format  
 * HH:MM.  
 */  
 public String getTime()  
 {  
 return displayString;  
 }  
 /**  
 * Update the internal string that represents the  
 * display.  
 */  
 private void updateDisplay()  
 {  
 displayString = hours.getDisplayValue() + ":" +  
 minutes.getDisplayValue();  
 }  
 }  

Class ClockGUI

 import java.awt.*;  
 import java.awt.event.*;  
 import javax.swing.*;  
 import javax.swing.border.*;  
 public class ClockGUI  
 {  
 private JFrame frame;  
 private JLabel label;  
 private ClockDisplay clock;  
 private boolean clockOn = false;  
 private TimerThread timerThread;  
 public void Clock()  
 {  
 makeFrame();  
 clock = new ClockDisplay();  
 }  
 private void start()  
 {  
 clockOn = true;  
 timerThread = new TimerThread();  
 timerThread.start();  
 }  
 private void stop()  
 {  
 clockOn = false;  
 }  
 private void step()  
 {  
 clock.timeTick();  
 label.setText(clock.getTime());  
 }  
 private void quit()  
 {  
 System.exit(0);  
 }  
 private void makeFrame()  
 {  
 frame = new JFrame("Clock");  
 JPanel contentPane = (JPanel)frame.getContentPane();  
 contentPane.setBorder(new EmptyBorder(1,60,1,60));  
 makeMenuBar(frame);  
 contentPane.setLayout(new BorderLayout(12,12));  
 label = new JLabel("00:00", SwingConstants.CENTER);  
 Font displayFont = label.getFont().deriveFont(96.0f);  
 label.setFont(displayFont);  
 contentPane.add(label, BorderLayout.CENTER);  
 JPanel toolbar = new JPanel();  
 toolbar.setLayout(new GridLayout(1,0));  
 JButton startButton = new JButton("Start");  
 startButton.addActionListener(e->start());  
 toolbar.add(startButton);  
 JButton stopButton = new JButton("Stop");  
 stopButton.addActionListener(e->stop());  
 toolbar.add(stopButton);  
 JButton stepButton = new JButton("Step");  
 stepButton.addActionListener(e->step());  
 toolbar.add(stepButton);  
 JPanel flow = new JPanel();  
 flow.add(toolbar);  
 contentPane.add(flow, BorderLayout.SOUTH);  
 frame.pack();  
 Dimension d = Toolkit.getDefaultToolkit().getScreenSize();  
 frame.setLocation(d.width/2 - frame.getWidth()/2, d.height/2 - frame.getHeight()/2);  
 frame.setVisible(true);  
 }  
 private void makeMenuBar(JFrame frame)  
 {  
 final int SHORTCUT_MASK =  
 Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();  
 JMenuBar menubar = new JMenuBar();  
 frame.setJMenuBar(menubar);  
 JMenu menu;  
 JMenuItem item;  
 menu = new JMenu("File");  
 menubar.add(menu);  
 item = new JMenuItem("Quit");  
 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q,SHORTCUT_MASK));  
 item.addActionListener(e->quit());  
 menu.add(item);  
 }  
 class TimerThread extends Thread  
 {  
 public void run()  
 {  
 while(clockOn)  
 {  
 step();  
 pause();  
 }  
 }  
 private void pause()  
 {  
 try  
 {  
 Thread.sleep(900);  
 }  
 catch(InterruptedException exc)  
 {  
 }  
 }  
 }  
 }