Last name:... First name:... Department (if not D-INFK):...

Transcription

1 Concepts of Object-Oriented Programming AS 2016 Concepts of Object-Oriented Programming Midterm Examination Prof. Dr. Peter Müller Last name: First name: Student ID number: Department (if not D-INFK): I confirm with my signature, that I was able to take this exam under regular circumstances and that I have read and understood the directions below. Signature: Read completely and carefully the following instructions before starting to work on the exam: 1. Write your last and first name on every page that contains parts of your s. Use a ballpoint pen or a fountain pen (no pencil). Do not use a red pen. Return the instructions, the tasks, and your s. 2. It is neither allowed to use your own papers, documents, scripts, etc., nor any electronic equipment (notebook computers, calculators, cell phones, etc.) 3. Write all of your s in English. 4. Explain your s carefully if a task asks for an explanation. 5. You have 1 hour to complete the exam. SOLUTION 6. Place your student ID on the desk. Task Total Max. points Achieved Good Luck!

2 COOP Midterm Exam AS 2016 Name: 2/11 Task 1 Multiple Choice - 10 points In all of the following questions exactly one answer is correct. To get points, you need to mark only the correct answer. In all other cases you will get no points. A (3 points) Subtyping and Inheritance Imagine extending the syntax of the Java language to support the following keywords: subtypes: used to declare that a class is a subtype of another class (without inheritance) inherits: used to declare that a class inherits form another class (without subtyping) Now consider the following classes: class A { public int foo (int n) { return n - 1; class B { public int foo (int n) { return n + 1; public int bar (int n) { return foo(n) - 1; class C inherits A subtypes B { public int bar (int n) { return foo(n); class Main { public static void main(string[] args) { B b = new C(); System.out.println( b.bar(3) ); What would happen if we tried to compile the code and execute method main in class Main? (a) The code will be rejected by the compiler (b) The code will compile but the execution will fail (c) CORRECT: The code will compile and print 2 (d) The code will compile and print 4 (e) None of the above Answer: a b c d e

3 COOP Midterm Exam AS 2016 Name: 3/11 B (3 points) Linearization Consider the following Scala code: class A { def foo() = "A" trait B extends A { override def foo() = "B" + super.foo() trait C extends A { override def foo() = "C" trait D extends A with C { override def foo() = "D" + super.foo() object Main { def main(args:array[string]) { foo(new A with D with B) def foo(x:a with C) { println(x.foo()) Which of the following statements is true? (a) The linearization of new A with D with B is B -> C -> D -> A (b) D is not a subtype of C (c) CORRECT: The output of the call Main.main() will be BDC (d) foo(new A with D with B) does not type check (e) None of the above Answer: a b c d e

4 COOP Midterm Exam AS 2016 Name: 4/11 C (4 points) Bytecode Verification Assume three Java classes A, B, and C and assume that B and C are direct subclasses of A. The method f of class B has the following signature: void f(c c, int i); The maximal stack size is equal to 1. Consider the following Java bytecode for the body of method f: 0: iload 2 1: ifeq 4 2: aload 1 3: astore 0 4: aload 1 5: astore 2 6: aload 0 7: astore 2 8: goto 6 After running the bytecode type inference algorithm, which of the following is true? (a) The inferred input to instruction 4 is ([],[B,C,int]). (b) CORRECT: The inferred input to instruction 4 is ([],[A,C,int]). (c) The bytecode cannot be verified due to a stack overflow. (d) The bytecode cannot be verified due to a stack underflow. (e) None of the above. Answer: a b c d e

5 COOP Midterm Exam AS 2016 Name: 5/11 Task 2 A (3 points) Behavioral Subtyping - 15 points Let X be a class with a single method m: class X { /// requires a > b /// ensures result >= b int m(final int a, final int b) {... Moreover, let Y be a class that extends class X and overrides method m: class Y extends X { /// requires P Y /// ensures Q Y override int m(final int a, final int b) {... Assume that there is no specification inheritance. Which of the following choices of precondition P Y and postcondition Q Y permit Y to be a behavioral subtype of X? Per choice, it suffices to answer with yes or no. 1. P Y : b - a <= 0 Q Y : result > b 2. P Y : 0 < a - b Q Y : result > b 3. P Y : a >= b Q Y : result >= a && a >= b 4. P Y : a^2 >= b^2 Q Y : result > a + b 5. P Y : false Q Y : true 6. P Y : true Q Y : false 1. Yes (Pre: yes, Post: yes) 2. Yes (Pre: yes, Post: yes) 3. Yes (Pre: yes, Post: yes) 4. No (Pre: no, Post: no) 5. No (Pre: no, Post: no) 6. Yes (Pre: yes, Post: yes) B (12 points) Consider the following class definitions (whose pre- and postconditions you will have to choose in the remainder of this task): class A { int f; /// requires P A /// ensures Q A void foo(final int n) {... class B extends A {

6 COOP Midterm Exam AS 2016 Name: 6/11 /// requires P B /// ensures Q B void foo(final int n) {... class C extends B { /// requires P C /// ensures Q C void foo(final int n) {... This task is concerned with the dynamic checking (i.e., runtime checking) of behavioral subtyping. In each subtask a dynamic check is suggested that is to be performed whenever a method is called. You have to decide whether or not these checks give the same guarantees as behavioral subtyping to method implementers and method clients for the given call. The dynamic checks are suggested in the context of a client that uses method foo. If you conclude that the suggested checks are sufficient, simply say so (no explanation is required). If not, you must (1) provide concrete contracts (for foo) and code (for foo and/or the client) to illustrate that a runtime error can occur because the checks do not suffice to enforce behavioral subtyping, and (2) clearly mark the location where you expect the runtime error. B.1 Consider the following client: B b =... // Dynamic check: check the precondition of foo // for the static type of b... Does checking the precondition of the static type of b.foo guarantee that can be executed successfully if the code relies on behavioral subtyping? (Postconditions are irrelevant for this question.) // Let P B be 0 <= n // Let P C be 0 < n // class C void foo(final int n) { this.f = 0/n // client B b = new C() // Error: division by zero alternative : // Let P B be 0 < n // Let P C be 0 <= n // client B b = new C() // Incorrectly rejected by the suggested runtime check, // although behavioural subtyping is adhered too B.2

7 COOP Midterm Exam AS 2016 Name: 7/11 Consider the following client: B b =... // Dynamic check: check the postcondition of foo // for the dynamic type of b... Does checking the postcondition of the dynamic type of b.foo guarantee that the remainder of the client code can be executed successfully if the code relies on behavioral subtyping? (Preconditions are irrelevant for this question.) // Let Q B be 0 < this.f // Let Q C be 0 <= this.f // client B b = new C() int n = 0/b.f // Relies on B.foo s postcondition // Error: division by zero B.3 Consider the following client: B b =... // Dynamic check: check the postcondition of foo // for each type in the type hierarchy // from and including the dynamic type of b // up to and including the static type of b.... Does checking these postconditions guarantee that the remainder of the client code can be executed successfully if the code relies on behavioral subtyping? (Preconditions are irrelevant for this question.) // Let Q A be 0 < this.f // Let Q B be 0 <= this.f // client B b = new B() if (b instanceof A) { A a = (A) b int n = 0/a.f // Relies on A.foo s postcondition // Error: division by zero

8 COOP Midterm Exam AS 2016 Name: 8/11 Task 3 Multiple Inheritance - 13 points Consider the following C++ code (recall that default constructors, i.e., constructors without arguments, do not need to be called explicitly in C++): class A { public: A(int i) { std::cout << "A" << i; A() { std::cout << "A1"; virtual int get() {... ; class B: MODIFIER A { public: B(int i) : A(i) { std::cout << "B" << i; ; class C: MODIFIER A { public: C(int i) : A(i) { std::cout << "C" << i; ; class D: public B, public C { public: D(int i) : B(i + 10), C(i + 20) { std::cout << "D" << i; ; Now assume that MODIFIER is replaced by public. A (2 points) Why does the following client code not compile? void client() { D* d = new D(5); std::cout << d->get(); d->get() is ambiguous because class D inherits two versions of A (and therefore get()), one from B and one from C. B (3 points) Add a method to one of the classes so that client compiles. Override D::get() to refer to B::get() C (4 points) What is the output resulting from the call new D(5) in method client? A15B15A25C25D5

9 COOP Midterm Exam AS 2016 Name: 9/11 D (4 points) Now, assume that MODIFIER is replaced by public virtual. What is the new output resulting from the call new D(5) in method client? A1B15C25D5

10 COOP Midterm Exam AS 2016 Name: 10/11 Task 4 A (8 points) Generics - 12 points Recall the Java interface Comparable<T> that was shown in the lecture: public interface Comparable<T> { public int compareto(t other); 1 if this is greater than other The method compareto returns 0 if this is equal to other 1 if this is less than other Suppose we want to turn Comparable into an abstract class with an additional helper method greaterthan, that returns true if and only if this is greater than other. Assume the following implementation: public abstract class Comparable<T> { public abstract int compareto(t other); public boolean greaterthan(t other) { return other.compareto(this) < 0; A.1 Why does this implementation not type check? T requires an upper bound that provides compareto. A.2 Fix the type error by changing only the body of greaterthan, while preserving the intended semantics of the method. return this.compareto(other) > 0. A.3 Fix the type error by changing only the class signature and the signature of method compareto. Let the class signature be Comparable<T extends Comparable<T>> and the signature of compareto be compareto(comparable<t> other). B (4 points) Suppose we have the following class: class A<X,Y > { X a; Y b;

11 COOP Midterm Exam AS 2016 Name: 11/11 Consider a variable v whose type is A<S,T> where S and T satisfy the type bounds that you have to insert above. Your type bounds have to guarantee that for all sequences of a and b accesses on v (e.g., v.b.a.b.a.a.b.b) the following two properties hold: The static type of a sequence ending in a is S. The static type of a sequence ending in b is T. class A<X extends A<X,Y>,Y extends A<X,Y>> { X a; Y b;