Exam 2 Review Questions

Picture ID is REQUIRED for all exams

Use the list of questions below as a guide when studying for Exam 2. It is by no means a comprehensive list of questions.

You are responsible for all material presented in lecture. You are also responsible for all associated reading assignments and material covered in lab.

Answering the applicable "self-test" questions in each chapter of the text is also a good way to review. The answers to the self-test questions are found at the end of each chapter.

DO NOT EXPECT to see these specific questions on your exam.
    I. Vocabulary List
    Be able to define these words and use them in the proper context.
  1. base class
  2. super class
  3. derived class
  4. subclass
  5. protected
  6. inherited, inheritance
  7. polymorphism
  8. extends
  9. method overriding
  10. exception class
  11. try, throw, catch, finally
  12. copy constructor, clone
  13. "is a type of"
  14. final
  15. Object class
  16. binding, early binding, late binding, dynamic binding
  17. abstract class, abstract method
  18. super( )

    19. II. Inheritance and Polymorphism
  19. Explain the differences among public, private, and protected member access specifiers. Be sure to mention their role in inheritance.
  20. Explain how inheritance promotes code reuse
  21. Explain the difference between the "is a" and "has a" relationships. Give an example of each from the course projects.
  22. Explain how Java implements "is a type of" relationship
  23. Explain how Java implements "has a" relationship
  24. Give a real life example (other than those used in class) for which inheritance would be appropriate
  25. For the following questions, assume that class D extends class B, that D has some of its own instance variables, some of its own instance methods, and overrides some of B's instance methods.
    1. Which of the two classes is the more general class?
    2. Which of the two classes is the more specific class?
    3. Can the toString() method defined in D call the toString( ) method defined in B? If not, why not. If so, how?
  26. Describe the order in which constructors are called when using inheritance.
  27. Explain the difference between method overriding and method overloading.
  28. Why is method overrding an essential part of polymorphism?
  29. Explain the difference between static (early) and dynamic(late) binding.
  30. What is meant by the following statement: "Polymorphism refers to the ability to associate many meanings to one method"?
  31. In the context of polymorphism, what is meant by the following statement: "The reference type defines which methods may be invoked, but the type of the object defines which implementation is executed".
  32. What is the clone method, and why is it necessary (in the context of polymorphism)?
  33. Explain the statement: "Inheritance allows class similarities to be shared while still allowing for class differences"
  34. What impact does the existance of Object have (if any) when implementing classes?
  35. Explain the statement, "Private methods are effectively not inherited".
  36. What does the keyword super represent? Give one example of its use.

    37. True/False

  37. A base class contains all data and methods which are common to all objects in its inheritance hierarchy.
  38. In Java inheritance is used to support the "is a type of" relationship between objects.
  39. Aggregation (composition) is used to support the "has-a" relationship between objects.
  40. A derived class has direct access to the base class' private data and methods.
  41. Dynamic binding is performed at run-time when code uses a reference to a base class to invoke a method.
  42. In Java, dynamic binding is used for all methods.
  43. A class labeled as final cannot be used as a base class.
  44. Polymorphism refers to how identical code can produce different effects depending on the actual type of the object being processed.
  45. Polymorphism refers to how structure and behavior can be shared between similar kinds of objects.
  46. When a derived class is instantiated, its base class no-argument constructor is called whether or not an explicit call to super( ) is made.
  47. When implementing a derived class' copy constructor. its base class copy constructor is automatically called where or not an explicit call to super( ) is made.

    48. Examine this code, then answer the questions below. 

    public class Exam2Code
{
  public static void main ( String[ ] args )
  {
    Lot parkingLot;

    Car chevy = new Car( );
    Car camry = new Car( );
    MotorCycle harley = new MotorCycle(3);
    MotorCycle honda = new MotorCycle( );

    parkingLot.park ( chevy );
    parkingLot.park ( honda );
    parkingLot.park ( harley );
    parkingLot.park ( camry );

	System.out.println( parkingLot );
  }
}

    // Vehicle class
public class Vehicle
{
  public Vehicle( )
	{ this(4); }
  public Vehicle (int nrWheels)
	{ setWheels(nrWheels); }
  public String toString (  )
   	{ System.out.println( "Vehicle with " 
		+ getWheels( ) + " wheels"); }
  public int getWheels ( )
   	{ return nrWheels; }
  public void  setWheels (int wheels)
   	{ nrWheels = wheels; } 
        
  private int nrWheels;
}

    // Parking Lot class

public class Lot
{
  private static final int MAX_VEHICLES = 20;
  public Lot (  )
  {
    nrVehicles = 0;
    vehicles = new Vehicle[MAX_VEHICLES];
  }
  public int nrParked (  )
	{ return nrVehicles; }
  public void park (Vehicle v)
	{ vehicles[ nrVehicles++ ] = v; }
  public int totalWheels ( )
  { 
    int nrWheels = 0;
    for (v = 0; v < nrVehichles; v++ )
      nrWheels += vehicles[ v ].getWheels( );
    return nrWheels;
  }
  public String toString( )
  { 
    String s = "";
    for ( v = 0; v < nrVehicles; v++ )
      s += vehicles[ v ].toString( ) + "\n"; 

    return s;
  }
 
  private int nrVehicles;
  private Vehicle [] vehicles;
}

    // MotorCycle class
public class MotorCycle extends Vehicle
{
  public MotorCycle ( )
    { this(2); }
  public MotorCycle( int wheels )
    { super(wheels); }
}

//===================

// Car class
public class Car extends Vehicle
{
  public Car ( )
     { super(4); }
  public String toString( )
  {
    return "Car with " + getWheels( ) + " wheels";
  }
}

  48. What feature(s) of this code tell you that dynamic binding is taking place?
  49. What is the output from main( ) ?
  50. True/False -- The Vehicle class is an abstract class.
  51. True/False -- Motorcylce is derived from Vehicle.
  52. True/False -- Car is derived from Vehicle.
  53. True/False -- setWheels( ) cannot be used polymorphically.
  54. Write the copy constructor for each class.
  55. Write the clone( ) method for each class (assuming the copy constructor exists)
  56. When a Car object is created, which constructors are invoked, and in what order?
  57. What is the purpose of the instance variable nrVehicles in the Lot class?
  58. Identify the common coding mistake in Lot's park method. How would you correct this coding error?
  59. In the Vehicle constructor, what is the purpose of { this( 4 ); } ?
  60. In the MotorCycle constructor, what is the purpose of { super( nrWheels); }?
  61. Car's toString( ) methods invokes getWheels( ), even though getWheels( ) is not defined in the Car class. How is this possible?

    62. III. Exceptions
  62. What are the advantages of Java's exception handling technique?
  63. Briefly explain the throw-try-catch exception mechanism.
  64. What is the purpose of a finally block? What kind of operations would typically be performed there?
  65. If a try block has multiple catch blocks, the order in which the catch blocks are defined is important. Why is this so?
  66. What is the "Catch or Declare Rule"? How is this rule enforced?
  67. What's the difference between "checked" and "unchecked" exceptions?
  68. What guidelines should be followed when defining your own exception classes?
  69. Name two common RuntimeExcepctions
  70. What is a throws clause and when is it needed?

    71. True/False

  71. Exception classes are different from other classes because they can only contain error messages.
  72. Only one try block is allowed in a program.
  73. A try block can have multiple catch blocks.
  74. Exceptions that are not caught by your program result in a run-time error and core dump.