Using Objects and Methods: Mixed Unit Review (Computer Science A Unit 1)

Read the big ideas and the method table, then try the seven questions without notes. Each question combines two or more Unit 1 topics.

These are original Marlbridge practice questions, not past exam questions. The rubrics are a suggested Marlbridge rubric, not official scoring. No calculator is allowed on the exam, so work by hand. Code fragments are assumed to be inside a main method.

Big ideas of the unit

• Programs are sequences of statements that run in order (1.1). Order matters, and errors come in three kinds: syntax (compiler), logic (testing) and run-time (while running).
• Every value has a type. int, double and boolean are primitive; classes such as String are reference types (1.2). The compiler checks that types fit.
• Expressions are evaluated one operation at a time with precedence and left-to-right order (1.3). Two int operands give an int; a double operand gives a double. Casting and range matter (1.5).
• Assignment stores the value of the right side in the left variable (1.4, 1.6). Primitive assignment copies a value.
• Libraries, documentation and contracts let you use code you did not write (1.7, 1.8). Preconditions are the caller’s job; postconditions are the method’s promise.
• Methods have signatures (1.9). Class methods are called with the class name (1.10, 1.11); arguments are passed by value.
• Objects are instances of classes, created by constructors (1.12, 1.13). A reference variable holds a reference or null; instance methods are called on objects (1.14).
• Strings are immutable objects (1.15). Indices start at 0, substring(from, to) excludes to, and equals compares content.

One-table method summary

The classes used in Question 5.

class Rectangle {
    private int width;
    private int height;

    public Rectangle(int w, int h) {
        width = w;
        height = h;
    }

    public int area() {
        return width * height;
    }

    public int perimeter() {
        return 2 * (width + height);
    }

    public void grow(int amount) {
        width = width + amount;
        height = height + amount;
    }

    public String describe() {
        return width + " x " + height;
    }
}

Question 1 (multiple choice · 1.2, 1.3, 1.5)

What value is stored in r by the following statement?

double r = (double) 7 / 2 + 7 / 2;

• (A) 7.0
• (B) 6.5
• (C) 6.0
• (D) 7.5

Question 2 (splitting a quantity · 1.3, 1.4, 1.6)

A program stores 200000 seconds in an int variable t. Using / and %= only, write statements that store the whole days, whole hours, whole minutes and remaining seconds in days, hours, mins and t, and display them in the form 2 d 7 h 33 min 20 s for this data. (A day has 86400 seconds.)

int t = 200000;
int days = t / 86400;
t %= 86400;
int hours = t / 3600;
t %= 3600;
int mins = t / 60;
t %= 60;
System.out.println(days + " d " + hours + " h " + mins + " min " + t + " s");

2 d 7 h 33 min 20 s

Question 3 (methods and contracts · 1.8, 1.9, 1.10)

The class Digits below has two class methods. The first one has a Javadoc comment.

class Digits {
    /**
     * Returns the last two digits of n.
     * Precondition: n >= 0
     * Postcondition: the value returned is from 0 to 99 inclusive
     */
    public static int lastTwoDigits(int n) {
        n = n % 100;
        return n;
    }

    public static int bump(int n) {
        n++;
        return n;
    }
}

In a different class:

int v = 12345;
int w = Digits.lastTwoDigits(v);
int z = Digits.bump(w) + Digits.lastTwoDigits(v + 55);
System.out.println(v + " " + w + " " + z);

(a) State the signature of lastTwoDigits and say who is responsible for the precondition.

(b) State the output, showing the value of each call.

(c) Explain why v is still 12345 even though lastTwoDigits assigns to its parameter.

12345 45 46

Question 4 (random numbers and rounding · 1.5, 1.11)

(a) Write an expression for a random int from -5 to 5, both inclusive, and test it with the smallest and largest possible values of Math.random().

(b) Write an expression for a random double that is at least 20.0 and less than 30.0.

(c) A student scored 7 out of 8. Write one expression that gives the percentage rounded to the nearest whole number as an int, and state its value.

Question 5 (objects and references · 1.12, 1.13, 1.14)

Using the Rectangle class above, trace the code and state the output of each println.

Rectangle a = new Rectangle(2, 5);
Rectangle b = a;
Rectangle c = new Rectangle(3, 3);
b.grow(1);
c.grow(1);
int s = a.area() + c.perimeter();
Rectangle d = null;
System.out.println(a.describe() + " " + b.describe() + " " + c.describe() + " " + s);
System.out.println(d.area());

(a) State the first line of output and the value of s.

(b) What happens at the last statement, and why does the compiler not report it?

(c) How many Rectangle objects were created?

Question 6 (strings and parsing · 1.7, 1.9, 1.15)

The variable date holds "2027-05-12" (year, month, day, separated by hyphens).

(a) State date.indexOf("-") and date.length().

(b) Write code that stores the year, month and day in String variables year, month and day using substring.

(c) Write a statement that displays 12/05/2027.

(d) Using the Integer.parseInt entry from the Java Quick Reference (it returns the String argument as an int), write a statement that displays the year after year, and state the output.

String date = "2027-05-12";
String year = date.substring(0, 4);
String month = date.substring(5, 7);
String day = date.substring(8);
System.out.println(day + "/" + month + "/" + year);
System.out.println(Integer.parseInt(year) + 1);

12/05/2027
2028

Question 7 (finding and classifying errors · 1.1, 1.4, 1.9, 1.10)

The program below does not compile as written.

public class Faulty {
    public static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int side = 4;
        int area = Faulty.square(side)
        double ratio = 7 / 2;
        int zero = 0;
        System.out.println(area / zero);
    }
}

(a) Find the error that stops it compiling, say what kind it is and correct it.

(b) After the correction, the program compiles. State the value stored in ratio. If the programmer expected 3.5, what kind of error is this, and how would it be found?

(c) What happens when the last statement is executed? What kind of error is this?

How did you do?

• Question 1: revisit 1.3 and 1.5: evaluate one operation at a time.
• Question 2: revisit 1.3 and 1.6.
• Question 3: revisit 1.8, 1.9 and 1.10.
• Question 4: revisit 1.5 and 1.11.
• Question 5: revisit 1.12, 1.13 and 1.14; draw the reference diagram.
• Question 6: revisit 1.15 and 1.7.
• Question 7: revisit 1.1.

Unit 2 adds decisions and loops. Before starting, make sure you can trace Unit 1 code with a table, one row per statement.