Computer Science Department   
Advancement Exam Information Page

EXAM ENVIRONMENT:

• Windows XP Professional Operating System
• Editors
• JEdit(syntax highlighting)
• JGrasp(syntax highlighting and includes a debugger)
• Notepad
• JDK 6.0 (1.6.x)
• Java API documentation
• No Internet access
• No notes or texts allowed

EXAM SPECIFICS

The Computer Science Department has determined that the distribution of points within the exam will be as follows:

• General Program Design: 20%
  
  • Penalty points can be assessed in this category for grossly inefficient code.
  • File input and output
  • Exception handling
  • Order-related manipulations, such as addOrdered, sort, and search
  
  
• Data Abstraction and Class Design: 30%
• Extending a class
• Overriding a method, such as toString
• Creating a class
• Accessing super class methods and/or fields
  
• Implementing an interface, such as Comparable


• Linked List Manipulation: 30%
• This will be a non-circular singly-linked list, either with or without a header/sentinel node.
• Operations will be chosen from the following list.
• Adding a node — all cases (to an empty list, to a non-empty list, at front, at back, in the middle)
• Remove a node — all cases (based on index, based on Object equality, from front, from back, from middle)
• Retrieve an item based on index or some other criterion (such as maximum or minimum).
• Order-related manipulations, such as addOrdered and sort, may be exemplified within the linked list.
• Generate a sublist, based on some criterion or criteria.


• Recursion: 20%
• Simple recursive methods to accomplish a task, which may or may not be list related. Examples would be printing a linked list in reverse, computation of factorials, and other recursive algorithms at the level of those covered in Programming Principles I and II and in Data Structures.
• An example you probably haven’t seen. AdditiveSquares.java

EXPANDED SPECIFICS

An expanded list of topics follows.  You should make sure you are proficient in each area to ensure success.

• Linked list utilization (a subset of the below items will be required)
• insert (front, back, in order)
• delete (front, back, specific item)
• print
• traverse
• sort(you must write the code, unless otherwise specified)  Note, however, that you may be asked to do array-oriented sorting.
• build a sub-list from an existing list
• utilize a dummy head node — or not utilize one


• Basic recursion (like using recursion to traverse a linked list in some form, or print the contents of a linked list in reverse order)


• File input and output
• Input via a Scanner object or a BufferedReader object (your choice)
• any input file will be well formed
• know how to stop when end of file is reached
• remember to close file when finished
• Output via PrintWriter
• know how to format output (decimal points, columns, etc.)
• remember to close output file when finished


• Inheritance
• Understand base / derived relationship
• know how to override methods to enable polymorphic behavior
• understand abstract classes and interfaces
• know how to derive a class from an existing class
• know how to call base/parent/super class methods (requires use of keyword super)


• Comparable interface
• know how to implement for a given class, including multiple-key comparisons
• know how to utilize when searching and sorting (i.e. call the compareTo method)


• Basic exception handling
• know how to designate a section of code as possibly throwing an execption (via a try block)
• know how to handle and exception (via a catch block)
• know how to propagate an exception from a method (by using throws and the end of the method signature)
• know how to generically handle an exception (use Exception to do this)


• toString
• know how to implement properly for a given class
• know how to utilize an existing toString provided by a class (recall that it returns a String representing data in the object you'd like printed and that it is automatically invoked whenever you try and print an object using print, println, or printf with the "%s" format specifier)

This exam is extremely similar in nature to the programming exam given in Data Structures (CSCD 300).  Therefore, if you feel you need to review any of the above, visit the Data Structures website at: http://penguin.ewu.edu/cscd300.  You will not have to start from scratch on the exam.  You will be given a (previously) working program that has had functionality removed.  It is your job to reinsert that functionality.  For the most part, this will be done via adding methods.  You will be told in some way what methods are required.  You may be asked to write a class in its entirety.  However, if you are asked to write an entire class the amount of code you will be required to write is not intended to be “large.”  Questions will be asked in “parts” that can be done separately.  This means if you mess up on part 1, and part 2 requires something from part 1, you will not need to have completed part 1 successfully to do part 2.

Problem Areas Identified From Previous Exams

• Not following directions
• not reading the specifications in their entirety — make sure you read all directions before you begin writing code.  A prime example is ignoring specifications related to whether the linked list does or does not have a header/sentinel node.
• not placing files in specified location
• not naming files as specified
• modifying files that were to be left alone
• Unfamiliarity with keywords in Java required for basic things like inheritance (extends) and interface use (implements)
• Spending too much time on one item
• Inability to implement simple recursion
• Turning in code that does not compile — you cannot pass the exam if you do this.  Make sure you comment out things that do not compile

Basic strategies you should use

1. Stub the methods out that you have to write, then fill them in with useful code when you are ready
2. Read the directions carefully, then look at the sample input and output before you begin writing code
3. Comment out items that don't compile so you can test other parts of your solution (this includes methods you can't get to work and method calls that may occur from elsewhere -- like in the main method of the program)

Old Exam 

• Student version – practice on this one

NOTE: This is just a sample exam — do not expect the exam you take to be formatted in precisely the same way, with the same number of classes, methods, etc. -- this is just for practice and to give you an idea of what to expect.  The amount of code you are asked to write on this exam is similar to the amount you will have to write on the actual exam.  The topics on this exam are a selection from the list given at the top of this web page; the actual exam you take may have topics not addressed on this exam, but which are a part of the list above).