diff --git a/DataLabs/lab3/ArrayBag.class b/DataLabs/lab3/ArrayBag.class
new file mode 100644
index 0000000..f076247
Binary files /dev/null and b/DataLabs/lab3/ArrayBag.class differ
diff --git a/DataLabs/lab3/ArrayBag.java b/DataLabs/lab3/ArrayBag.java
new file mode 100644
index 0000000..5afc1c5
--- /dev/null
+++ b/DataLabs/lab3/ArrayBag.java
@@ -0,0 +1,143 @@
+public class ArrayBag<T> implements BagInterface<T> {
+
+    private T[] t;
+    private int size;
+    private int capacity;
+    private static final int DEFAULT_CAPACITY = 25;
+
+
+    public ArrayBag(int capacity) {
+        this.size = 0;
+        this.capacity = capacity;
+        this.t = (T[]) new Object[capacity];
+
+    }
+    public ArrayBag() {
+        this(DEFAULT_CAPACITY);
+    }
+
+    public int getCurrentSize() {
+        return size;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public boolean add(T newEntry) {
+        if (isFull()) {
+ //       return false;
+            resize();
+        }
+        t[size] = newEntry;
+        size++;
+        return true;
+    }
+
+    public T remove() {
+        if (isEmpty()) {
+            return null;
+        }
+            T temp = t[size - 1];
+            t[size - 1] = null;
+            size--;
+            return temp;
+        }
+
+    public boolean remove(T anEntry) {
+        int index = getIndexOf(anEntry);
+        if (index >= 0) {
+            t[index] = t[size - 1];
+            t[size - 1] = null;
+            size--;
+            return true;
+        }
+        return false;
+    }
+
+    public void clear() {
+        while(!isEmpty()) {
+            t[size - 1] = null;
+            size--;
+        }
+    }
+
+    public int getFrequencyOf(T anEntry) {
+    int temp = 0;
+    for(int i = 0; i < size; i++) {
+        if(t[i] == anEntry) {
+            temp++;
+        }
+    }
+    return temp;
+    }
+
+    public boolean contains(T anEntry) {
+        if(getFrequencyOf(anEntry) > 0) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public T[] toArray() {
+        T[] newArray = (T[]) new Object[size];
+        for(int i = 0; i < size; i++) {
+        newArray[i] = t[i];
+        }
+    return newArray;
+    }
+
+    private int getIndexOf(T anEntry) {
+        for(int i = 0; i < size; i++) {
+            if(t[i] == anEntry) {
+            return i;
+            }
+        }
+        return -1;
+    }
+
+    public boolean isFull() {
+        return capacity == size;
+ }
+    public void resize() {
+        int newCapacity = 2 * capacity;
+        T[] newArray = (T[]) new Object[newCapacity];
+
+        for (int i = 0; i < size; i++) {
+            newArray[i] = t[i];
+    }
+
+    t = newArray;
+    capacity = newCapacity;{}
+    }
+
+        public ArrayBag<T> union(ArrayBag<T> otherBag) {
+            ArrayBag<T> result = new ArrayBag<>(this.size + otherBag.size);
+
+            for(int i = 0; i < this.size; i++){
+                result.add(this.t[i]);
+            }
+
+            for(int i = 0; i < otherBag.size; i++){
+                result.add(otherBag.t[i]);
+            }
+            return result;
+        }
+
+        public ArrayBag<T> intersection(ArrayBag<T> otherBag) {
+            ArrayBag<T> result = new ArrayBag<>(Math.min(this.size, otherBag.size));
+
+            for(int i = 0; i < this.size; i++) {
+                T temp = this.t[i];
+
+
+                if(otherBag.contains(temp)) {
+                    result.add(temp);
+                    otherBag.remove(temp);
+                }
+            }
+            return result;
+        }
+
+}
diff --git a/DataLabs/lab3/ArrayBagDemo.java b/DataLabs/lab3/ArrayBagDemo.java
new file mode 100644
index 0000000..46252bf
--- /dev/null
+++ b/DataLabs/lab3/ArrayBagDemo.java
@@ -0,0 +1,241 @@
+/** A demonstration of the class ArrayBag
+    @author Frank M. Carrano
+    @version 4.0
+*/
+public class ArrayBagDemo
+{
+	public static void main(String[] args) 
+	{
+		String[] contentsOfBag = {"A", "A", "B", "A", "C", "A"};
+      // Tests on an empty bag
+      BagInterface<String> aBag = new ArrayBag<>(contentsOfBag.length);
+      System.out.println("Testing an initially empty bag:");
+      testIsEmpty(aBag, true);
+      String[] testStrings1 = {"", "B"};
+      testFrequency(aBag, testStrings1);
+      testContains(aBag, testStrings1);
+      testRemove(aBag, testStrings1);
+      // Adding strings
+      System.out.println("Adding " + contentsOfBag.length +
+                         " strings to an initially empty bag with" +
+                         " the capacity to hold more than " +
+                         contentsOfBag.length + " strings:");
+		testAdd(aBag, contentsOfBag);
+      
+      // Tests on a bag that is not empty
+      testIsEmpty(aBag, false);
+      String[] testStrings2 = {"A", "B", "C", "D", "Z"};
+      testFrequency(aBag, testStrings2);
+      testContains(aBag, testStrings2);
+		
+      // Removing strings
+		String[] testStrings3 = {"", "B", "A", "C", "Z"};
+      testRemove(aBag, testStrings3);
+		System.out.println("\nClearing the bag:");
+		aBag.clear();
+      testIsEmpty(aBag, true);
+		displayBag(aBag);
+      
+      // Filling an initially empty bag to capacity
+      System.out.println("\nTesting an initially empty bag that " +
+                         " will be filled to capacity:");
+		aBag = new ArrayBag<String>(7);
+		String[] contentsOfBag2 = {"A", "B", "A", "C", "B", "C", "D"};
+		testAdd(aBag, contentsOfBag2);
+      
+      System.out.println("Try to add another string to the full bag:");
+      if (aBag.add("another string"))
+         System.out.println("Added a string beyond the bag's capacity: ERROR!");
+      else
+         System.out.println("The method add cannot add another string: OK");
+	} // end main
+	
+   // Tests the method add.
+	private static void testAdd(BagInterface<String> aBag, String[] content)
+	{
+		System.out.print("Adding ");
+		for (int index = 0; index < content.length; index++)
+		{
+			aBag.add(content[index]);
+         System.out.print(content[index] + " ");
+		} // end for
+      System.out.println();
+      
+		displayBag(aBag);
+	} // end testAdd
+   // Tests the two remove methods.
+	private static void testRemove(BagInterface<String> aBag, String[] tests)
+	{
+      for (int index = 0; index < tests.length; index++)
+      {
+         String aString = tests[index];
+         if (aString.equals("") || (aString == null))
+         {
+            // test remove()
+            System.out.println("\nRemoving a string from the bag:");
+            String removedString = aBag.remove();
+            System.out.println("remove() returns " + removedString);
+         }
+         else
+         {
+            // test remove(aString)
+            System.out.println("\nRemoving \"" + aString + "\" from the bag:");
+            boolean result = aBag.remove(aString);
+            System.out.println("remove(\"" + aString + "\") returns " + result);
+         } // end if
+         
+         displayBag(aBag);
+      } // end for
+	} // end testRemove
+   // Tests the method isEmpty.
+   // correctResult indicates what isEmpty should return.   
+	private static void testIsEmpty(BagInterface<String> aBag, boolean correctResult)
+	{
+      System.out.print("Testing isEmpty with ");
+      if (correctResult)
+         System.out.println("an empty bag:");
+      else
+         System.out.println("a bag that is not empty:");
+      
+      System.out.print("isEmpty finds the bag ");
+      if (correctResult && aBag.isEmpty())
+			System.out.println("empty: OK.");
+		else if (correctResult)
+			System.out.println("not empty, but it is empty: ERROR.");
+		else if (!correctResult && aBag.isEmpty())
+			System.out.println("empty, but it is not empty: ERROR.");
+		else
+			System.out.println("not empty: OK.");      
+		System.out.println();
+	} // end testIsEmpty
+   // Tests the method getFrequencyOf.
+	private static void testFrequency(BagInterface<String> aBag, String[] tests)
+	{
+ 		System.out.println("\nTesting the method getFrequencyOf:");
+      for (int index = 0; index < tests.length; index++)
+      {
+         String aString = tests[index];
+         if (!aString.equals("") && (aString != null))
+         {
+            System.out.println("In this bag, the count of " + tests[index] +
+                               " is " + aBag.getFrequencyOf(tests[index]));
+         } // end if
+      } // end for
+   } // end testFrequency
+   
+   // Tests the method contains.
+	private static void testContains(BagInterface<String> aBag, String[] tests)
+	{
+ 		System.out.println("\nTesting the method contains:");
+      for (int index = 0; index < tests.length; index++)
+      {
+         String aString = tests[index];
+         if (!aString.equals("") && (aString != null))
+         {
+            System.out.println("Does this bag contain " + tests[index] + 
+                               "? " + aBag.contains(tests[index]));
+         } // end if
+      } // end for
+   } // end testContains
+   // Tests the method toArray while displaying the bag.
+	private static void displayBag(BagInterface<String> aBag)
+	{
+		System.out.println("The bag contains " + aBag.getCurrentSize() +
+		                   " string(s), as follows:");		
+		Object[] bagArray = aBag.toArray();
+		for (int index = 0; index < bagArray.length; index++)
+		{
+			System.out.print(bagArray[index] + " ");
+		} // end for
+		
+		System.out.println();
+	} // end displayBag
+} // end ArrayBagDemo
+/*
+ Testing an initially empty bag:
+ Testing isEmpty with an empty bag:
+ isEmpty finds the bag empty: OK.
+ 
+ 
+ Testing the method getFrequencyOf:
+ In this bag, the count of B is 0
+ 
+ Testing the method contains:
+ Does this bag contain B? false
+ 
+ Removing a string from the bag:
+ remove() returns null
+ The bag contains 0 string(s), as follows:
+ 
+ 
+ Removing "B" from the bag:
+ remove("B") returns false
+ The bag contains 0 string(s), as follows:
+ 
+ Adding 6 strings to an initially empty bag with the capacity to hold more than 6 strings:
+ Adding A A B A C A
+ The bag contains 6 string(s), as follows:
+ A A B A C A
+ Testing isEmpty with a bag that is not empty:
+ isEmpty finds the bag not empty: OK.
+ 
+ 
+ Testing the method getFrequencyOf:
+ In this bag, the count of A is 4
+ In this bag, the count of B is 1
+ In this bag, the count of C is 1
+ In this bag, the count of D is 0
+ In this bag, the count of Z is 0
+ 
+ Testing the method contains:
+ Does this bag contain A? true
+ Does this bag contain B? true
+ Does this bag contain C? true
+ Does this bag contain D? false
+ Does this bag contain Z? false
+ 
+ Removing a string from the bag:
+ remove() returns A
+ The bag contains 5 string(s), as follows:
+ A A B A C
+ 
+ Removing "B" from the bag:
+ remove("B") returns true
+ The bag contains 4 string(s), as follows:
+ A A C A
+ 
+ Removing "A" from the bag:
+ remove("A") returns true
+ The bag contains 3 string(s), as follows:
+ A A C
+ 
+ Removing "C" from the bag:
+ remove("C") returns true
+ The bag contains 2 string(s), as follows:
+ A A
+ 
+ Removing "Z" from the bag:
+ remove("Z") returns false
+ The bag contains 2 string(s), as follows:
+ A A
+ 
+ Clearing the bag:
+ Testing isEmpty with an empty bag:
+ isEmpty finds the bag empty: OK.
+ 
+ The bag contains 0 string(s), as follows:
+ 
+ 
+ Testing an initially empty bag that  will be filled to capacity:
+ Adding A B A C B C D
+ The bag contains 7 string(s), as follows:
+ A B A C B C D
+ Try to add another string to the full bag:
+ The method add cannot add another string: OK
+  */
+  /*
+   Exception in thread "main" java.lang.SecurityException: Attempt to create a bag whose capacity exceeds 3
+	at ArrayBag.<init>(ArrayBag.java:38)
+	at ArrayBagDemo.main(ArrayBagDemo.java:12)
+   
+*/
diff --git a/DataLabs/lab3/BagInterface.class b/DataLabs/lab3/BagInterface.class
new file mode 100644
index 0000000..6e4b165
Binary files /dev/null and b/DataLabs/lab3/BagInterface.class differ
diff --git a/DataLabs/lab3/BagInterface.java b/DataLabs/lab3/BagInterface.java
new file mode 100644
index 0000000..75a10e1
--- /dev/null
+++ b/DataLabs/lab3/BagInterface.java
@@ -0,0 +1,48 @@
+/**
+   An interface that describes the operations of a bag of objects.
+   @author Frank M. Carrano
+   @version 4.0
+*/
+public interface BagInterface<T>
+{
+	/** 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();
+} // end BagInterface
diff --git a/Example.java b/Example.java
new file mode 100644
index 0000000..7b19fa2
--- /dev/null
+++ b/Example.java
@@ -0,0 +1,9 @@
+public class Example
+{
+    public static <T> void displayArray(T[] anArray) {
+        for (T arrayEntrey : anArray) {
+            System.out.print(arrayEntry);
+            System.out.print(" ");
+        }
+    }
+}
diff --git a/assignments/AssigmentS3/StorageBox.class b/assignments/AssigmentS3/StorageBox.class
new file mode 100644
index 0000000..0c62336
Binary files /dev/null and b/assignments/AssigmentS3/StorageBox.class differ
diff --git a/assignments/AssigmentS3/StorageBox.java b/assignments/AssigmentS3/StorageBox.java
new file mode 100644
index 0000000..91b2e8c
--- /dev/null
+++ b/assignments/AssigmentS3/StorageBox.java
@@ -0,0 +1,44 @@
+public class StorageBox<T> {
+
+    private T[] items;
+    private int size;
+    private int capacity;
+
+public StorageBox(int capacity) {
+    this.capacity = capacity;
+    this.size = 0;
+    this.items = (T[]) new Object[capacity];
+}
+
+public void addItem(T item) {
+    if(capacity == size) {
+        System.out.println("StorageBox is full");
+        return;
+    } else {
+        items[size] = item;
+        size++;
+        System.out.println("Item added: "+ item);
+    }
+}
+
+public T removeItem() {
+        if(size == 0) {
+            System.out.println("No more item left!");
+            return null;
+        } else {
+            T temp = items[size - 1];
+            items[size - 1] = null;
+            size--;
+            System.out.println("Removed Item: "+ temp);
+            return temp;
+        }
+}
+
+public void listItem() {
+        System.out.println("Items in StorageBox: ");
+        for(int i = 0; i < size; i++) {
+            System.out.print(items[i]+ " ");
+        }
+}
+
+}
diff --git a/assignments/AssigmentS3/demo.java b/assignments/AssigmentS3/demo.java
new file mode 100644
index 0000000..ced5c12
--- /dev/null
+++ b/assignments/AssigmentS3/demo.java
@@ -0,0 +1,36 @@
+public class demo {
+    public static void main(String[] args) {
+    StorageBox<String> box = new StorageBox<>(3);
+    StorageBox<Integer> box1 = new StorageBox<>(3);
+
+    box.addItem("Math");
+    box.addItem("Java");
+    box.addItem("Statistics");
+    box.addItem("capacityTest");
+
+    System.out.println();
+
+    box.listItem();
+
+    System.out.println(" ");
+    System.out.println();
+
+    box.removeItem();
+    box.removeItem();
+    box.removeItem();
+    box.removeItem();
+    box.removeItem();
+    box.removeItem();
+
+    System.out.println();;
+
+    box.listItem();
+
+    box1.addItem(1);
+    box1.addItem(2);
+    box1.addItem(3);
+    box1.addItem(4);
+
+    box1.listItem();
+    }
+}
diff --git a/assignments/AssigmentS4/AList.class b/assignments/AssigmentS4/AList.class
new file mode 100644
index 0000000..b49f2de
Binary files /dev/null and b/assignments/AssigmentS4/AList.class differ
diff --git a/assignments/AssigmentS4/AList.java b/assignments/AssigmentS4/AList.java
new file mode 100644
index 0000000..3181601
--- /dev/null
+++ b/assignments/AssigmentS4/AList.java
@@ -0,0 +1,181 @@
+import java.util.Arrays;
+
+/**
+ * A class that implements a list of objects by using an array.
+ * Entries in a list have positions that begin with 1.
+ * Duplicate entries are allowed.
+ * @author Frank M. Carrano
+ */
+public class AList<T> implements ListInterface<T> {
+    private T[] list; // Array of list entries; ignore list[0]
+    private int numberOfEntries;
+    private boolean initialized = false;
+    private static final int DEFAULT_CAPACITY = 25;
+    private static final int MAX_CAPACITY = 10000;
+
+    public AList() {
+        this(DEFAULT_CAPACITY); // Call next constructor
+    } // end default constructor
+
+    public AList(int initialCapacity) {
+        // Is initialCapacity too small?
+        if (initialCapacity < DEFAULT_CAPACITY)
+            initialCapacity = DEFAULT_CAPACITY;
+        else // Is initialCapacity too big?
+            checkCapacity(initialCapacity);
+
+        // The cast is safe because the new array contains null entries
+        @SuppressWarnings("unchecked")
+        T[] tempList = (T[]) new Object[initialCapacity + 1];
+        list = tempList;
+        numberOfEntries = 0;
+        initialized = true;
+    } // end constructor
+
+    public void add(T newEntry) {
+        checkInitialization();
+        list[numberOfEntries + 1] = newEntry;
+        numberOfEntries++;
+        ensureCapacity();
+    } // end add
+
+    public void add(int newPosition, T newEntry) {
+        checkInitialization();
+        if ((newPosition >= 1) && (newPosition <= numberOfEntries + 1)) {
+            if (newPosition <= numberOfEntries) {
+                makeRoom(newPosition);
+            }
+            list[newPosition] = newEntry;
+            numberOfEntries++;
+            ensureCapacity();
+        } else {
+            throw new IndexOutOfBoundsException("Given position of add's new entry is out of bounds.");
+        }
+    } // end add
+
+    public T remove(int givenPosition) {
+        checkInitialization();
+        if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {
+            T result = list[givenPosition];
+            if (givenPosition < numberOfEntries) {
+                removeGap(givenPosition);
+            }
+            list[numberOfEntries] = null;
+            numberOfEntries--;
+            return result;
+        } else {
+            throw new IndexOutOfBoundsException("Illegal position given to remove operation.");
+        }
+    } // end remove
+
+    public void clear() {
+        while (!isEmpty()) {
+            remove(numberOfEntries);
+        }
+    } // end clear
+
+    public T replace(int givenPosition, T newEntry) {
+        checkInitialization();
+        if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {
+            T originalEntry = list[givenPosition];
+            list[givenPosition] = newEntry;
+            return originalEntry;
+        } else {
+            throw new IndexOutOfBoundsException("Illegal position given to replace operation.");
+        }
+    } // end replace
+
+    public T getEntry(int givenPosition) {
+        checkInitialization();
+        if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {
+            return list[givenPosition];
+        } else {
+            throw new IndexOutOfBoundsException("Illegal position given to getEntry operation.");
+        }
+    } // end getEntry
+
+    public T[] toArray() {
+        checkInitialization();
+
+        // The cast is safe because the new array contains null entries
+        @SuppressWarnings("unchecked")
+        T[] result = (T[]) new Object[numberOfEntries];
+        for (int index = 0; index < numberOfEntries; index++) {
+            result[index] = list[index + 1];
+        } // end for
+
+        return result;
+    } // end toArray
+
+    public boolean contains(T anEntry) {
+        checkInitialization();
+        boolean found = false;
+        int index = 1;
+        while (!found && (index <= numberOfEntries)) {
+            if (anEntry.equals(list[index])) {
+                found = true;
+            }
+            index++;
+        } // end while
+        return found;
+    } // end contains
+
+    public int getLength() {
+        return numberOfEntries;
+    } // end getLength
+
+    public boolean isEmpty() {
+        return numberOfEntries == 0; // Or getLength() == 0
+    } // end isEmpty
+
+    // Doubles the capacity of the array list if it is full.
+    // Precondition: checkInitialization has been called.
+    private void ensureCapacity() {
+        int capacity = list.length - 1;
+        if (numberOfEntries >= capacity) {
+            int newCapacity = 2 * capacity;
+            checkCapacity(newCapacity); // Is capacity too big?
+            list = Arrays.copyOf(list, newCapacity + 1);
+        } // end if
+    } // end ensureCapacity
+
+    // Throws an exception if the client requests a capacity that is too large.
+    private void checkCapacity(int capacity) {
+        if (capacity > MAX_CAPACITY)
+            throw new IllegalStateException("Attempt to create a list whose capacity exceeds " +
+                    "allowed maximum of " + MAX_CAPACITY);
+    } // end checkCapacity
+
+    // Throws an exception if receiving object is not initialized.
+    private void checkInitialization() {
+        if (!initialized)
+            throw new SecurityException("AList object is not initialized properly.");
+    } // end checkInitialization
+
+    // Makes room for a new entry at newPosition.
+    // Precondition: 1 <= newPosition <= numberOfEntries + 1;
+    // numberOfEntries is list's length before addition;
+    // checkInitialization has been called.
+    private void makeRoom(int newPosition) {
+        int newIndex = newPosition;
+        int lastIndex = numberOfEntries;
+
+        for (int index = lastIndex; index >= newIndex; index--) {
+            list[index + 1] = list[index];
+        }
+    } // end makeRoom
+
+    // Shifts entries that are beyond the entry to be removed to the
+    // next lower position.
+    // Precondition: 1 <= givenPosition < numberOfEntries;
+    // numberOfEntries is list's length before removal;
+    // checkInitialization has been called.
+    private void removeGap(int givenPosition) {
+        int removedIndex = givenPosition;
+        int lastIndex = numberOfEntries;
+
+        for (int index = removedIndex; index < lastIndex; index++) {
+            list[index] = list[index + 1];
+        }
+    } // end removeGap
+} // end AList
\ No newline at end of file
diff --git a/assignments/AssigmentS4/ListClient.java b/assignments/AssigmentS4/ListClient.java
new file mode 100644
index 0000000..994f421
--- /dev/null
+++ b/assignments/AssigmentS4/ListClient.java
@@ -0,0 +1,26 @@
+import java.util.Arrays;
+
+public class ListClient {
+    public static void main(String[] args) {
+        // Create an instance of AList
+        AList<String> list = new AList<>();
+
+        // Test isEmpty() on a new list
+        System.out.println("Is the list empty? " + list.isEmpty()); // Expected: true
+
+        // Test add(T newEntry)
+        list.add("Apple");
+        list.add("Banana");
+        list.add("Cherry");
+        System.out.println("After adding 3 items: " + Arrays.toString(list.toArray())); // Expected: [Apple, Banana, Cherry]
+
+        list.add(2, "Peach");
+        System.out.println(list.getEntry(2));
+        System.out.println("New List: "+ Arrays.toString(list.toArray()));
+        list.remove(2);
+        System.out.println("New List: "+ Arrays.toString(list.toArray()));
+        System.out.println("Changed item:"+list.replace(2, "Orange"));
+        System.out.println("New List: "+ Arrays.toString(list.toArray()));
+        System.out.println(list.contains("Apple"));
+    }
+}
\ No newline at end of file
diff --git a/assignments/AssigmentS4/ListInterface.class b/assignments/AssigmentS4/ListInterface.class
new file mode 100644
index 0000000..b10edee
Binary files /dev/null and b/assignments/AssigmentS4/ListInterface.class differ
diff --git a/assignments/AssigmentS4/ListInterface.java b/assignments/AssigmentS4/ListInterface.java
new file mode 100644
index 0000000..4fe9af3
--- /dev/null
+++ b/assignments/AssigmentS4/ListInterface.java
@@ -0,0 +1,70 @@
+public interface ListInterface<T> {
+    /**
+     * Adds a new entry to the end of the list.
+     * @param newEntry The object to be added as a new entry.
+     */
+    void add(T newEntry);
+
+    /**
+     * Adds a new entry at a specified position within the list.
+     * @param newPosition An integer that specifies the desired position of the new entry.
+     * @param newEntry The object to be added as a new entry.
+     * @throws IndexOutOfBoundsException if newPosition is out of bounds.
+     */
+    void add(int newPosition, T newEntry);
+
+    /**
+     * Removes the entry at a given position from the list.
+     * @param givenPosition An integer that indicates the position of the entry to be removed.
+     * @return A reference to the removed entry.
+     * @throws IndexOutOfBoundsException if givenPosition is out of bounds.
+     */
+    T remove(int givenPosition);
+
+    /**
+     * Removes all entries from the list.
+     */
+    void clear();
+
+    /**
+     * Replaces the entry at a given position in the list.
+     * @param givenPosition An integer that indicates the position of the entry to be replaced.
+     * @param newEntry The object that will replace the entry at the given position.
+     * @return The original entry that was replaced.
+     * @throws IndexOutOfBoundsException if givenPosition is out of bounds.
+     */
+    T replace(int givenPosition, T newEntry);
+
+    /**
+     * Retrieves the entry at a given position in the list.
+     * @param givenPosition An integer that indicates the position of the desired entry.
+     * @return A reference to the indicated entry.
+     * @throws IndexOutOfBoundsException if givenPosition is out of bounds.
+     */
+    T getEntry(int givenPosition);
+
+    /**
+     * Retrieves all entries that are in this list in the order in which they occur in the list.
+     * @return An array of all the entries in the list.
+     */
+    T[] toArray();
+
+    /**
+     * Determines whether the list contains a given entry.
+     * @param anEntry The object that is the desired entry.
+     * @return True if the list contains anEntry, or false if not.
+     */
+    boolean contains(T anEntry);
+
+    /**
+     * Gets the length of this list.
+     * @return The integer number of entries currently in the list.
+     */
+    int getLength();
+
+    /**
+     * Determines whether this list is empty.
+     * @return True if the list is empty, or false if not.
+     */
+    boolean isEmpty();
+}
\ No newline at end of file