diff --git a/src/main/java/io/zipcoder/Classroom.java b/src/main/java/io/zipcoder/Classroom.java
index 64566f0..270cfe0 100644
--- a/src/main/java/io/zipcoder/Classroom.java
+++ b/src/main/java/io/zipcoder/Classroom.java
@@ -1,4 +1,74 @@
 package io.zipcoder;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+
 public class Classroom {
+    ArrayList<Student> students = new ArrayList<>();
+
+    //Constructors
+    public Classroom(int maxNumberOfStudents){
+        this.students = new ArrayList<>(maxNumberOfStudents);
+    }
+
+   public Classroom(Student[] classroom){
+        this.students.addAll(Arrays.asList(classroom));
+   }
+
+    public Classroom(){
+        this.students = new ArrayList<>(30);
+    }
+
+    //Get Methods
+    public ArrayList<Student> getStudents(){ return this.students; }
+
+    public String[] getStudentFirstNames(){
+        String[] names = new String[students.size()];
+        for(int i = 0; i < students.size(); i++){
+            names[i] = students.get(i).getFirstName();
+        }
+        return names;
+    }
+
+    public Double getAverageExamScore(){
+        Double sumScores = 0.0;
+        Double sumExams = 0.0;
+        for (int i = 0; i < students.size(); i++){
+            Student kid = students.get(i);
+            sumExams += kid.getNumberOfExamsTaken();
+            sumScores += (kid.getAverageExamScore() * kid.getNumberOfExamsTaken());
+        }
+       return sumScores/sumExams;
+    }
+
+    public void addStudent(Student guy){
+        students.add(guy);
+    }
+
+    public void removeStudent(String firstName, String lastName){
+        for (int i = 0; i < students.size(); i++){
+            if (students.get(i).getFirstName().equals(firstName) && students.get(i).getLastName().equals(lastName)){
+               students.remove(i);
+            }
+        }
+    }
+
+    public Student[] getStudentsByScore(){
+        Student[] rankings = students.toArray(new Student[students.size()]);
+        Student placeholder;
+
+        for(int w = 1; w < students.size(); w++){
+            for(int i = 0; i < students.size() - w; i++){
+                if(rankings[i].getAverageExamScore() > rankings[i+1].getAverageExamScore()){
+                    placeholder = rankings[i+1];
+                    rankings[i+1] = rankings[i];
+                    rankings[i] = placeholder;
+                }
+            }
+        }
+
+        return rankings;
+    }
+
+
 }
diff --git a/src/main/java/io/zipcoder/Student.java b/src/main/java/io/zipcoder/Student.java
index b543e36..ebc506e 100644
--- a/src/main/java/io/zipcoder/Student.java
+++ b/src/main/java/io/zipcoder/Student.java
@@ -1,4 +1,81 @@
 package io.zipcoder;
 
+import javax.xml.crypto.dom.DOMCryptoContext;
+import java.util.ArrayList;
+import java.util.Arrays;
+
 public class Student {
+   String firstName;
+   String  lastName;
+   ArrayList<Double> examScores = new ArrayList<>();
+
+    public Student(String firstName, String lastName, Double[] testScores){
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.examScores.addAll(Arrays.asList(testScores));
+
+    }
+
+    // Getters
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public ArrayList<Double> getExamScores() {
+        return examScores;
+    }
+
+    public Integer getNumberOfExamsTaken() {
+        return examScores.size();
+    }
+
+    // Setters
+
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    // Other Methods
+
+    public String getExamsTaken() {
+        String ans = "Exam Scores:";
+        for (int i = 1; i <= examScores.size(); i++) {
+            ans += "\n      Exam " + i + " -> " + Math.round(examScores.get(i - 1));
+        }
+        return ans;
+    }
+
+    public void takeExam(Double newScore) {
+        this.examScores.add(newScore);
+    }
+
+    public void setExamScore(int examNumber, double newScore){
+        this.examScores.set(examNumber - 1, newScore);
+    }
+
+    public Double getAverageExamScore() {
+        Double sum = 0.0;
+        for (int i = 0; i < examScores.size(); i++) {
+            sum += this.examScores.get(i);
+        }
+
+        return sum/examScores.size();
+    }
+
+    @Override
+    public String toString(){
+      return  "Student Name: " + firstName + " " + lastName + "\n"
+      +"> Average Score: " + getAverageExamScore() + "\n"
+      +"> " + getExamsTaken();
+    }
 }
