Missed Questions on Inheritance/Polymorphism Test

Which of the following statements is true about both an interface and an abstract class?

Consider the following instance variable and method from a class.
 
 ArrayList<String> nameList;
 
 public String getItem(int loc)
{
 if(loc == nameList.size() – 1)
  return nameList.get(loc);
  else
 {
 String temp = getItem(loc+1);
  String thisOne = nameList.get(loc);
  if(temp.compareTo(thisOne) < 0)
 return temp;
 else
 return thisOne;
 }
}
 Assume that nameList has been initialized as shown below.
  
nameList --> | Harry | Chris | Barbara | Peter | John |
 
 
Which of the following is returned by the call getitem(0)?

Consider the incomplete method ChoiceOfThree.
 
 public int choiceOfThree()
{
 // missing code
}
  
Method choiceOfThree is intended to return one of the values 1, 2, 3, each with probability 1/3. Consider the following replacements for//missing code.
  
I. return (int)(Math.random() * 3); 
II. return (int)(Math.random() * 3) + 1;
 III. if(Math.random() < 1.0/3.0)
  return 1;
  else if (Math.random() < 2.0/3.0)
   return 2;
 else
   return 3;
 Which if these replacements for //missing code will make choiceOfThree work as intended?

The following code segment is intended to sum compute the product of the first five odd integers.
 
 product = 1;
 for(int k = 0; k < 5; k++)
  product = product * (2*k + 1);
 
 Which of the following best describes the error, if any, in this code.

Consider the following declarations.
 
 public class Book
{
  private String myTitle;
  private int myNumPages;
 
  public int numPages()
 {
 return myNumPages;
 }
 // constructors and other methods not shown
}
 
 ArrayList<Book> readingList;
  
Assume that readingList has had several books added to it. Consider the following code segments.
 
  I. int sum = 0;
 for(Book bk: readingList)
  sum += bk.numPages();
 
  II. int sum = 0;
 for(int k = 0; k < readingList.size(); k++)
  sum += readingList.get(k).numPages();
 
   III. int sum = 0;
 int k = 0;
  while(k < readingList.size())
 {
  sum += readingList.get(k).numPages();
  k++;
 }
 
 Which of these code segments correctly calculates sum to be the total number of pages of books in readingList?

Consider the following partial declarations. 
 public class Direction 
{  private int degrees; public Direction(int deg) {degrees = deg; System.out.println("direction "); }                                          
  ...                   }                                                     
public class Location                    
{
  private double xLoc, yLoc;            
  public Location(double x, double y)   
  {                                       
    xLoc = x;                             
    yLoc = y;                                             
    System.out.println("location ");      
  }                                         
  ...                                        
}                                                                                                                                                                 
public class Car
{
  private Direction dir;
  private Location loc;
  public Car(Direction d , Location l)
  {
    dir = d;
    loc = l;
    System.out.println("car");
  } 
public class RaceCar extends Car
 {
  private double speed;
  public RaceCar(Direction d, Location l, double sp)
   {
    super(d, l);
    speed = sp;
    System.out.println("race-car");
   }
  ... 
} Consider the statement
 
 RaceCar TSX = new RaceCar(new Direction(90), new Location(5, 8), 160);
 
 What is printed when this statement is executed?

A class Tach has a method rpm() that returns an integer. Consider the following method from the same class. 
 // precondition: 0 < caution < danger 
// postcondition: return "green" if rpm is less than caution;
 // return "yellow" if rpm is greater than or equal to caution and
// less than danger
 // return "red" if rpm is greater than or equals to danger 
public string indicator(int caution, int danger)
{
 // missing code
}
 The method indicator is intended to return "green" if rpm() returns a value less than caution, to return "yellow" if rpm()returns a value greater than or equal to caution and less than danger, to return "red" if rpm()returns a value greater or equal to danger. Consider the following replacement for//missing code.
 
  I.  if(rpm() < caution)
  return "green";
 else if(caution <= rpm() < danger)
  return "yellow";
 else
  return "red";
 
  II. if(rpm() < caution)
  return "green";
 if(rpm() >= danger)
  return "red";
 return "yellow";
 
