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