Replace a null Array with objects

The array is initialized and is not null, however the entries of the array are null. It is possible without the use of a list (but it would be simpler). You need to store additonal information, how many students are enrolled.

int numberOfStudents = 0;

public boolean enroll(Student student) 
{
  if(numberOfStudents >= 100) return false;

  students[numberOfStudents] = student;
  numberOfStudents++;
  return true;
}

You also need to consider what should happen when there are more than 100 students?

Thats basically what an ArrayList does with the advantage that it will automatically grow the array, if there is too much data. If you know in advanced how many entries there will be, you can use ArrayList(int initialCapacity) to avoid unneccessary copying:

List<Student> students = new ArrayList<Student>(100);

public boolean enroll(Student student) 
{
  return students.add(student);
}

The array is actually initialized, to 100 null Student objects, indexed 0 to 99.

So, assuming that the enroll() method is part of the Course class, returning true whenever it stores a non-null Student object, it can be implemented as follows:

public boolean enroll(Student s) {
  if ((s == null) || (this.counter >= 100)) {
    return false;
  }
  this.students[this.counter] = s;  
  ++this.counter;
  return true;
}

where this.counter is an integer initialized to 0 in the constructor, after the students array is initialized.

A better approach would have been to use an ArrayList instead of an array, to avoid having to check the size every time and have no maximum size limitation. In that case, this.students would be initialized as

List<Student> students;
...
this.students = new ArrayList<Student>();

and the implementation of enroll() would be simplified to

public boolean enroll(Student s) {
  if (s == null) {
    return false;
  }
  this.students.add(s);  
  return true;
}

without the need for a counter.

You can enroll a student in two ways:

• Use ArrayList instead of array, by this way, you won't need to keep track of last entry or iterate through an array every time enroll is called, e.g.:

  public Course(Professor professor, String courseName) { this.professor = professor; this.courseName = courseName; this.students = new ArrayList<Student>(); }

  public void enroll(Student s){ this.students.add(s); }

• Use array and iterate through it to find out the last null location, e.g.:

  public void enroll(Student s){ if(null == s) return; for(int i=0 ; i<this.students.length ; i++){ if(this.students[i] == null){ this.students[i] = s; return; } } }

In this method, you will also keep track of whether all 100 students have been enrolled already.