Assignment 2

class X {
    public X y = null;
    public X z = null;
    public int v = 0;
    public int w() {
//      int xv = 0; -- unneeded (this was a typo)
        int yv = 0;
        int zv = 0; // omitted in original version
        if (y != null) yv = y.w();
        if (z != null) zv = z.w();
//      return v + xv + yv; -- typo
        return v + yv + zv; // intended
    }
}

Two object handles per item immediately suggests a tree, and the integer field suggests a tree of integers, but many other data structures could be made with objects with this structure, depending on how they are linked together. You have to look at the method w to see what assumptions it makes about thee data structure. It uses a recursive algorithm where recursion is terminated by encountering a null, exactly the algorithm for tree traversal and totally unsuited to graph traversal. If used on a tree, w adds zero for nulls, and it sums all the values of the non-null items.

X x = new X();
x.y = x;
x.z = x;
x.v = 1;
System.out.println( x.w() );

What happens when you try to compile and run the above?
a) There is a compile time error
b) The code goes into an infinite loop
c) The code suffers from run-away recursion and dies of a stack overflow — correct
d) The code outputs the value 1
e) Something else

First, int, float and boolean are not Classes, and variables of these primitive types are not objects. (Had the class names Integer, Float or Boolean been used, the answer would depend on what was on the right side of the equals sign on these lines.) This rules out a), b) and d).

Second, String is a real class in Java, so the answer on lines d) and e) depends on whether the right-hand-side of the equals sign creates a new object. The string constant "Hello World!" is a constant. Each time line c) is encountered in a program, the same object is assigned. The object holding the string constant was created just once, when you loaded your program to run, and all uses of this constant refer to the same object. No new object is created at any later time during the execution of your program.

That leaved option e). Each time the expression "x = " + x is encountered, the variable x is evaluated and concatenated with the string constant "x = ". To do this concatenation, a new String must be created each time this is done. So this line actually does concatenation.

Note that the expression "x = " + x uses a short-hand notation. The Java compiler treats this as equivalent to the following:
new StringBuilder("x = ").append( x.toString() ).toString()

public class Test {public static void main(String[] arg){}}

public class Test {
    public static void main(String[] arg) {
    }
}

public class Test
    {
        public static void main(String[] arg)
            {
            }
    }

public class Test {
        public static void main(String[] arg) {}
}

public class Test
        {
                public static void main(String[] arg)
                        {
                        }
        }

public class
Test {
        public static void
        main(String[] arg) {
                           }
     }

public class Hw2 {

    static final String section = "xxxx";

    static final String user = System.getenv( "USER" );

    public static void main(String[] args) {
        try {
            Process p = Runtime.getRuntime().exec( new String[] {
                "/mnt/nfs/clasnetappvm/fs3/dwjones/2820hw2",
                section,
                user,
            }, null, null );
        } catch (Exception e) {
            System.out.println( "oops: " + e );
        }
    }
}

81 students completed this assignment. 47 completed it on Monday, 10 completed it on Tuesday, 22 completed it on Wednesday, and 2 completed it shortly after midnight Thursday morning (close enough).