Question

Using Java, write code as follows:

1. Create an interface called Items. It should define at least the following methods:
   1. public void add( Object item ) - adds a single object to the collection.
   2. public Object get( int index ) - returns an item at a specific index.
   3. public int size() - returns the number of items stored in the collection.
   4. public void addAll( Object[] items ) - adds all of the elements in the array to the collection.
2. Write a class called AbstractItems that implements the Items interface. It should provide concrete implementations of at least the following methods:
   1. public void addAll( Object[] items ) - This should simply loop and call the add method for each item in the array.
   2. public String toString() - returns a string that lists all of the items on a single line. For example, if the collection contained the strings “abc”,“123”, and “cat” the toString method should return something like “abc 123 cat”. This method should use a loop and call the get method.
3. Create a class called ArrayOfItems that extends AbstractItems.
   1. Create a constructor that takes an integer parameter called size and use it to create an Object array of that size to hold your items.
   2. Use the array to implement the remaining abstract methods inherited from the Items class: add, size, and get. Note that size should return the number of items that have been added to the array, not the size of the array. In other words, if your initial array is large enough to hold 10 items, but only 2 items have been added, your size method should return 2, not 10. Once the array is full, the add method should ignore additional values.
4. You should include a main method to test the addAll and toString methods as well as the add, get, and size methods.
5. Create a class called Node. A Node has two instance variables.
   1. An Object named item.
   2. A reference to another Node called next.

Create the appropriate accessors and mutators for both variables.

5. Create a class called ListOfItems that extends AbstractItems. This new class will us the Node created previously. The class will need three instance variables:
   1. A Node called head.
   2. A Node called tail.
   3. An int called size.

When a ListOfItems is created, create a new Node and set both the head and the tail to refer to it. The first time that the “add” method is called, add the Object to the head node and increment size from 0 to 1 Each time add is called after that, follow this algorithm:

1. Create a new Node.
2. Add the Object to the new Node. using the setItem method.
3. Use the setNext mutator on the current tail to point to the new Node.
4. Change the tail to point to the new Node.
5. Increment size.

Also provide an implementation for the get method. This will require you to start at the head and use the getNext method to count the appropriate number of nodes in the list before returning the item at the specified index using its getItem method.

9. Create a class called ItemsTest with two methods:
   1. public static void testItems(Items items) - this method should thoroughly test all methods of the Items interface (add, addAll, get, size, toString). The Items instance should be printed to standard output (using its toString method) each time the contents are changed.
10. public static void main(String[] args) - Your main method should create at least one instance of each of the implementation classes and call the testItems method. You must show that your ArrayOfItems ignores values after the array is full.

Answer 1

import java.io.*;

import java.util;

public class void main {

interface Items
{
   public void method1();
}

int add()

{

public void add( Object item )  

public Object get( int index )

public int size(add)

public static void main(String[] args)

public void addAll( Object[] items ) // done for looping //

public String toString()

{

int arr[] = new int[] { "abc", 1, 2, 0 };

        Vector<Integer> v = new Vector();

        Hashtable<Integer, String> m = new Hashtable();

}

  

public class MyClass { int x; public MyClass()
{

x = 55;
}

public static void main(String[] args)

{

MyClass myObj = new MyClass(); //constructor //

System.out.println(myObj.x);

}

}

class node

{

object item =new item()

   class Node{

int data;   

Node next;    

sessionItem.setItem(keyname, value)

class Item LinkNode;

}

}

public static void testItems(Items)

{

public class Calculator {
   public static int add(int number8, int number9) {
      return number8 + number9;
   }

 
   public static int sub(int number1, int number2) {
      return number1 - number2;
        }

}

}