Review for Quiz 2

Question 2-1

Name and explain a reason why generics (such as generic packages in Ada or templates in C++) are a useful feature for a programming language to include.

Question 2-2

Write the withdraw: method of our Account class so that the balance cannot drop below 0.

Question 2-3

Say you want to add a unary instance method into Smalltalk's built-in Integer class called abs, which returns the absolute value of the Integer instance to which the method is applied. Write the definition of this method.

Question 2-4

Name two significant and distinct differences between the object-oriented features of Java and Smalltalk. Do not address other differences, like their radically different syntax.

Question 2-5

Consider the following Java program.

class A {
    int f() { return 1; }
}

class B extends A {
    int f() { return 0; }
}

class Main {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.f());
    }
}

What does this program print?

Question 2-6

Consider the following program.

class Ident {
    int f(int x) { return x; }
    int g(int x) { return f(f(x)); }
}

class Square extends Ident {
    int f(int x) { return x * x; }
}

class Main {
    public static void main(String[] args) {
        Ident a = new Ident();
        Ident b = new Square();
        Square c = new Square();
        System.out.println(a.g(3) + " " + b.g(3) + " " + c.g(3));
    }
}

What does this program print?

Question 2-7

Draw the Listener pattern using an UML Class Diagram.

Solutions

Solution 2-1

A generic allows the programmer to write subprograms in which a type can vary. For example, you could write a Sort subprogram that works with an array of any type of data by using a generic. Without generics, in a statically typed language, you would need a separate sort subprogram for each type of array you might want to sort.

(A more minor, but still legitimate, advantage is that generics allow the programmer to write a generic subprogram that takes a constant as a parameter, and this constant could be compiled into by the compiler into individual instances of the generic subprogram. For example, we could have a generic function that multiplies a number by a generic parameter.

generic
    Mult : Integer
function Multiply(X : Integer) return Integer is
begin
    return Mult * X;
end Multiply;

function Double is new Multiply(2);
function Triple is new Multiply(3);

The compiler will be able to optimize the Double routine to do a left-shift instead of a multiplication.)

Solution 2-2

withdraw: aNumber
    balance := balance - aNumber.
    balance < 0
        ifTrue: [ balance := 0 ]

Solution 2-3

abs
    self >= 0 ifTrue: [ ^ self ] ifFalse: [ ^ 0 - self ]

Solution 2-4

1. Everything's an object in Smalltalk, while Java has ``primitive types,'' which are not objects.

2. Java provides data protection, while Smalltalk does not.

3. Java is statically typed, and Smalltalk is dynamically typed. For Java, this means that the programmer must be more careful with defining types that are needed (as with the AccountListener interface, which was unnecessary in Smalltalk).

Solution 2-5

1

Solution 2-6

3 81 81

Solution 2-7