EECS 2030

Interfaces and Inheritance- What is an interface?

Interfaces and Inheritance- Java supports single inheritance; what does the term single inheritance mean?

Interfaces and Inheritance- Consider the following classes related by inheritance:
See Figure: pg 11 of 28
Question 27
Assuming A, B, and C all have public no-argument constructors, which of the following variable definitions are legal?

Interfaces and Inheritance-Consider the following classes related by inheritance:
Which of the following statements is the most accurate and complete regarding the class C?

12/28 Q29.
Consider the following two classes related by inheritance:
public class AdultCat {
private int size; /* INVARIANT: this.size > 0 && this.size <= 10 */
public AdultCat(int size) {
/* IMPLEMENTATION NOT SHOWN */
}
/**
* Sets the size of this cat to be equal to sz. If sz is greater than 10
* then the size of this cat is set to some value between 1 and 10.
*
* @param sz the desired size of this cat
* @pre. sz is greater than 0
*/
public void setSize(int sz) {
/* IMPLEMENTATION NOT SHOWN */
}
}
public class Lion extends AdultCat {
public Lion(int size) {
/* MISSING STATEMENT */
}
/**
* Sets the size of this cat to be equal to sz. If sz is greater than 10
* then /* MISSING POSTCONDITION */
*
* @param sz the desired size of this cat
* @pre. /* MISSING PRECONDITION */
*/
@Override
public void setSize(int sz) {
/* IMPLEMENTATION NOT SHOWN */
}
}

What can the line with the comment /* MISSING STATEMENT */ be replaced with in the Lion constructor?

** REFER TO Q29.
Interfaces and Inheritance
- The precondition of the Lion version of setSize is incomplete (ends with
/* MISSING PRECONDITION */); which of the following can be used to complete the precondition
so that Lion is substitutable for AdultCat?

Interfaces and Inheritance-
**REfere to Q29**
Can the AdultCat constructor be safely implemented like so?:
public AdultCat(int size) {
this.setSize(size);
}

Class Features-What is an obligatory method?

Class Features-What is a class invariant?

Class Features-Which statement is true for a static attribute (or field) of a class X?

Class Features- Suppose that an implementer creates a class that defines no constructors in the class body. Which one
of the following statements is correct?

Class Features- Which of the following is required for objects of a class to be considered immutable?

Class Features- The class MyBoolean has a single attribute named value of type boolean. Consider the following
implementation of the equals method:

public boolean equals(Object object) {
boolean equals;
if (object != null && this.getClass() == object.getClass()) {
MyBoolean other = (MyBoolean) object;
equals = this.value && other.value;
}
else {
equals = false;
}
return equals;
}

Class Feature- Consider the following code fragment:
/**
* This method does something
*
* @param i an integer
* @pre. i>=0
*/
public void method(int i) {
/* method body not shown */
}
Which of the following statements is correct?

Class Features- What are the parts of a method signature?

Class Features- What is the difference between x.equals(y) and x == y for two references x and y?

Class Features-What is true about the expression x.compareTo(y) if x is an instance of a type that implements the
comparable interface?

Class Features- Consider the following class:
public class A {
public static int x = 0;
public int y;
public A() {
this.y = 0;
}
}
Suppose that you have a reference of type A:
A a = new A();

Testing- What makes up a unit test for a method in Java?

Testing- What is the main purpose of testing?

Testing- Consider the following method that determines if a numeric grade is equivalent to a letter grade of A+:
/**
* Returns true if the specified grade is equivalent to a letter grade
* of A+. A numeric grade greater than or equal to 90 is an A+.
*
* @param grade a numeric grade
* @returns true if grade is equivalent to A+ and false otherwise
* @pre. grade is less than or equal to 100
*/
public static boolean isAPlus(int grade) {
// IMPLEMENTATION NOT SHOWN
}
Which of the following values of grade would be considered as boundary cases for the method isAPlus?

Testing - Consider the following class that represents a temperature in degrees Celcius or degrees Fahrenheit:
public class Temperature {
private double degrees;
private String units; // INVARIANT: this.units is equal to "C" or "F"

public Temperature() {
this.degrees = 0.0;
this.units = "C";
}
/**
* Changes the units of this temperature to the specified units
* if the specified units is equal to "C" or "F", otherwise leaves
* the current units of this temperature unchanged.
*
* @param the desired units of this temperature
*/
public void setUnits(String units) {
if (units == "C" || units == "F") {
this.units = units;
}
}
public void getUnits() {
return this.units;
}
}
Consider the following unit test for setUnit:
@Test
public void test_setUnits() {
String units = /* SEE TABLE BELOW */
String expected = /* SEE TABLE BELOW */
Temperature t = new Temperature();
t.setUnits(units);
assertEquals(expected, t.getUnits());
}
Test case units expected
See test cases on pg 5/28 question 15

Which test case fails?

