Mutation Conceptions

These exercises work with the following two classes:

public class Office {
  String building;
  int room;
  String occupant;

  Office(String building, int room, String occupant) {
    this.building = building;
    this.room = room;
    this.occupant = occupant;
  }
}

public class Building {
  public Office office;

  public Building(Office office) {
    this.office = office;
  }
}

Exercise A

What does calling question1() return?

  public void F1(Office forOffice, String toOccupant) {
    forOffice = new Office(forOffice.building, forOffice.room, toOccupant);
  }

  public String question1() {
    Office carmenOffice = new Office("CS", 176, "Carmen");
    F1(carmenOffice, "Fred");
    return carmenOffice.occupant;
  }

Choices:

Carmen
Fred
Other:
I'm not really sure (explained below)

Exercise B

What does calling question2() return?

public void F2(Office o1, Office o2) {
  o2 = o1;
  o2.room = 63;
}

public String question2() {
  Office labOffice = new Office("CS", 130, "Tyler Smith");
  Office commonOffice = new Office("CS", 275, "everyone");
  F2(labOffice, commonOffice);
  return labOffice.room + ", " + commonOffice.room;
}

Choices:

Exercise C

What does calling question4() return?

public void F4 (Office o1) {
  Building bill = new Building(o1);
  bill.office.room = 999;
}

public int question4() {
  Office peterOffice = new Office("CS", 37, "Peter Gibbons");
  Building cs = new Building(peterOffice);
  F4(peterOffice);
  return cs.building.room;
}

Choices

37
999
Other:
I'm not really sure

Exercise D

What does calling question6() return?

public int f() {
  int x = 17;
  return g();
}

public int g() {
  int y = 4;
  return x / y;
}

public int question6() {
  return f();
}

Choices

0
4
Other
I'm not really sure

Don't go past here until Kathi says so

Memory Diagram Instructions

https://hackmd.io/@csci0200/rJCsizE6K

Don't go past here until Kathi says so

Mutable vs Immutable Lists

Consider the following simple interface for lists:

interface IList<T> {
  public IList addFirst(T newelt);
  public IList addLast(T newelt);
  public int length();
}

Question 1

In your own words, what is the difference between a mutable list and an immutable list? Write no more than 2 sentences.

Question 2

Assume you’re using a class MysteryList that implements IList, but you don’t know whether MysteryList implements mutable or immutable lists. Finish the following test case so that it will pass only if MysteryList implements immutable lists.

public boolean testIsImmutable(Tester t) {
  MysteryList L = 
    new MysteryList().addFirst(9).addFirst(8).addFirst(7);

  // optional additional lines (as many as you want)
  
  assert(_____________, ______________);
}

Question 3

Now assume you are implementing an immutable list class from a chain of Node objects, where the fields are as follows (constructors are omitted for conciseness.

public class ImmutableList<T> implements IList<T> {
  class Node {
    T data;
    Node next;
  }
  Node start; // the first node in the chain/front of list
  Node end;   // the last node in the chain/back of list
  int eltCount;
}

Draw the memory diagram that should exist after running the following line of code (include both environment and heap):

IList L2 = new ImmutableList<String>.addFirst(“brown”).addFirst(“go”);

Circle the diagram you have drawn so far (this will distinguish your diagram on the previous expression from the additions in the rest of the question).

Extend the diagram (outside the circle) to include the expected results of subsequently running the following line of code (we know you don’t have the implementation – the point of the question is for you to show what addLast should do on an immutable list).

IList L3 = L2.addLast(“bears”);