Introduction to Programming: Comment on Test 3

The test was marked out of 80, and the 20 marks for each question were divided equally among its parts (with 7 marks for each part of questions 2 and 3, but a maximum of 20 overall). However, since the test was done very badly by most people, and there were complaints that it was too much for the time available, I have decided to grade it by counting complete and correct answers to three questions as enough to get full marks. In other words, a mark of 60 is equivalent to 100%, and the pass mark is 40% of 60, which is 24. The three people who got over 60 marks will be recorded as getting 100%.

Even after this scaling, over half those taking the test failed. I do not believe this is an acceptable performance. Anyone who had paid any attention to what was going on in the classes and done a significant amount of labwork ought to have had no trouble getting 24 marks.

Question 1

Part a

Part b

Part c

Part d

Note that it was not certainly enough to say "we use the word to declare a Java interface", since that really does not indicate an understanding of what is meant by the term. "We use it to define a type in terms of what objects of that type can do" is better, but a little imprecise, so a completely correct answer would need to mention that an interface lists the methods that all objects of that type are expected to be able to have called on them.

Part e

Question 2

One big difference here from what we did before, however, is that questions 2 and 3 deal with arrays of objects. That ought not to have been a problem since we dealt extensively with arrays of objects in the banks examples in class. Question 3 also deals with a class (Councillor) which has a subclass (Alderman). Again, we dealt with something similar in the banks example (AccountB with subclass DepositAccountB).

Many people still don't seem to understand the basic idea of methods, parameter passing and value returning. When you are asked, for example to "write a method which takes a Thing and a Doodah and returns a Grommet", you ought immediately to start by writing a header something like:

Grommet myMethod(Thing t, Doodah d)

Note that if we have a class called MyType, then the type MyType[] is the type for an array of MyType objects. This is true for any type, so if an argument is to be an array of Grommet objects, then its type is Grommet[], for example.

Suppose the method we started above called myMethod is static, so its full signature is:

public static Grommet myMethod(Thing t, Doodah d)

If the method is not static, then its full signature will be:

public Grommet myMethod(Thing t, Doodah d)

Part a

One surprisingly common error, which is obviously wrong if you think about it, was to write something like this:

for(int i=0; i<council.length; i++)
   if(council[i].isPresent())
      if(council[i].agrees(m))
         return true;
      else
         return false;

For some reason, some people thought you would have to use the method getName somewhere in this answer, for example council[i].getName().agrees(m). This would attach the call agrees(m) to the string returned by getName() and not to the Councillor object. Obviously strings can't agree with motions, so that doesn't make sense.

Part b

Note something similar was done with the banks example where we went though an array of AccountRecord objects looking for those which had DepositAccountB objects in them so we could call the method update on them. This shows the importance of looking through the programs that were given as examples in class and making sure you understand them and how they work. Ask me if you don't. All the examples were given for a reason: to illustrate principles which you need to know.

Again, some answers to this question showed some strange uses of getName. The name of the councillor is just an extra feature, and the question does not suggest it has anything to do with whether the councillor is a member of the executive.

Part c

Since the method you are asked to write in part c is static, it won't be called attached to an object. So it will change the value of the array passed to it as an argument (by setting one of the array cells that held a Councillor object to hold an Alderman object).

Note that the test for whether two strings, str1 and str2, are equal is str1.equals(str2). It is not str1==str2 because strings are objects and the == test tests whether two object references are to the same object. It evaluates to false if it is applied to two object references which aren't to the same object, even if they are to diffeent objects with the same content. Another way to test two strings are equal is str1.compareTo(str2)==0, since the compareTo method returns a negative number if str1 is less than str2 in alphabetic order, a positive number if it is greater than str2 alphabetically, and 0 if they are equal in content.

Question 3

Part a

In this question, the phrase "assuming all councillors were present" was given, indicating that unlike parts a and b of question 3, there should not be a check using the isPresent method on the Councillor objects.

Part b

