Please help this is in java

Given the interface file and class file below, write the main program to test all the methods we have in the interface file.

A sample code to create the bag is shown below:

public class Main {

public static void main(String[] args) {

ArrayBag b1 = new ArrayBag<>();

b1.add(4);

b1.add(6);

if (b1.contains(6))

System.out.println("b1 contains 6");

}

}

/**

An interface that describes the operations of a bag of objects.

@author Frank M. Carrano

@author Timothy M. Henry

@version 4.1

*/

public interface BagInterface

{

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

@return The integer number of entries currently in the

bag. */

public int getCurrentSize();

/** Sees whether this bag is empty.

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

public boolean isEmpty();

/** 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);

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

@return Either the removed entry, if the removal.

was successful, or null. */

public T 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);

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

public void clear();

/** 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 the bag.

*/

public int getFrequencyOf(T anEntry);

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

@param anEntry The entry to locate.

@return True if the bag contains anEntry, or false if

not. */

public boolean contains(T anEntry);

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

@return A newly allocated array of all the entries in

the bag.

Note: If the bag is empty, the returned array is empty. */

public T[] toArray();

// public T[] toArray(); // Alternate

// public Object[] toArray(); // Alternate

/** Creates a new bag that combines the contents of this bag

and anotherBag.

@param anotherBag The bag that is to be added.

@return A combined bag. */

// public BagInterface union(BagInterface anotherBag);

/** Creates a new bag that contains those objects that occur

in both this bag and anotherBag.

@param anotherBag The bag that is to be compared.

@return A combined bag. */

// public BagInterface intersection(BagInterface anotherBag);

/** Creates a new bag of objects that would be left in this bag

after removing those that also occur in anotherBag.

@param anotherBag The bag that is to be removed.

@return A combined bag. */

// public BagInterface difference(BagInterface anotherBag);

} // end BagInterface

/**

A class of bags whose entries are stored in a fixed-size array.

@author Frank M. Carrano

@author Timothy M. Henry

@version 4.0

*/

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

// 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