Testing - Consider the following class that represents a two-dimensional point having an x-coordinate and a
y-coordinate.
public class Point2 {
private int x;
private int y;
public Point2(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object obj) {
// implementation not shown
}
}
equals is implemented using the guidelines discussed in class, and two points are considered equal if
their x components are equal and their y components are equal. Consider the following unit test cases
for equals:

See table: question 16 pg 6/28

Testing- Suppose that you want to compute the average of all of the values that are greater than 10 in a list x.
You implement the following method:
/**
* Returns the average of all values greater than 10 in the list x.
*
* @param x a list
* @return the average of all values greater than 10 in the list x
* @pre. x.size() > 0
*/
public static double avg(List<Double> x) {
double avg = 0.0;
int n = 0;
for (int i = 0; i < x.size(); i++) {
double xi = x.get(i);
if (xi > 10.0) {
n = n + 1;
avg = avg + xi;
}
}
return avg / n;
}
After testing your code, you are convinced that it is correct and you give it to your friends to use in
their project. A couple of weeks later, your friends tell you that they did poorly on their project because
of your code. What went wrong?

Aggregation and composition- Consider the following class that represents a line segment connecting two points (its start point and
its end point):
public class LineSegment {
private Point2 start;
private Point2 end;
public Line(Point2 p1, Point2 p2) {
this.start = p1;
this.end = p2;
}
}

See the diagram

Aggregation and composition- In the LineSegment class from the previous question(q18), the constructor contains the line:
this.start = p1;
Which choice below best completes the following statement: “this.start is for p1”

Aggregation and composition- When does a privacy leak occur?

Aggregation and composition- Suppose that you want to make a shallow copy of a List<Widget> object where Widget is some
class. What public feature does Widget need to provide for you to make a shallow copy of the list?

Aggregation and composition- Consider the following class
public class DeckOfCards {
private Set<Card> cards; /* the only field in DeckOfCards */
public DeckOfCards() {
/* IMPLEMENTATION NOT SHOWN but sets this.cards to be equal to
standard deck of 52 playing cards */
}
public DeckOfCards(DeckOfCards other) {
this.cards = new HashSet<>();
for (Card card : other.cards) {
this.cards.add(card);
}
}
public Set<Card> getCards() {
/* IMPLEMENTATION NOT SHOWN but returns either:
an alias to this.cards OR
a new copy of this.cards */
}
}

Aggregation and composition- Consider the following class that uses DeckOfCard from Question 22:
public class Test {
public static void main(String[] args) {
DeckOfCards deck = new DeckOfCards();
DeckOfCards copy = new DeckOfCards(deck);
Set<Card> deckCards = deck.getCards();
Set<Card> copyCards = copy.getCards();
System.out.println(deckCards.equals(copyCards));
}
}

Aggregation and composition- Consider the following class that uses DeckOfCard from Question 22:
public class Test {
public static void main(String[] args) {
DeckOfCards deck = new DeckOfCards();
Set<Card> deckCards = deck.getCards();
System.out.println(deckCards == deck.getCards());
}
}
Suppose that the program above prints true; what is the most likely statement regarding the method
getCards?

Complexity and Recursion-In plain English, what is the meaning of a big-O complexity O(g(n))?

Complexity and Recursion- If an algorithm has complexity O(n^2) then which of the following statements is the most correct?

Complexity and Recursion- Consider the following implementation of the set method on a singly linked-list:
/**
* Sets the element stored at the given index in this linked list.
* Returns the old element that was stored at the given index.
*
* @param index the index of the element to set
* @param elem the element to store in this linked list
* @return the old element that was stored at the given index
* @throws IndexOutOfBoundsException if (index < 0) || (index > size)
*/
public char set(int index, char elem) {
if (index < 0 || index >= this.size) {
throw new IndexOutOfBoundsException();
}
Node n = this.head;
for (int i = 0; i < index; i++) {
n = n.next;
}
char oldData = n.data;
n.data = elem;
return oldData;
}
What is the Big-O complexity for this method?

Complexity and Recursion- Whenever a recursive method is called, the method:

Complexity and Recursion- In plain English, what is the meaning of a recurrence relation T(n)?

Complexity and Recursion- What do you expect the Big-O complexity of mergesort to be?

Consider the following recursive implementation of a merge sort (pseudocode only):
public static LinkedList<Integer> mergeSort(LinkedList<Integer> t) {
if (t.size() <= 1) {
return t;
}
LinkedList<Integer> left = mergeSort(t.sublist(0, t.size() / 2) );
LinkedList<Integer> right = mergeSort(t.sublist(t.size()/2 + 1, t.size() );
LinkedList<Integer> result = merge(left,right);
return result;
}

What is the recurrence relation for mergesort for the recursive case where n is the number of elements
in the list? Note: you may assume the merge method has a complexity of O(n); and the value of n/2 is
computed using integer division