diff --git a/src/test/java/io/zipcoder/ClassroomTest.java b/src/test/java/io/zipcoder/ClassroomTest.java
index 7bac1ff..30b2f12 100644
--- a/src/test/java/io/zipcoder/ClassroomTest.java
+++ b/src/test/java/io/zipcoder/ClassroomTest.java
@@ -1,4 +1,171 @@
 package io.zipcoder;
 
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
 public class ClassroomTest {
+
+    @Test
+    public void testGetStudents(){
+        Double[] s1Scores = { 100.0, 150.0 };
+        Double[] s2Scores = { 225.0, 25.0 };
+
+        Student s1 = new Student("student", "one", s1Scores);
+        Student s2 = new Student("student", "two", s2Scores);
+
+        Student[] cohort = {s1,s2};
+        Classroom testClass = new Classroom(cohort);
+
+        ArrayList<Student> expected = new ArrayList<>(Arrays.asList(cohort));
+        ArrayList<Student> actual = testClass.getStudents();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testGetNotStudents(){
+        Double[] s1Scores = { 100.0, 150.0 };
+        Double[] s2Scores = { 225.0, 25.0 };
+
+        Student s1 = new Student("student", "one", s1Scores);
+        Student s2 = new Student("student", "two", s2Scores);
+
+        Student[] cohort = {s1,s2};
+        Classroom testClass = new Classroom(cohort);
+
+        Student[] unexpected = {s1,s2};
+        ArrayList<Student> actual = testClass.getStudents();
+
+        Assert.assertNotEquals(unexpected,actual);
+    }
+
+    @Test
+    public void testGetAverageExamScore(){
+        Double[] s1Scores = { 100.0, 150.0 };
+        Double[] s2Scores = { 225.0, 25.0 };
+
+        Student s1 = new Student("student", "one", s1Scores);
+        Student s2 = new Student("student", "two", s2Scores);
+
+        Student[] cohort = {s1,s2};
+        Classroom testClass = new Classroom(cohort);
+
+        Double expected = 125.0;
+        Double actual = testClass.getAverageExamScore();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetNotAverageExamScore(){
+        Double[] s1Scores = { 100.0, 150.0 };
+        Double[] s2Scores = { 225.0, 26.0 };
+
+        Student s1 = new Student("student", "one", s1Scores);
+        Student s2 = new Student("student", "two", s2Scores);
+
+        Student[] cohort = {s1,s2};
+        Classroom testClass = new Classroom(cohort);
+
+        Double unexpected = 125.0;
+        Double actual = testClass.getAverageExamScore();
+
+        Assert.assertNotEquals(unexpected, actual);
+    }
+
+    @Test
+    public void addStudentPositiveTest(){
+        Classroom classroom = new Classroom(10);
+        Double[] examScores = { 100.0, 150.0, 250.0, 0.0 };
+        Student s1 = new Student("Leon", "Hunter", examScores);
+
+        Integer preEnrollmentsize = classroom.getStudents().size();
+        classroom.addStudent(s1);
+        ArrayList postEnrollment = classroom.getStudents();
+
+        Integer[] expected = {0,1};
+        Integer[] actual = {preEnrollmentsize, postEnrollment.size()};
+
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void addStudentNegativeTest(){
+        Classroom classroom = new Classroom(10);
+        Double[] examScores = { 100.0, 150.0, 250.0, 0.0 };
+        Student s1 = new Student("Leon", "Hunter", examScores);
+
+        Integer preEnrollmentsize = classroom.getStudents().size();
+        classroom.addStudent(s1);
+        ArrayList postEnrollment = classroom.getStudents();
+
+        Integer[] expected = {0,0};
+        Integer[] actual = {preEnrollmentsize, postEnrollment.size()};
+
+        Assert.assertNotEquals(expected,actual);
+    }
+
+    @Test
+    public void removeStudentPositiveTest(){
+        Double[] s1Scores = { 100.0, 150.0 };
+        Double[] s2Scores = { 225.0, 25.0 };
+
+        Student s1 = new Student("one", "one", s1Scores);
+        Student s2 = new Student("two", "two", s2Scores);
+
+        Student[] cohort = {s1,s2};
+        Classroom testClass = new Classroom(cohort);
+
+        testClass.removeStudent("one","one");
+
+        Assert.assertEquals(1,testClass.students.size());
+
+    }
+
+    @Test
+    public void removeStudentNegativeTest(){
+        Double[] s1Scores = { 100.0, 150.0 };
+        Double[] s2Scores = { 225.0, 25.0 };
+
+        Student s1 = new Student("one", "one", s1Scores);
+        Student s2 = new Student("two", "two", s2Scores);
+
+        Student[] cohort = {s1,s2};
+        Classroom testClass = new Classroom(cohort);
+
+        testClass.removeStudent("one","one");
+
+        Assert.assertNotEquals(2,testClass.students.size());
+    }
+
+    @Test
+    public void getStudentsByScoreTest(){
+        Double[] scores1 = {1.0};
+        Double[] scores2 = {2.0};
+        Double[] scores3 = {3.0};
+        Double[] scores4 = {4.0};
+        Double[] scores5 = {5.0};
+        Double[] scores6 = {6.0};
+
+        Student s1 = new Student("1","1",scores1);
+        Student s2 = new Student("2","2",scores2);
+        Student s3 = new Student("3","3",scores3);
+        Student s4 = new Student("4","4",scores4);
+        Student s5 = new Student("5","5",scores5);
+        Student s6 = new Student("6","6",scores6);
+
+        Student[] cohort = {s4,s3,s2,s1,s6,s5};
+        Student[] expected = {s1,s2,s3,s4,s5,s6};
+        Classroom cohortSorted = new Classroom(cohort);
+        Student[] actual = cohortSorted.getStudentsByScore();
+
+        Assert.assertEquals(actual,expected);
+
+    }
+
+
 }
diff --git a/src/test/java/io/zipcoder/StudentTest.java b/src/test/java/io/zipcoder/StudentTest.java
index a9fedec..b1cd8b2 100644
--- a/src/test/java/io/zipcoder/StudentTest.java
+++ b/src/test/java/io/zipcoder/StudentTest.java
@@ -1,5 +1,309 @@
 package io.zipcoder;
 
+import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
 public class StudentTest {
 
+    @Test
+    public void testGetNotFirstName() {
+        String first = "Lyon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+
+        String actual = leonHunter.getFirstName();
+        Assert.assertNotEquals("first", actual);
+
+    }
+
+    @Test
+    public void testGetFirstName() {
+        String first = "Lyon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+
+        String actual = leonHunter.getFirstName();
+        //System.out.println(actual);
+        Assert.assertEquals("Lyon", actual);
+
+    }
+
+    @Test
+    public void testSetNotFirstName() {
+        String first = "Lyon";
+        String last = "Hunter";
+        Double[] scores = {100.0, 95.0, 123.0, 96.0};
+
+        Student leonHunter = new Student(first, last, scores);
+        leonHunter.setFirstName("Leon");
+
+        String actual = leonHunter.firstName;
+        Assert.assertNotEquals("Lyon", actual);
+
+    }
+
+    @Test
+    public void testSetFirstName() {
+        String first = "Lyon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+        leonHunter.setFirstName("Leon");
+
+        String actual = leonHunter.firstName;
+        //System.out.println(actual);
+        Assert.assertEquals("Leon", actual);
+
+    }
+
+    @Test
+    public void testGetNotLastName() {
+        String first = "Leon";
+        String last = "Hynter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+
+        String actual = leonHunter.getLastName();
+        Assert.assertNotEquals("last", actual);
+
+    }
+
+    @Test
+    public void testGetLastName() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+
+        String actual = leonHunter.getLastName();
+        //System.out.println(actual);
+        Assert.assertEquals("Hunter", actual);
+
+    }
+
+    @Test
+    public void testSetNotLastName() {
+        String first = "Leon";
+        String last = "Hynter";
+        Double[] scores = {100.0, 95.0, 123.0, 96.0};
+
+        Student leonHunter = new Student(first, last, scores);
+        leonHunter.setLastName("Hunter");
+
+        String actual = leonHunter.lastName;
+        Assert.assertNotEquals("Hynter", actual);
+
+    }
+
+    @Test
+    public void testSetLastName() {
+        String first = "Lyon";
+        String last = "Hynter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+        leonHunter.setLastName("Hunter");
+
+        String actual = leonHunter.lastName;
+        //System.out.println(actual);
+        Assert.assertEquals("Hunter", actual);
+
+    }
+
+    @Test
+    public void testGetNotExamScores() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+
+        Double[] unexpected = scores;
+        ArrayList<Double> actual = leonHunter.examScores;
+
+        Assert.assertNotEquals(unexpected,actual);
+
+    }
+
+    @Test
+    public void testGetExamScores() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+
+        ArrayList<Double> expected = new ArrayList<>(Arrays.asList(scores));
+        ArrayList<Double> actual = leonHunter.examScores;
+
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void testGetNotNumberOfExamsTaken() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+        int actual = leonHunter.getNumberOfExamsTaken();
+
+        Assert.assertFalse(actual <= 1);
+
+    }
+
+    @Test
+    public void testGetNumberOfExamsTaken() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+        int actual = leonHunter.getNumberOfExamsTaken();
+
+        Assert.assertEquals(4,actual);
+
+    }
+
+    @Test
+    public void testGetExamsTaken() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = { 100.0, 95.0, 123.0, 96.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+        String actual = leonHunter.getExamsTaken();
+
+        System.out.println("\nTest Of getExamsTaken() Method \n");
+        System.out.println(actual);
+        //This empirically worked as both a negative and a positive unit test
+
+    }
+
+    @Test
+    public void testTakeExamNegative() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = {};
+
+        Student leonHunter = new Student(first, last, scores);
+
+        leonHunter.takeExam(100.0);
+        ArrayList<Double> unexpected = new ArrayList<Double> (Arrays.asList(scores));
+        ArrayList<Double> actual = leonHunter.getExamScores();
+
+        Assert.assertNotEquals(unexpected,actual);
+    }
+
+    @Test
+    public void testTakeExam() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = {};
+
+        Student leonHunter = new Student(first, last, scores);
+
+        leonHunter.takeExam(100.0);
+        ArrayList<Double> expected = new ArrayList<Double>(){{add(100.0);}};
+        ArrayList<Double> actual = leonHunter.getExamScores();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testTakeExamSysOut() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = {};
+
+        Student leonHunter = new Student(first, last, scores);
+
+        leonHunter.takeExam(100.0);
+        String actual = leonHunter.getExamsTaken();
+
+        System.out.println("\nTest Of takeExam() Method \n");
+        System.out.println(actual);
+    }
+
+    @Test
+    public void testSetExamNegative() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = { 100.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+
+        leonHunter.setExamScore(1, 150.0);
+        ArrayList<Double> unexpected = new ArrayList<Double> (Arrays.asList(scores));
+        ArrayList<Double> actual = leonHunter.getExamScores();
+
+        Assert.assertNotEquals(unexpected,actual);
+    }
+
+    @Test
+    public void testSetExam() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = { 100.0 };
+
+        Student leonHunter = new Student(first, last, scores);
+
+        leonHunter.setExamScore(1, 150.0);
+        ArrayList<Double> expected = new ArrayList<Double> (Arrays.asList(150.0));
+        ArrayList<Double> actual = leonHunter.getExamScores();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testGetAverageExamScoreNegative() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = {100.0, 150.0, 250.0, 0.0};
+
+        Student leonHunter = new Student(first, last, scores);
+
+        Double unexpected = 0.0;
+        Double actual = leonHunter.getAverageExamScore();
+
+        Assert.assertNotEquals(unexpected, actual);
+    }
+
+    @Test
+    public void testGetAverageExamScore() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = {100.0, 150.0, 250.0, 0.0};
+
+        Student leonHunter = new Student(first, last, scores);
+
+        Double expected = 125.0;
+        Double actual = leonHunter.getAverageExamScore();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testToString() {
+        String first = "Leon";
+        String last = "Hunter";
+        Double[] scores = {100.0, 150.0, 250.0, 0.0};
+
+        Student leonHunter = new Student(first, last, scores);
+
+        System.out.println("\n Test toString() method \n");
+        System.out.println(leonHunter.toString());
+    }
 }
