Quiz
EECS 2030
Create a free account to finish this quiz
Save your progress and see your final score.
Already have an account? Sign in
Questions in this quiz (39)
1Interfaces and Inheritance- What is an interface?
- Aan abstract class
- Ban abstract class that other classes may extend
- Ca class
- Da class that other classes may extend
- Ea declaration of an API
2 Interfaces and Inheritance- Java supports single inheritance; what does the term single inheritance mean?
- Aevery class has exactly one parent class
- Bevery class has exactly one child class
- Cevery class implements exactly one interface
- Devery class inherits from Object
3Interfaces 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?- AA a = new B();
- BB b = new A(); (*)
- CC c = new B(); (**)
- DC c = new A(); (***)
- EB (*)and C (**)
- FB(*) C(**) D(***)
- GNone of the expression is legal
4Interfaces and Inheritance-Consider the following classes related by inheritance:
Which of the following statements is the most accurate and complete regarding the class C?- AC inherits all of the fields and methods from A
- BC inherits all of the fields and methods from B
- CC inherits all of the fields and methods from A and B 11/28 Q28
- DC inherits all of the fields and methods from A and B and may add its own fields and methods
- EC is made up of an A subobject
- FC is made up of an B subobject
- GC is made up of an A subobject and a B subobject
512/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?- Asuper(size);
- Bthis(size);
- Cthis.setSize(size);
- Dthis.size = size;
6** 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?- Asize is greater than 0 and less than 10
- Bsize is greater than 0 and less than 11
- Csize is greater than 1
- Dsize is greater than -1
- Esize is not equal to 0
7Interfaces and Inheritance-
**REfere to Q29**
Can the AdultCat constructor be safely implemented like so?:
public AdultCat(int size) {
this.setSize(size);
}- Ano, the postcondition of setSize does not guarantee that the class invariant is true
- Bno, setSize is not a final method
- Cyes, setSize can be overridden by child classes
- Dyes, using setSize minimizes code duplication
8Class Features-What is an obligatory method?
- Aa method that can be invoked using any object reference.
- Ba method that the client must invoke, such as a constructor.
- Ca method that the implementer must override.
- Da method that the implementer must not override
9Class Features-What is a class invariant?
- Aa condition that the method promises will be true immediately after the method finishes running
- Ba condition that the method must check at the beginning of the method
- Ca condition that the user (client) must ensure is true before calling the method
- D. a condition that is always true immediately after a constructor or method finishes running
10 Class Features-Which statement is true for a static attribute (or field) of a class X?
- AThe class X has one copy of the attribute for every x object.
- BThe class X has the only copy of the attribute
- CEach X object has its own copy of the attribute
- DOnly objects of classes that extend X have a copy of the attribute.
11Class Features- Suppose that an implementer creates a class that defines no constructors in the class body. Which one
of the following statements is correct?- Athe class must be a utility class
- Bthe class does not compile.
- Cthe class compiles but is not useable.
- Dthe compiler adds a default (no-argument) constructor.
12Class Features- Which of the following is required for objects of a class to be considered immutable?
- Athe class should be declared as final
- Bthe class should have no public mutators
- Call fields in the class should be private
- Dclass methods should not return references to class fields
- Eall of the above
- Fsome of the above
13Class 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;
}- Ax.equals(y) returns true if and only if y.equals(x) returns true
- Bx.equals(null) returns false
- Cx.equals(x) returns true
- Dif x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) returns
true.
14Class 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?- AIn the method body, the implementer has to throw an exception when i is smaller than zero
- BIn the method body, the implementer has to take the absolute value of i to ensure that its
value is greater than or equal to zero. - CIn the method body, the implementer has to set i to zero whenever the value of i is smaller
than zero - DNone of the above
15Class Features- What are the parts of a method signature?
- Amethod name and return type
- Bmethod name and list of parameter types
- Cmethod name, list of parameter types, and return type
- Dmethod name, modifiers, list of parameter types, and return type
16Class Features- What is the difference between x.equals(y) and x == y for two references x and y?
- Ax == y does not compile
- Bequals compares equality of state and == compares equality of addresses
- Cequals compares equality of addresses and == compares equality of state
- Dthere is no difference
17Class Features-What is true about the expression x.compareTo(y) if x is an instance of a type that implements the
comparable interface?- Ax.compareTo(y) returns a postive integer if x is less than y
- Bx.compareTo(y) returns a postive integer if x is equal to y
- Cx.compareTo(y) returns a postive integer if x is greater than y
- Dx.compareTo(y) must return 0 if x is equal to y
18Class 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();- Aa.x = 1;
- Ba.y = 1
- CA.x = 1;
- DA.y = 1;
19Testing- What makes up a unit test for a method in Java?
- Aarguments to the method and the expected result of running the method with the arguments
- Barguments to the method that do not satisfy the preconditions of the method
- Ca program that prints out the result of running the method
- Da program that records the result of running the method
20Testing- What is the main purpose of testing?
- Ato find errors in your code
- Bto make sure that every line of code is necessary
- Cto make sure that every line of code is run at least once
- Dto prove that your code is correct
21Testing- 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?- A89
- B90
- C100
- D101
- Eall of the above
- FA and B
- GA, B, and C
22Testing - 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?- A1
- B2
- C3
- D4
- E5
- F6
- Gall of the test cases fail
- Hnone of the test cases fail
23Testing - 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- A1
- B2
- C3
- D4
- E5
- F6
- Gall of the choices should be used
- Hnone of the choices should be used
24Testing- 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?- Ayou forgot to test the case where x has only negative values
- Byou forgot to test the case where x has only one value
- Cyou forgot to test the case where x has only positive values
- Dyou forgot to test the case where x has values all greater than 10
- Eyou forgot to test the case where x has values all less than 10
- Fyou forgot to test the case where x has some values equal to 10
25Aggregation 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- Aa
- Bb
- Cc
- Dd
26Aggregation 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”- Aan alias
- Ba shallow copy
- Ca deep copy
- Da privacy leak
- Enone of the aboe
27Aggregation and composition- When does a privacy leak occur?
- Awhen the client passes a reference to an object to a constructor or method
- Bwhen an object returns the value of one of its primitive fields
- Cwhen an object returns a reference to one of its immutable fields
- Dwhen an object returns a reference to one of its mutable fields
28Aggregation 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?- Aa constructor
- Ba copy constructor
- Ca method that returns a Widget that is equal to another Widget
- Dan overridden equals(Object obj) method
- Enone of the above
29Aggregation 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 */
}
}- Aan alias for other.cards
- Ba shallow copy of other.cards
- Ca deep copy of other.cards
- Dnone of the above
30Aggregation 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));
}
}- Afalse because deckCards contains different cards than copyCards
- Bfalse because deckCards returns a reference to a different object than copyCards
- Ctrue because deckCards contains the same cards as copyCards
- Dtrue because deckCards returns a reference to the same object as copyCards
31Aggregation 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?- Aany reasonable implementation of getCards will always cause the program to print true
- BgetCards has a privacy leak
- CgetCards returns a shallow copy of this.cards
- Dit is impossible to implement getCards so that the program prints true
32Complexity and Recursion-In plain English, what is the meaning of a big-O complexity O(g(n))?
- Aan estimate of best-case runtime operations of a method to solve a problem of size n
- Ban estimate of the worst-case runtime operations of a method to solve a problem of size n
- Can estimate of the average runtime operations of a method to solve a problem of size n
- Dan estimate of the best-case memory usage for a method to solve a problem of size n
- Ean estimate of the worst-case memory usage for a method to solve a problem of size n
- Fan estimate of the average memory usage for a method to solve a problem of size n
33Complexity and Recursion- If an algorithm has complexity O(n^2) then which of the following statements is the most correct?
- Adoubling the size of the problem does not affect the amount of time needed for the algorithm
to solve the problem - Bdoubling the size of the problem doubles the amount of time needed for the algorithm to
solve the problem - Cdoubling the size of the problem increases the amount of time needed for the algorithm to
solve the problem by 1 unit of time - Ddoubling the size of the problem quadruples the amount of time needed for the algorithm to
solve the problem
- Adoubling the size of the problem does not affect the amount of time needed for the algorithm
34Complexity 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?- AO(1)
- BO(log(n))
- CO(n)
- DO(nlog(n))
- EO(n^2)
35Complexity and Recursion- Whenever a recursive method is called, the method:
- Aalways calls itself at least once
- Balways calls itself zero or more times
- Calways returns a value
- Dnever contains a loop
36Complexity and Recursion- In plain English, what is the meaning of a recurrence relation T(n)?
- AT(n) is the big-O complexity of a recursive method
- BT(n) is the number of elementary operations required by the base case of the method
- CT(n) is the number of elementary operations required by the recursive case of the method
- DT(n) is the number of elementary operations required by the method to solve a problem of
size n
37Complexity and Recursion- What do you expect the Big-O complexity of mergesort to be?
- AO(1)
- BO(log(n))
- CO(n)
- DO(nlog(n))
- EO(n^2)
38Consider 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;
}- AT(0) = T(1) = 0
- BT(0) = T(1) = c for some constant postive integer c
- CT(n) = c for some constant postive integer c
- DT(n) = O(n) where n is the number of elements in the list
39What 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- AT(n) = d for some constant postive integer d
- BT(n) ≈ T(n − 1) + d for some constant postive integer d
- CT(n) ≈ T(n/2) + d for some constant postive integer d
- DT(n) ≈ 2T(n/2) + d for some constant postive integer d
- ET(n) ≈ 2T(n/2) + O(n) for some constant postive integer d
- FT(n) ≈ 2T(n/2) + O(n^2) for some constant postive integer d
Information
- Description
- Set of Final Question
- Author
- Junaid Khan
- Language
- English
- Views
- 166
- History
- Created on 5 Jan 2019 · updated on 17 Jan 2019
- Tags
- Rating
- No ratings yet Rate this quiz