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.
I. Inheritance and Polymorphism
- Explain the differences among public, private, and protected member access specifiers.
Be sure to mention their role in inheritance.
- Explain how inheritance promotes code reuse
- Explain the difference between the "is a" and "uses a" relationships. Give an example
of each from the course projects.
- Explain how Java implements "is a" relationship
- Explain how Java implements "has a" relationship
- Describe the order in which constructors are called when using inheritance.
- Explain the difference between method overriding function overloading.
- Explain the difference between static (early) and dynamic(late) binding.
- Define abstract base class. Give an example from one of the course projects.
- What is meant by the following statement: "Polymorphism refers to the ability to associate many meanings to one method"?
- 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".
- What is the
clone method, and why is it necessary (in the context of polymorphism)?
True/False
- A base class contains all data and methods which are common to all objects
in its inheritance hierarchy.
- In Java inheritance is used to support the "uses-a" relationship between objects.
- Aggregation (composition) is used to support the "has-a" relationship between objects.
- A derived class has direct access to the base class' private data and methods.
- Dynamic binding is performed at run-time when the programmer uses a reference to a base class.
- Polymorphism refers to how identical code can produce different effects
depending on the actual type of the object being processed.
- Polymorphism refers to how structure and behavior can be shared between similar kinds of
objects.
Examine this code, then answer the questions below.
public class Exam2Code
{
public static void main ( String[ ] args )
{
Lot parkingLot;
Car chevy;
Car camry;
MotorCycle harley( 3 );
MotorCycle honda;
ParkingLot.park ( chevy );
ParkingLot.park ( honda );
ParkingLot.park ( harley );
ParkingLot.park ( camry );
System.out.println( parkingLot.toString( ) );
}
}
|
// 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 final int maxVehicles = 20;
public Lot ( )
{
nrVehicles = 0;
vehicles = new Vehicle[maxVehicles];
}
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";
}
}
|
- What features of this code tell you that dynamic binding is taking place?
- What is the output from main() ?
- True/False -- The Vehicle class is an abstract class.
- True/False -- Motorcylce is derived from Vehicle.
- True/False -- Car is derived from Vehicle.
- True/False -- setWheels() cannot be used polymorphically.
- Write the copy constructor for each class.
- When a Car object is created, which constructors are invoked, and in what order?
- What is the purpose of the instance variable
nrVehicles in the Lot class?
- Identify the common coding mistake in
Lot's park method. How would you correct
this coding error?
- In the
Vehicle constructor, what is the purpose of { this( 4 ); } ?
- In the
MotorCycle constructor, what is the purpose of { super( nrWheels); }?
II. Exceptions
- What are the advantages of Java's exception handling technique?
- Briefly explain the throw-try-catch exception mechanism.
- What is the purpose of a
finally block? What kind of operations would typically be
performed there?
- If a
try block has multiple catch blocks, the order in which the catch
blocks are defined is important. Why is this so?
- What is the "Catch or Declare Rule"? How is this rule enforced?
- What's the difference between "checked" and "unchecked" exceptions?
- What guidelines should be followed when defining your own exception classes?
- Name two common RuntimeExcepctions
- What is a
throws clause and when is it needed?
True/False
- Exception classes are different from other classes because they can only contain error messages.
- Only one try block is allowed in a program.
- A try block can have multiple catch blocks.
- Exceptions that are not caught by your program result in a run-time error and core dump.
III. Interfaces
- Define a Java interface
- Explain what it means to say that an interface is also a type
- The
Comparable interface defines the method compareTo.
What are the Comparable interface semantics?
- What is the method header of
compareTo?
- What is an interface inconsistency?
- What is the difference between an abstract class and an interface?
- Write the declaration for an array of objects that implement the
Comparable inteface
True/False
- An interface may only contain method headers
- An interface may not contain instance variables
- An interface may contain (public, static, final) constants
- Interfaces may be extended
- When a class implements an interface it must implement all of
the methods in that interface
- A class can only implement one interface
- The
Comparable interface is often implemented by classes
that require sorting.
- Interfaces are Java's way of simulating multiple inheritance (having more than one base class)
- The compiler enforces the sematics of the
Comparble interface .
IV. Inner Classes
- Define "inner class"
- Describe two advantages of using inner classes
- Why do we often mark inner classes as
private?
True/False
- An inner class has access to the outer class' private members
- An outer class has access to the inner class' private members
- To use methods defined in an inner class, the outer class must create an instance
of the inner class
- What is a static inner class?
- How do static and non-static inner classes differ in the way they interact with the outer class?
- When should an inner class be marked
private? public?
- What is an anonymous class?
V. Text File I/O
- What is a stream?
- What is a text file?
- What class is typically used to write to a text file?
- How is writing to text file similar to displaying output on the user's screen?
Why is this similarity possible?
- What does it mean to say that output files are buffered?
- What does it mean to say that every file used by your program has two names?
- What method should be invoked when your program is finished writing to a file? Why?
- What class is typically used to read from a file?
- How is reading from a text file similar to getting user input from the keyboard?
Why is this similarity possible?
- What mechanism is often used to determine the end-of-file (EOF) condition when reading a text file?
Write a short code snippet to show how this mechanism is implemented.
- What is the difference between an absolute path name and a relative path name?
