Introduction to Programming: Comment on Test 1

The test was marked out of 80, and the 20 marks for each question were divided equally among its parts (except 2e had 5 marks with 3 for the rest of question 2).

Question 1

Part a

The reason for this is that if a language compiles directly to machine code there has to be a separate compiler for every type of machine, and the compiled version of the program for one type of machine won't run on another type of machine. In Java there has to be a separate Java byte code interpreter for each type of machine, but as Java byte code is always the same for any machine, the compiled version of Java can be run on any machine that has a Java byte code interpreter. This gives Java programs their "run anywhere" property.

Part b

Aliasing is only going to matter with mutable objects (that is objects whose field values can be changed either because they are not declared as private or they have methods that can chage them). In that case, after executing a=b the two variables a and b do refer to the same object. It will be the object which b referred to before the assignment was executed. Then, making a change to the object by calling a method on either a or b, or assigning a new value to a non-private field of a or b will change the object both refer to as it is literally the same object. Note, if either a or b is later assigned to another object that does not change what the other of them refers to. So if we later do b=c, then b will refer to the object which c referred to previously (and c will still refer to it). But a will stay referring to the object which b used to refer to.

Note it is possible for two separate objects to have data of equal values stored in their own fields. This is not aliasing. Aliasing refers to two or more names for the same object, not two or more identical but separate objects.

Part c

So what was expected was a precise description of how && works, that is that in an expression of the form exp1&&exp2, the subexpression exp2 is only evaluated if exp1 evaluates to true. This will only have an effect if exp2 has a side-effect (i.e. evaluating it can change the state of something) or evaluating it can cause an exception. So exp2 cannot just be a variable (some people wrongly referred to it as that).

However, the question did not ask for an expression which would demonstrate that the operator has a short-circuit effect. Some people chose to answer the question by giving such an expression but without actually explaining what is meant by short-circuiting with respect to the && operator. There were no marks for that, as it didn't answer the question.

Part d

Question 2

Part a

Part b

Part c

Part d

The ?: is a little obscure - you don't see it that often, you never really have to use it, and it's often mentioned as an afterthought in textbooks. But if you're familiar with it, you won't be confused if you come across some code where someone has decided to use it.

Part e

Also in this part it should again be remembered that what was asked for was exactly what would be printed. The println call prints the three number with a spaces in between them, not commas. A few people still have not grasped that + when a string is involved means "join the string representations" and not "arithmetic add", and of course " " is a string, the string consisting of one space character.

Part f

But note that in a similar way, (int)d*2 is interpreted as ((int)d)*2 and not as (int)(d*2). In other words, the integer conversion of d is found first and that is multiplied by 2. As d has value 2.6666667 or thereabouts, the integer conversion gives the value 2 and that is multiplied by 2 in c=(int)d*2 to give c the value 4. It's not the case that d is multiplied by 2 first, giving 5.3333333 and that is converted to an integer.

Question 3

Part a

The reason it is not valid Java is that as < is a binary operator (i.e. takes two arguments, one to its left, the other to its right), a<b<c must be interpreted as either (a<b)<c or a<(b<c). But neither of these makes sense because both would involve comparing a boolean (i.e. true or false, the result of the < within the brackets) with an integer, which doesn't make sense.

A more subtle error in this question is that it didn't actually state that a was less than c, though a lot of people assumed it. As it wasn't stated, you had also to allow for the case that c was the lowest, b the middle and c the highest, and print Yes in that case.

By the way, when the question asked for code that printed Yes it meant that, and not YES. It is important to be precise when writing programs, and if you are told to write a program to do something make sure it does exactly that. You don't know what the code you're writing is for, it may be used to provide input for another program that tests for Yes and not YES. The very earliest computers made no distinction between small and capital letters but that was back in the Stone Age when computer memory was so expensive that it made sense to save space by minimising the set of characters usable, and anyway computers just calculated and printed numbers. Most of you weren't even born when that was the case, so there is no excuse for ignoring case sensitivity now.

That also applies to writing Java reserved words (if, while etc.) - they use small letters and it's a mistake to use capital letters, Java won't interpret If as an if and so on. Capital letters are used in Java in words like String, but that's a predefined object-type, and charAt but that's a predefined method, neither are reserved words which are things that can't be analysed in any other way than as symbols of Java. Of course, it's equally wrong to use string for String and so on.

Another point on this question is that the question told you that you have three int variables a, b and c, which have been given values. So it is assumed you are writing a piece of code to put below an existing piece of code which already has a line int a,b,c; plus further code to give values to a, b and c (or some other code which has the same effect). It is therefore wrong to write as part of your answer int a,b,c;. The effect of that is to declare three new variables called a, b and c. Depending on circumstances (to do with scope, as mentioned in question 1d), this would either be an error or would mean the rest of your code refers to these three new variables which have no connection to the a, b and c of the question.

A final point is that a lot of people seemed to be making up notation that doesn't exist in Java. In some cases, from my knowledge of other programming languages, they're using something from Pascal or Basic, for example using the word and as in Pascal, rather than Java's &&. This indicates the danger of thinking you know how to program from previous experience. Since all you need for the test was explained in the lectures, and can also be found in the web notes and in your textbooks, using notation from a language you studied previously suggests you haven't been working hard enough at studying Java. Plenty of those making mistakes which suggest pre-university familiarity with another language haven't got very far on other aspects of the test. This indicates that pre-university programming experience may not be as helpful as those without it sometimes imagine. Sometimes it's a case of not realising how trivial the pre-university programming was, other times the pre-university experience actually makes it harder to start thinking about programming in the object-oriented style of Java.