The question gave the hint that you could use the method from part a, and this made it much simpler to answer. Despite this, some people gave answers in which code very similar to that of their answer to part a was repeated in order to count the votes first for one motion then for the other. It is always permissible in a programming exam to save time by making use in one part of a method you've defined in another, should that be appropriate.

Part c

public static Motion morePopular(Motion m1, Motion m2, Councillor[] council)
{
 if(m1.countVotes(council)>m2.countVotes(council)
    return m1;
 else
    return m2;
}

public static Motion bestMotion(Motion[] motions, Councillor[] council)
{
 Motion best = motions[0];
 for(int i=1; i<motions.length; i++)
    best = Motion.morePopular(best,motions[i],council);
 return best;
}

A number of people thought as the question asked for a reference to the most popular motion, the name of the method should be something like reference. That is to misunderstand why when we are being precise we use the term "reference" in Java. We could say the method just returns the most popular motion from the array, but actually it returns a reference because all Java variables except those of the primitive types hold references to objects rather than the objects themselves. That is why you can have two object variables referring to the same object, because they don't actually hold the object itself, they hold a reference to it. We sometimes show this in diagrams by showing the actual object as one thing, and the reference to it as an arrow pointing to it.

Question 4

Some people drew diagrams with two arrows coming from a box. It's not possible for a single Java object field or variable to refer to two objects at once, although of course an object can be referred to by several different references. I was not sure if the people who gave answers like this actually believed that a field could refer to two objects at the same time, or it was meant to be working out.

Some people drew cells which were initially part of the structure, but which nothing mentioned in the question pointed to after the execution of the code fragment in the question. This should not be done. If nothing points to a cell, it should be considered to have disappeared. To be technical, it is automatically garbage collected. "Garbage collection" refers to letting cells be reused. In Java (but not in some other language, such as C and Pascal) garbage collection is done automatically, so once a cell is not referred to by anything, the computer memory that was used for that store could be reused any time more memory is required when another cell is created.

Another common problem was not showing where cells were shared. In some cases, from their answers it looked as if people knew that sharing occurred, but they just didn't show it in their diagrams, in other cases they perhaps mistakenly believed that assigning one object variable or field to another meant the object was copied rather than shared.

It is important, for example, to distinguish:

from

Although both represent cases where n1 represents the list [x,a,b] and n2 represents the list [y,a,b], they represent different situations, and this needs to be made clear in the diagrams. Consider what would happen if following this, the statement n1.next.first='z' were executed. In the first case, n1 would then represent [x,z,b] and because of the sharing n2 would then represent [y,z,b]. In the second case, while n1 still comes to represent [x,z,b], n2 stays representing [y,a,b] because its cell holding 'a' is a different cell from the one which holds the 'a' for n2.

For those who haven't understood how sharing happens, suppose our initial situation is:

and then we execute n2.next=n1.next. The situation will then be as in the first diagram above, and not as in the second. This is because the next fields of the list cell objects are of object types (the same type as the list cell), and when an object field or variable is assigned an object value, it causes aliasing to occur, as we saw in week 4. So here n2.next becomes an alias for n1.next, in other words it points to the same cell that n1.next pointed to (and n1.next still points to that cell).

Part a

Part b

Following this, the += is just the normal += of Java, where a+=b is shorthand for a=a+b. So n1.next.first += n1.first is shorthand for n1.next.first = n1.next.first+n1.first, in other words, the contents of the first cell in n1's list is added to the contents of the second cell of the list.

Part c

So this code moves ptr down the list represented by n1, until it points to a cell whose first field is not less than 8. After that, the statement ptr.first *= 2; is executed, doubling the value of that cell whose number is not less than 8 (i.e. changing 9 to 18). The next statement sets the next field of that same cell to point to the cell that n2 points to, so causing sharing of cells. The final statement triples the value of the number in the second cell of n2's list, and due to cell-sharing that tripling is shared because that cell is now also the fifth cell of n1's list.

Part d

for(ptr=n1; n2!=null; n2=n2.next)
   {
    k += n2.first;
    ptr=ptr.next;
   }

ptr=n1;
while(n2!=null)
   {
    k += n2.first;
    n2 = n2.next;
    ptr=ptr.next;
   }