Exercise 13 Self-Study Exercise Sheet

Transcription

1 Concepts of Object-Oriented Programming AS 2017 Exercise 13 Self-Study Exercise Sheet NOTE: This exercise sheet will not be discussed in an exercise session. We publish it now together with the solution to allow you to better prepare for the final exam. If you have any questions regarding this sheet, please consult your assistant. Subtyping and Behavioral Subtyping Task 1 Consider the class X and its only method foo where ZZZ is placeholder for a class name: class X { /// requires x>0 ( i,j: int 2 i,j x i*j=x) /// ensures result>0 result % 2 = 0 int foo(final int x){ return (new ZZZ()).foo(x); Which of the four classes below could be substituted for ZZZ such that no contracts will be violated? (a) class A { /// requires x 0 /// ensures result = x+1 int foo(final int x) {... (b) class B { /// requires true /// ensures result%2 = 0 int foo(final int x) {... (c) class C { /// requires x%2 = 1 /// ensures result = x+1 int foo(final int x) {... (d) class D { /// requires true /// ensures result = x*(x+1) int foo(final int x) {...

2 Inheritance, Dynamic Method Binding, Multiple Inheritance, and Linearization Task 2 Consider the following Java classes and interfaces: public interface IA { IA g(ia x); public interface IB extends IA { IB g(ia x); IA g(ib x); public interface IC extends IA { IC g(ib x); class B implements IB { public IB g(ia x){system.out.print("b1");return null; public IC g(ib x){system.out.print("b2");return null; class C implements IC { public IC g(ia x){system.out.print("c1");return null; public C g(ib x){system.out.print("c2");return null; class Main{ public static void main(string[] args) { B b = new B(); C c = new C(); IA a1 = b; IA a2 = c; IA r1 = a1.g(a2); IA r2 = a2.g(b); IC r3 = b.g(b); IA r4 = c.g(a2); C r5 = c.g(b); What is the output of the execution of the Main.main method? Explain your answer.

3 Bytecode Verification Task 3 Assume two Java classes A and B and assume that B is a subclass of A. Consider the following byte code: 0: aload_1 1: astore_2 2: goto 0 and assume that the input to the initial node of this code is ([],[A,A,B]), where the first list indicates the contents of the stack and the second list indicates the contents of the registers. After running the bytecode type inference algorithm, what is the inferred input to the initial node? (a) ([],[A,A,A]) (b) ([],[A,A,B]) (c) ([],[A,B,B]) (d) Nothing is inferred the type inference does not terminate (e) Nothing is inferred the type inference rejects the program

4 Parametric Polymorphism Task 4 This is an extended version of a previous exam question. Consider the following Java code: interface Food { interface Grass extends Food { interface Meat extends Food{ abstract class Animal<F extends Food> implements Meat{ abstract void eat(f food); F getlunchbag(){ return lunchbag; ; F lunchbag; final class Sheep extends Animal<Grass>{ void eat(grass f){ final class Wolf extends Animal<Meat> { void eat(meat f){ class Cage { //You are allowed to modify this class Cage(Animal<?> animal){ this.animal = animal; Animal<?> getanimal() { return animal; Animal<?> animal; class Zoo{ void feedanimal(cage cage){ /*code given in each section*/ <F extends Food>void feed(f food, Animal<F> animal){animal.eat(food); void manage(){ /*your code here*/ Clearly a Wolf can eat a Sheep but not the other way around. In the following subtasks we explore if relaxing some of the Java type rules can lead to a situation where a Sheep can eat a Wolf - that is, the method eat is called on an object of the dynamic type Sheep with an argument object of the dynamic type Wolf. All the code you give in the answers to the following sections is in the same package as the code above, and must type check in standard Java. The top method that is called in all sections is Zoo.manage. You can assume that method call arguments are evaluated left to right, and that the program is sequential. You are not allowed to use reflection, raw types, or type-casts. A) Assume the following body of Zoo.feedAnimal(Cage cage), which is rejected by the Java type checker: { feed(cage.getanimal().lunchbag,cage.getanimal()); Make a Sheep eat a Wolf assuming the body of feedanimal is exempted from the type checker. Show all necessary code. You are only allowed to change the Cage class and provide the body of the Zoo.manage method. B) Assume the following body of Zoo.feedAnimal(Cage cage), which is rejected by the Java type checker: {feed(cage.animal.getlunchbag(),cage.animal); Can you make a Sheep eat a Wolf if the body of feedanimal is exempted from the type checker? If so, show all necessary code, otherwise explain why not. You are only allowed to change the Cage class, provide the body of the Zoo.manage method, and add new classes.

5 C) Answer the question in the previous section, assuming the field Cage.animal is final. Explain your answer. Reminder: Java s final fields can be assigned to only in the constructor of the class that declares them. D) Assume the following body of Zoo.feedAnimal(Cage cage), which is rejected by the Java type-checker: {feed(cage.animal.lunchbag,cage.animal); Can you make a Sheep eat a Wolf if the body of feedanimal is exempted from the typechecker? If so, show all necessary code, otherwise explain why not. E) Which of the above cases, that is safe in the sequential case, is unsafe in a multithreaded program? For each such case, explain what can happen in the multithreaded case that cannot in the sequential case. F) The current Java rule for evaluating an expression (including a method call) with wildcard typed arguments is to capture each wildcard in the arguments separately. Propose a more lenient wildcard capture rule than current Java, that is typesafe and accept all the above cases that you deem safe. Hint: define "stable" paths that cannot be modified by calls.

6 Information Hiding and Encapsulation Task 5 Suppose that we have a language with the information hiding rules of Java, but with structural subtyping. What should be the subtyping relations between the following three classes? class A {int foo(); class B {protected int foo(); class C {public int foo(); Task 6 Consider the class Hour, defined as follows: public class Hour { protected int h=0; /// invariant h>=0 && h<24 public void set(int h) { if(h>=0 && h<24) this.h=h; What is the external interface of Hour? Can we extend the code, without changing the class, so that the invariant is broken? If yes, provide an example, and propose how to fix the class.

7 Aliasing, Readonly Types, and Ownership Types Task 7 Consider the following class definitions in the context of the read-only type system taught in the course: class C { public D f; void foo(readonly C other) {... class D { E g; class E { Let a and b be non-null references of type C. Which of the following statements is true: (a) The call a.foo(b) is guaranteed not to change the value of b.f, but may change the value of b.f.g (b) The call a.foo(b) is guaranteed not to change the value of b.f and neither the value of b.f.g (c) The assignment other.f.g = new E(); may appear in the code of foo (d) None of the above is correct Task 8 Consider this code, which uses the topological ownership type system and the owners-asmodifiers discipline. Assume that there is no concurrency and reflection is not used. public class Cell { public int value; public Cell(int value) { this.value = value; public final class Some { public final any Cell a; public final peer Cell b; public final rep Cell c; public Some(any Cell a, peer Cell b, int cval) { this.a = a; this.b = b; this.c = new rep Cell(cval); public void foo(peer Other other) { int av = a.value; int bv = b.value; int cv = c.value; other.bar(this) assert av == a.value assert bv == b.value assert cv == c.value // assertion A // assertion B // assertion C

8 public class Other { public void bar(...) {... public class Client { public void client() {... You will have to choose an implementation for the methods Other.bar and Client.client later in this task. A) After the call other.bar(this), the Some.foo method asserts that the values of the three cells have not been changed by the method call. Without knowing anything about the Other.bar method (except that it type-checks), say, for each of the assertions, if it is guaranteed to hold or if it might fail. You do not have to justify your answers. Provide an implementation for the methods Other.bar and Client.client, such that, when the client method is executed, all assertions which are not guaranteed to hold will fail. B) Does any of your answers in part A change if you are also allowed to add arbitrary methods to class Some? Briefly explain your answer. C) In class Other, write a method clonesome which takes a Some instance and returns a copy of it. As a first priority, the method must maximize the amount of sharing between the original and the cloned object. As a second priority, its parameter type should allow as many clients to call it as possible. You may add additional constructors (but not methods) to class Some.

9 Non-null Types and Initialization Task 9 Consider a Java class Vector, representing a 2 dimensional vector: public class Vector { public Number x; // Remark: Number is a super-interface for public Number y; // Integer, Double, etc. public Vector (Number x, Number y) { this.x = x; this.y = y; Suppose that in some other class we write the following method to calculate the length of the vector represented by a Vector object: public double vectorlength(vector c) { double x = c.x.doublevalue(); double y = c.y.doublevalue(); return Math.sqrt(x * x + y * y); A) This implementation is unsafe - when executed it may throw exceptions. Why? Is this a reasonable behavior? B) Add a pre-condition for the method, specifying what is required to be safe. C) Suppose you are allowed to modify the signature of the method to include non-null type annotations. To what extent can you weaken the necessary pre-condition? D) Suppose that you are also allowed to upgrade the class Vector to include reasonable nonnull type annotations. How does this affect your previous answer? Do these changes to the class seem reasonable? Task 10 Consider the following three classes (declared in the same package): public class Person { Dog? dog; // people might have a dog public Person() { public class Dog { Person! owner; // Dogs must have an owner Bone! bone; // Dogs must have a bone String! breed; // Dogs must have a breed public Dog(Person owner, String breed) { this.owner = owner; this.bone = new Bone(this); this.breed = breed;

10 public class Bone { Dog! dog; // Bones must belong to a dog.. public Bone(Dog toown) { this.dog = toown; A)Annotate the code with non-null and construction type annotations where they are necessary. Explain why the code now type-checks according to construction types. B) Could we provide constructors for classes Dog and Bone with no parameters? C) Now, suppose a (possibly mad) scientist wants to extend the implementations of these classes with some genetic engineering. Firstly, we want to be able to clone a bone. We can add the following method to class Bone to make a copy of an existing bone, and assign it to another Dog: public Bone clone(dog toown) { return new Bone(toOwn); However, our scientist would like to go further, and be able to clone dogs. A cloned Dog should also have its bone cloned along with it, but may be assigned to a new owner: we add the following extra constructor and method to class Dog: Dog(Dog toclone, Person newowner) { this.owner = newowner; this.breed = toclone.breed; this.bone = new Bone(this); public Dog clone(person toown) { return new Dog(this, toown); However, our scientist would like to go still further, and be able to clone people. A cloned Person should also have its dog (if any) cloned along with it: we add the following extra constructor and method to class Person: Person(Person toclone) { Dog? d = toclone.dog; if(d!=null) { this.dog = new Dog(d, this); public Person clone() { return new Person(this); Annotate this extra code with appropriate non-null and construction types annotations. You should guarantee that each of the clone methods (which belong to the public interface) return a committed reference. You should ensure that your answers guarantee that all of the code type-checks - explain your choices. Hint: think carefully about how constructor calls are typed, and what happens if the constructors are called in more than one situation.

11 Reflection Task 11 Which of the following is the defining characteristic of reflection? (a) It allows for much simpler code (b) It enables more flexibility (c) It allows a program to observe and modify its own structure and behavior (d) It is not statically safe (e) It may hurt performance (f) None of the above Task 12 Consider the following Java code: void foo() throws java.lang.exeption { LinkedList<String> xs = new LinkedList<String>(); xs.add("a"); xs.add("b"); xs.add("c"); Class<?> c = xs.getclass(); Method remove = c.getmethod("remove"); xs.add(remove.invoke(xs)); which uses the following methods of class LinkedList<E> public E remove() public boolean add(e e) Which of the following statements is true? The invocation of... (a) c.getmethod("remove") is rejected by the compiler (b) c.getmethod("remove") raises an exception (at run time) (c) remove.invoke(xs) is rejected by the compiler (d) remove.invoke(xs) raises an exception (at run time) (e) xs.add(...) is rejected by the compiler (f) xs.add(...) raises an exception (at run time)