Your task is to modify the worked-example of ABC Wash Machine and print out the above statistical
Question:
public class Clock
{
private int hr; //store hours
private int min; //store minutes
private int sec; //store seconds
//Constructor with parameters, to set the time
//The time is set according to the parameters
//Postcondition: hr = hours; min = minutes; sec = seconds
public Clock(int hours, int minutes, int seconds)
{
setTime(hours, minutes, seconds);
}
//Default constructor
//Postcondition: hr = 0; min = 0; sec = 0
public Clock()
{
setTime(0, 0, 0);
}
//Method to set the time
//The time is set according to the parameters
//Postconditions: hr = hours; min = minutes; sec = seconds
public void setTime(int hours, int minutes, int seconds)
{
if(0 <= hours && hours < 24)
hr = hours;
else
hr = 0;
if(0 <= minutes && minutes < 60)
min = minutes;
else
min = 0;
if(0 <= seconds && seconds < 60)
sec = seconds;
else
sec = 0;
}
public void getTime (int hours, int minutes, int seconds) {
hours = hr;
minutes = min;
seconds = sec;
}
//Method to return the hours
//Postconditions: the value of hr is returned
public int getHours()
{
return hr;
}
//Method to return the minutes
//Postconditions: the value of min is returned
public int getMinutes()
{
return min;
}
//Method to return the seconds
//Postconditions: the value of sec is returned
public int getSeconds()
{
return sec;
}
//Method to print the time
//Postconditions: Time is printed in the form hh:mm:ss
public void printTime()
{
if(hr < 10)
System.out.print("0");
System.out.print(hr + ":");
if(min < 10)
System.out.print("0");
System.out.print(min + ":");
if(sec < 10)
System.out.print("0");
System.out.print(sec);
}
//Method to increment the time by one second
//Postconditions: The time is incremented by one second
//If the before-increment time is 23:59:59, the time
//is reset to 00:00:00
public void incrementSeconds()
{
sec++;
if(sec > 59)
{
sec = 0;
incrementMinutes(); //increment minutes
}
}
//Function to increment the time by one minute
//Postconditions: The time is incremented by one minute
//If the before-increment time is 23:59:53, the time
//is reset to 00:00:53
public void incrementMinutes()
{
min++;
if(min > 59)
{
min = 0;
incrementHours(); //increment hours
}
}
public void addTimeMinute(int minutes) { //new
for (int i=0; i
incrementMinutes();
}
//Method to increment the time by one hour
//Postconditions: The time is incremented by one hour
//If the before-increment time is 23:45:53, the time
//is reset to 00:45:53
public void incrementHours()
{
hr++;
if(hr > 23)
hr = 0;
}
//Function to compare the two times
//Postconditions: Returns true if this time is equal to
// otherTime; otherwise returns false
public boolean equals(Clock otherClock)
{
return(hr == otherClock.hr
&& min == otherClock.min
&& sec == otherClock.sec);
}
//Method to copy time
//Postcondition: The data members of otherTime are copied
// into the correspoding data members of
// this time.
// hr = otherTime.hr; min = otherTime.min;
// sec = otherTime.sec;
public void makeCopy(Clock otherClock)
{
hr = otherClock.hr;
min = otherClock.min;
sec = otherClock.sec;
}
//Method to return a copy of time
//Postcondition: A copy of the object is created
// and a reference of the copy is returned
public Clock getCopy()
{
Clock temp = new Clock();
temp.hr = hr;
temp.min = min;
temp.sec = sec;
return temp;
}
public String toString()
{
String str = "";
if(hr < 10)
str = "0";
str = str + hr + ":";
if(min < 10)
str = str + "0" ;
str = str + min + ":";
if(sec < 10)
str = str + "0";
str = str + sec;
return str;
}
public int durationSec (Clock stopA) { //new
int durSec, durMin, durHour;
boolean borrowHour=false, borrowMin=false;
Clock stop;
stop=stopA;
if (stop.sec >= sec)durSec=stop.sec-sec;
else {
durSec=((stop.sec+60) - sec);
borrowMin=true;
}
if (borrowMin)
stop.min-=1;
if (stop.min >= min)durMin=(stop.min-min);
else {
durMin=((stop.min+60) - min);
borrowHour=true;
}
if (borrowHour)
stop.hr-=1;
durHour=(stop.hr - hr);
return (durHour*60)+durMin; //+(int)(durSec/60.0);
}
public boolean equalTime(Clock otherClock) {
return (hr == otherClock.hr && min == otherClock.min && sec == otherClock.sec);
}
public boolean lessThan (Clock otherClock) { //new
if (hr < otherClock.hr) return true;
else if (hr == otherClock.hr) {
if (min < otherClock.min) return true;
else if (min == otherClock.min) {
if (sec == otherClock.sec) return true;
}
}
return false;
}
}
----------------------------------------------------------------------------------------------------------------------------------------------------------
public class Customer {
Clock time = new Clock ();
int serviceType;
public Customer (Clock tm, int sType)
{
time.setTime(tm.getHours(),tm.getMinutes(),tm.getSeconds());
serviceType = sType;
}
public Customer()
{
time.setTime(0,0,0);
serviceType =0;
}
public int getSeviceType()
{
int temp;
temp=this.serviceType;
return temp;
}
public int setSeviceType()
{
int temp;
temp=this.serviceType;
return temp;
}
public Customer CopyCustomer()
{
Customer temp = new Customer();
//temp.time.getTime(this.time.getHours(), this.time.getMinutes(), this.time.getSeconds());
temp.time = time.getCopy();
temp.serviceType= getSeviceType();
temp.toString();
return temp;
}
public String toString()
{
String str;
//System.out.print("Customer arrival time: " );
str = this.time.toString();
str = str + " (" + serviceType + ") ";
return str;
}
}
-----------------------------------------------------------------------------------------------------------------------------------------------
import java.util.*;
public class DEFWashMachine {
//write your codes here
}
----------------------------------------------------------------------------------------------------------------------------------------------------
/******************************************************************************
* Compilation: javac Queue.java
*
* The Queue class represents a first-in-first-out (FIFO) queue of generic items.
* It supports the usual enqueue and dequeue operations, along with methods for
* peeking at the top item, testing if the queue is empty, getting the number of
* items in the queue, and iterating over the items in FIFO order.
*
* For additional documentation, see http://introcs.cs.princeton.edu/43stack of
* Introduction to Programming in Java: An Interdisciplinary Approach
*by Robert Sedgewick and Kevin Wayne.
*
* @author Robert Sedgewick
* @author Kevin Wayne
*
******************************************************************************/
import java.util.Iterator;
import java.util.NoSuchElementException;
public class Queue implements Iterable {
private int n; // number of elements on queue
private Node first; // beginning of queue
private Node last; // end of queue
// helper linked list class
private class Node {
private Item item;
private Node next;
}
/**
* Initializes an empty queue.
*/
public Queue() {
first = null;
last = null;
n = 0;
}
/**
* Returns true if this queue is empty.
*
* @return {@code true} if this queue is empty; {@code false} otherwise
*/
public boolean isEmpty() {
return first == null;
}
/**
* Returns the number of items in this queue.
*
* @return the number of items in this queue
*/
public int size() {
return n;
}
/**
* Returns the number of items in this queue.
*
* @return the number of items in this queue
*/
public int length() {
return n;
}
/**
* Returns the item least recently added to this queue.
*
* @return the item least recently added to this queue
* @throws NoSuchElementException if this queue is empty
*/
public Item peek() {
if (isEmpty()) throw new NoSuchElementException("Queue underflow");
return first.item;
}
/**
* Add the item to the queue.
*/
public void enqueue(Item item) {
Node oldlast = last;
last = new Node();
last.item = item;
last.next = null;
if (isEmpty()) first = last;
else oldlast.next = last;
n++;
}
/**
* Removes and returns the item on this queue that was least recently added.
*
* @return the item on this queue that was least recently added
* @throws NoSuchElementException if this queue is empty
*/
public Item dequeue() {
if (isEmpty()) throw new NoSuchElementException("Queue underflow");
Item item = first.item;
first = first.next;
n--;
if (isEmpty()) last = null; // to avoid loitering
return item;
}
/**
* Returns a string representation of this queue.
*
* @return the sequence of items in FIFO order, separated by spaces
*/
public String toString() {
StringBuilder s = new StringBuilder();
for (Item item : this) {
s.append(item);
s.append(' ');
}
return s.toString();
}
/**
* Returns an iterator that iterates over the items in this queue in FIFO order.
*
* @return an iterator that iterates over the items in this queue in FIFO order
*/
public Iterator iterator() {
return new ListIterator();
}
// an iterator, doesn't implement remove() since it's optional
private class ListIterator implements Iterator {
private Node current = first;
public boolean hasNext() { return current != null; }
public void remove() { throw new UnsupportedOperationException(); }
public Item next() {
if (!hasNext()) throw new NoSuchElementException();
Item item = current.item;
current = current.next;
return item;
}
}
}
Expert Answer:
It looks like you have provided code for a Clock class a Customer class and a Queue class To modify the Clock class to print out statistical informati... View the full answer
Introduction to Java Programming, Comprehensive Version
ISBN: 978-0133761313
10th Edition
Authors: Y. Daniel Liang