\ No newline at end of file
diff --git a/target/classes/io/zipcoder/Classroom.class b/target/classes/io/zipcoder/Classroom.class
new file mode 100644
index 0000000..84f6d7e
Binary files /dev/null and b/target/classes/io/zipcoder/Classroom.class differ
diff --git a/target/classes/io/zipcoder/Student.class b/target/classes/io/zipcoder/Student.class
new file mode 100644
index 0000000..cc425dd
Binary files /dev/null and b/target/classes/io/zipcoder/Student.class differ
diff --git a/target/test-classes/io/zipcoder/ClassroomTest.class b/target/test-classes/io/zipcoder/ClassroomTest.class
new file mode 100644
index 0000000..ddee5a7
Binary files /dev/null and b/target/test-classes/io/zipcoder/ClassroomTest.class differ
diff --git a/target/test-classes/io/zipcoder/StudentTest$1.class b/target/test-classes/io/zipcoder/StudentTest$1.class
new file mode 100644
index 0000000..c9ba433
Binary files /dev/null and b/target/test-classes/io/zipcoder/StudentTest$1.class differ
diff --git a/target/test-classes/io/zipcoder/StudentTest.class b/target/test-classes/io/zipcoder/StudentTest.class
new file mode 100644
index 0000000..3f2e477
Binary files /dev/null and b/target/test-classes/io/zipcoder/StudentTest.class differ