Membuat Jam
1. Source Code Clock
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
/**
* A very simple GUI (graphical user interface) for the clock
* display.
* In this implementation, time runs at about 3 minutes per second,
* so that testing the display is a little quicker
*
* @author (Christine Amelia)
* @version (6-01/10/2018)
*/
public class Clock
{
private JFrame frame;
private JLabel label;
private ClockDisplay clock;
private boolean clockRunning = false;
private TimerThread timerThread;
/**
* Constructor for objects of class Clock
*/
public Clock()
{
makeFrame();
clock = new ClockDisplay();
}
public void start()
{
clockRunning = true;
timerThread = new TimerThread();
timerThread.start();
}
private void stop()
{
clockRunning = false;
}
private void step()
{
clock.timeTick();
label.setText(clock.getTime());
}
/**
* 'About' function:show the 'about' box.
*/
private void showAbout()
{
JOptionPane.showMessageDialog(frame,
"Clock Version 1.0\n"+
"A simple interface for the 'Objects First' clock display project",
"About Clock",
JOptionPane.INFORMATION_MESSAGE);
}
/**
* Quit function: quit the application.
*/
private void quit()
{
System.exit(0);
}
/**
* Create the Swing frame and its content.
*/
private void makeFrame()
{
frame = new JFrame("Clock");
JPanel contentPane = (JPanel)frame.getContentPane();
contentPane.setBorder(new EmptyBorder(1, 60, 1, 60));
makeMenuBar(frame);
//Specify the layout manager with nice spacing
contentPane.setLayout(new BorderLayout(12,12));
//Create the image pane in the center
label = new JLabel("00:00", SwingConstants.CENTER);
Font displayFont = label.getFont().deriveFont(96.0f);
label.setFont(displayFont);
//imagePanel.setBorder(new EtchedBorder());
contentPane.add(label,BorderLayout.CENTER);
//Create the toolbar with the buttons
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);
//Add toolbar into panel with flow layout for spacing
JPanel flow = new JPanel();
flow.add(toolbar);
contentPane.add(flow, BorderLayout.SOUTH);
//building is done - arrange the components
frame.pack();
//place the frame at the center of the screen and show
Dimension d=Toolkit.getDefaultToolkit().getScreenSize();
frame.setLocation(d.width/2 - frame.getWidth()/2, d.height/2 - frame.getHeight()/2);
frame.setVisible(true);
}
/**
* Create the main frame's menu bar
*
* @paramframe The frame that the menu bar should be added to.
*/
private void makeMenuBar(JFrame frame)
{
final int SHORTCUT_MASK = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
JMenuBar menubar = new JMenuBar();
frame.setJMenuBar(menubar);
JMenu menu;
JMenuItem item;
//create the File menu
menu = new JMenu("File");
menubar.add(menu);
item = new JMenuItem("Anout Clock...");
item.addActionListener(e->showAbout());
menu.add(item);
menu.addSeparator();
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 (clockRunning)
{
step();
pause();
}
}
private void pause()
{
try
{
Thread.sleep(300); //pause for 300 milliseconds
}
catch(InterruptedException exc)
{
}
}
}
}
2.Source Code ClockDisplay
/**
* The ClockDisplay class implements a digital clock display for
* s European-style 24 hour clock, The clock show hours and
* minutes. The range of the dock is 00:00 (midnight) to 23:59
* (one minute before midnight).
*
* The clock display recives "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 (Christine Amelia)
* @version (6-01/10/2018)
*/
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();
}
/**
* Constructur 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);
setTimer(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 setTimer(int hour, int minute)
{
hours.setValue(hour);
minutes.setValue(minute);
updateDisplay();
}
/**
* Return the current time if this display in the format
* HH:MM.
*/
public String getTime()
{
return displayString;
}
/**
* Update teh internal string that represents the display.
*/
private void updateDisplay()
{
displayString = hours.getDisplayValue()+ ":" +minutes.getDisplayValue();
}
}
3.Source Code 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 (Christine Amelia)
* @version (6-01/10/2018)
*/
public class NumberDisplay
{
private int limit;
private int value;
/**
* Constructor for objects of class NumberDisplay
* Set the limit at which the display rolls over.
*/
public NumberDisplay(int rollOverLimit)
{
limit = rollOverLimit;
value = 0;
}
/**
* Return the current value.
*/
public int getValue()
{
return value;
}
/**
* 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;
}
}
/**
* Set the value of the display to the 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;
}
}
/**
* Increment the display value by one, rolling over to zero
* if the limit is reached.
*/
public void increment()
{
value = (value+1)%limit;
}
}
