TUGAS PBO B (Tugas Rumah 4)

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