In a main program for java, create 3 ArrayBag objects that have type Car. Create 3 car objects and show that you can add each to three different bags, then display whats in each bag.

(Car interface)

public interface CarInter {

public void goFast(int s);

public void goSlow(int s);

public void pumpGas(int t);

}

(Implementation for Car)

public class Car implements CarInter, Comparable{

public Car()

{

tank = 5;

speed = 0;

model = "newCar";

}

public int compareTo(Object c)

{

Car m = (Car) c;

if (tank > m.tank)

return 1;

else if (tank == m.tank)

return 0;

else

return -1;

}

public void goFast(int s)

{

speed += s;

if (speed > 65)

speed = 65;

}

@Override

public String toString()

{

String st = "";

st = st + model + "tank = " + tank;

return st;

}

public void pumpGas(int t)

{

tank += t;

if (tank > 15)

tank = 15;

}

public void goSlow(int s)

{

speed = speed - s;

if (speed < 0)

speed = 0;

}

public void displaySpeed()

{

System.out.println("speed = " + speed);

}

private int speed;

private int tank;

private String model;

}

(ArrayBag implementation)

public final class ArrayBag implements BagInterface

{

private final T[] bag;

private int numberOfEntries;

private boolean initialized = false;

private static final int DEFAULT_CAPACITY = 25;

private static final int MAX_CAPACITY = 10000;

/** Creates an empty bag whose initial capacity is 25. */

public ArrayBag()

{

this(DEFAULT_CAPACITY);

} // end default constructor

/** Creates an empty bag having a given capacity.

@param desiredCapacity The integer capacity desired. */

public ArrayBag(int desiredCapacity)

{

if (desiredCapacity <= MAX_CAPACITY)

{

// The cast is safe because the new array contains null entries

@SuppressWarnings("unchecked")

T[] tempBag = (T[])new Object[desiredCapacity]; // Unchecked cast

bag = tempBag;

numberOfEntries = 0;

initialized = true;

}

else

throw new IllegalStateException("Attempt to create a bag " +

"whose capacity exceeds " +

"allowed maximum.");

} // end constructor

/** Adds a new entry to this bag.

@param newEntry The object to be added as a new entry.

@return True if the addition is successful, or false if not. */

public boolean add(T newEntry)

{

checkInitialization();

boolean result = true;

if (isArrayFull())

{

result = false;

}

else

{ // Assertion: result is true here

bag[numberOfEntries] = newEntry;

numberOfEntries++;

} // end if

return result;

} // end add

/** Retrieves all entries that are in this bag.

@return A newly allocated array of all the entries in this bag. */

public T[] toArray()

{

checkInitialization();

// The cast is safe because the new array contains null entries.

@SuppressWarnings("unchecked")

T[] result = (T[])new Object[numberOfEntries]; // Unchecked cast

for (int index = 0; index < numberOfEntries; index++)

{

result[index] = bag[index];

} // end for

return result;

// Note: The body of this method could consist of one return

statement,

// if you call Arrays.copyOf

} // end toArray

/** Sees whether this bag is empty.

@return True if this bag is empty, or false if not. */

public boolean isEmpty()

{

return numberOfEntries == 0;

} // end isEmpty

/** Gets the current number of entries in this bag.

@return The integer number of entries currently in this bag. */

public int getCurrentSize()

{

return numberOfEntries;

} // end getCurrentSize

/** Counts the number of times a given entry appears in this bag.

@param anEntry The entry to be counted.

@return The number of times anEntry appears in this ba. */

public int getFrequencyOf(T anEntry)

{

checkInitialization();

int counter = 0;

for (int index = 0; index < numberOfEntries; index++)

{

if (anEntry.equals(bag[index]))

{

counter++;

} // end if

} // end for

return counter;

} // end getFrequencyOf

/** Tests whether this bag contains a given entry.

@param anEntry The entry to locate.

@return True if this bag contains anEntry, or false otherwise. */

public boolean contains(T anEntry)

{

checkInitialization();

return getIndexOf(anEntry) > -1; // or >= 0

} // end contains

/** Removes all entries from this bag. */

public void clear()

{

while (!isEmpty())

remove();

} // end clear

/** Removes one unspecified entry from this bag, if possible.

@return Either the removed entry, if the removal

was successful, or null. */

public T remove()

{

checkInitialization();

T result = removeEntry(numberOfEntries - 1);

return result;

} // end remove

/** Removes one occurrence of a given entry from this bag.

@param anEntry The entry to be removed.

@return True if the removal was successful, or false if not. */

public boolean remove(T anEntry)

{

checkInitialization();

int index = getIndexOf(anEntry);

T result = removeEntry(index);

return anEntry.equals(result);

} // end remove

// Returns true if the array bag is full, or false if not.

private boolean isArrayFull()

{

return numberOfEntries >= bag.length;

} // end isArrayFull

// Locates a given entry within the array bag.

// Returns the index of the entry, if located,

// or -1 otherwise.

// Precondition: checkInitialization has been called.

private int getIndexOf(T anEntry)

{

int where = -1;

boolean found = false;

int index = 0;

while (!found && (index < numberOfEntries))

{

if (anEntry.equals(bag[index]))

{

found = true;

where = index;

} // end if

index++;

} // end while

// Assertion: If where > -1, anEntry is in the array bag, and it

// equals bag[where]; otherwise, anEntry is not in the array.

return where;

} // end getIndexOf

// Removes and returns the entry at a given index within the array.

// If no such entry exists, returns null.

// Precondition: 0 <= givenIndex < numberOfEntries.

// Precondition: checkInitialization has been called.

private T removeEntry(int givenIndex)

{

T result = null;

if (!isEmpty() && (givenIndex >= 0))

{

result = bag[givenIndex]; // Entry to remove

int lastIndex = numberOfEntries - 1;

bag[givenIndex] = bag[lastIndex]; // Replace entry to remove

with last entry

bag[lastIndex] = null; // Remove reference to last

entry

numberOfEntries--;

} // end if

return result;

} // end removeEntry

public void display()

{

for(int i=0; i< numberOfEntries; i++)

System.out.print(bag[i] + " ");

System.out.println();

}

// Throws an exception if this object is not initialized.

private void checkInitialization()

{

if (!initialized)

throw new SecurityException("ArrayBag object is not initialized

properly.");

} // end checkInitialization

} // end ArrayBag

(Bag interface)

public interface BagInterface

{

public int getCurrentSize();

public boolean isEmpty();

public boolean add(T newEntry);

public T remove();

public boolean remove(T anEntry);

public void clear();

public int getFrequencyOf(T anEntry);

public boolean contains(T anEntry);

public void display();

}