  III. if(rpm() < caution)
  return "green";
 else if(rpm() >= danger)
  return "red";
 else
  return "yellow";
 
 Which of these replacements for //missing code would make the method indicator work as intended?


Consider the following declaration  
public class CD
{
  private String[] songs;
 
  public getSong(int k)
 { return songs[k]; }
 
 // constructor and other methods not shown
}
  
ArrayList<CD> CDCollection;
  
Assume that CDCollection has been initialized and several CD 's have been added to it. Which of the following can be used in a client program to reference the third song on the fifth CD in the collection?

"class Aggregate" is incorrect.  Choose the correct line so that this program prints
     Granite: weight=25.0 value=4 numKind=7
       public class Inherit
     {
             abstract class Stone 
           {
                    protected float weight = 13;
                    protected int  value  = 4;
                    abstract public String toString( );
            }
            class Aggregate
           { 
                   protected int numKind;
           }
            class Granite extends Aggregate
            {
                   Granite( ) 
                   {
                           weight = 25; numKind = 7;
                   } 
                   public String toString( ) 
                   {
                           return "Granite: weight="
                               + weight + " value="
                               + value  + " numKind="
                               + numKind;
                    }
            }
            Inherit( )
           {
                    Granite g = new Granite( );
                    System.out.println(g); 
           }
             public static void main(String[ ] args)
           {
                   new Inherit( );
           }
     }

Assume the following partial declarations have been made, with default (no parameter) constructors for the classes.
 
public abstract class Player 
public class ComputerPlayer extends Player;
 public class SmartComputerPlayer extends ComputerPlayer;
 
 Consider the following declarations.
 
 I. ComputerPlayer playerA = new SmartComputerPlayer();
 II. Player playerB = new SmartComputerPlayer(); 
III. Player playerC = new Player();
 
 Which of these declarations will compile correctly?

private ArrayList<String> list;
 
 public void change()
{
 String str = list.get(list.size() – 1);
 
  for(int k = list.size() - 1; k > 0; k--)
  list.set(k, list.get(k-1));
 
  list.set(0, str);
}
 
 Consider following replacements for the entire body of method change.
  
I. list.add(list.remove(0));
  
II. list.add(0, list.remove(list.size() – 1));
 
 III. String str = list.get(0);
 for(int k = 1; k < list.size() – 1; k++)
  list.set(k, list.get(k+1));
 list.set(list.size() -1, str);
 Which of these replacements would result in an equivalent method?

Consider the following data field and partially defined method.
 
 private ArrayList<String> people; 
public void removeDups(String target)
{ // code not shown }
 
 The method removeDups is intended to remove all instances of target that occur in people except the first, leaving the first instance in the same relative position. Which of the following correctly implements the method removeDups?

Assume that isHigh(), isBack(), and isLeft() are three boolean methods. Consider the following expression.
 
  (isHigh() && isBack()) || (isHigh() && isLeft())
 
 Which of the following is equivalent to the given expression?

public void sort(double[] list)
{
  for(int start = 1; start < list.length; start++)
  {
 double temp = list[start];
  int k = start;
  while(k > 0 && list[k-1] > temp)
  {
 list[k] = list[k-1];
 k++;
 }
 list[k] = temp;
  } 
} Assume the array values is initialized as shown below.

 values | 5.0 | 1.0 | 3.0 | 8.0 | 4.0 | 6.0 | 2.0 | 


Which of the following best represents the array word after the fourth pass through the outer loop in the call sort(values)?

Consider the following description. A Kennel has animals. Animals come and go from the kennel, so the number there varies. A dog is an animal. A cat is an animal. Which of the following partial declarations is the best choice for representing the relationships among these things?


A certain application needs to store three types of object. Each type has a common method, rating(), that returns a double between 0.0 and 1.0. Otherwise the different types of object have different characteristics and behavior. The application needs to store many objects of these three types so that they can easily be accessed in order of their ratings. Assume that the three types will be defined by three classes: TypeA, TypeB, TypeC. Which of the following is the best design for this application?