A few people simply made up notation of their own, for example, b!<a for "b not less than a". Maybe this seems as if it ought to work, since != is Java's symbol for "not equal". However, it doesn't work - the symbol b!<a is not in any Java textbook or web site, and the test was open book so you could check that. Also the mathematical "less than or equal" and "greater than or equal" signs (I can just about render them in HTML as < and >) are not valid Java operators. That ought to be obvious, since how would you be able to type them into a Java program without a key on the computer keyboard for them? When you are asked to write a Java program, do be accurate, and that involves little things like using the correct <= and >= for "less than or equal" and "greater than or equal".

Part b

When it's stated that a method has signature boolean hit(int force) it means when the method is called it must be attached to an object. If the method was declared as static its call should be attached to the name of its class, but hit wasn't declared as static. Attaching a method to an object means you have a reference to an object, followed by a dot, followed by the call. Usually the reference is a variable which has been set to refer to an object.

You were told that punchbag was a variable on which that method could be called. You didn't need to know anything else about the method other than that fact and its signature. That fact meant you could write punchbag.hit(arguments). As the return type of hit was given as boolean the expression punchbag.hit(arguments) evaluates to a boolean value, i.e. either true or false. So what happens is that anywhere where punchbag.hit(arguments) occurs in your code, when the computer evalutes that code, it will go away, execute the code in the hit method, which will eventually return true or false. You don't need to know, and weren't told in the question how it does it. All you need to know is what you are told by that return type, that where you wrote punchbag.hit(arguments) it's writing something that will actually become true or false when the code is evaluated, only you don't know which until that happens.

Now, in punchbag.hit(arguments), what arguments must be is given by what appears between the opening and closing bracket in the signature. There is one int argument given there called force. It doesn't matter what the argument is called, because that's only really relevant to the code for the method, which you weren't given. What it means is that in your call to hit, you must make arguments one thing which evaluates to an integer value. The question tells you that you have one such thing, a variable of type int called b, and it tells you to use it as an argument. So your call to hit on punchbag with argument b cannot be anything except:

punchbag.hit(b)

The next issue is how to keep making that call until the number of times in variable c or until it returns false. We can do something a certain number of times by setting another variable to 0 and increasing it by 1 each time until it reaches the value. The question stated that we could use the variable a to store temporary values. We can exit a loop before its condition is met by using break, and this is technique is used in the following solution:

a=0;
while(a<c)
   {
    if(!punchbag.hit(b))
       break;
    a++;
   }

Note the importance of good layout here. While the Java compiler doesn't require it, it's essential to make your program easier for the human reader to pick up. I prefer the closing } to be directly below the opening { and both to be at the beginning of the line, but many authors recommend a style where the opening { is on the same line as the while and the closing } is directly below the w, giving:

a=0;
while(a<c) {
   if(!punchbag.hit(b))
      break;
   a++;
}

a=0;
while(a<c) {
   if(!punchbag.hit(b))
      break;
   a++;    }

What's even worse than that is the complete lack of indentation:

a=0;
while(a<c) {
if(!punchbag.hit(b))
break;
a++;    }

while(test)
   {
    stuff
   }

Break statements are considered not really in accord with the principles of structured programming. When you have a loop like ours of the form

while(a<c)
   {
    stuff
   }

The break wasn't necessary in our example. Here's an alternative way of answering it:

a=0;
while(a<c&&punchbag.hit(b))
   {
    a++;
   }

a=0;
while(a<c&&punchbag.hit(b))
   a++;

Our example quite nicely illustrates the short-circuit effect of &&. When it makes the test a<c&&punchbag.hit(b) in the while loop, if a is equal to c then a<c is false and we don't evaluate punchbag.hit(b). That is just as well, because if we did, we would be calling hit with argument b on punchbag one more time than we were asked to.

Since the test was set before we had discussed for statements, you wouldn't have been expected to have answered it using a for statement. However, it could be done that way, and that wouldn't have been wrong. A for statement is just like a while statement, except it has an extra part before the test and separated from it by a ; where you can initialise a variable to a value (or even declare and initialise a new variable), and an extra part after the test, again separated with a ;, which is a statement executed after executing all those in the body. The following for statement will answer the question:

for(a=0; a<c&&punchbag.hit(b); a++);

class Something
{
 public static void main(String[] args)
 {
 Some stuff
 }
}

int getTemp()

Grommet pushButton()

void addFuel(int amount)

int getQuality()

BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

String str;
int amount;
str = in.readLine();
amount = Integer.parseInt(str);

String str = in.readLine();
int amount = Integer.parseInt(str);

int amount = Integer.parseInt(in.readLine());

Machine m = new Machine();

m.addFuel(amount);

m.addFuel(Integer.parseInt(in.readLine()));

while(m.getTemp()>=20)
   {
    stuff
   }

while(m.getTemp()>=20)
   {
    Grommet g = m.pushButton();
   }

while(m.getTemp()>=20)
   {
    m.pushButton();
   }

Machine m = new Machine();
int count;
Grommet g;
for(count=0; m.getTemp()>=20; count++)
   g=m.pushButton();
System.out.println(count+" grommets produced");

for(int count=0; m.getTemp()>=20; count++)
   g=m.pushButton();

int count=0, qcount=0;
int gQual=g.getQuality();
while(count<100)
   {
    Grommet g1=m.pushButton();
    count++;
    if(g1.getQuality()>gQual)
       qcount++;
   }
System.out.println(qcount+" high quality grommets produced");

int qcount=0;
int gQual=g.getQuality();
for(int count=0; count<100; count++)
   {
    Grommet g1=m.pushButton();
    if(g1.getQuality()>gQual)
       qcount++;
   }
System.out.println(qcount+" high quality grommets produced");

int qcount=0;
int gQual=g.getQuality();
for(int count=0; count<100; count++)
   if(m.pushbutton().getQuality()>gQual)
      qcount++;
System.out.println(qcount+" high quality grommets produced");