Notes on the Final Exam (added 8/26/2002)

The Final Exam will be from 1pm to 3pm on Thursday, August 29th in 300 Richards.

The best guide by far for the Final Exam are the two Midterm exams, posted here and here. My approach to all this, as I've said repeatedly in class, is that I want you to learn a few very basic things well, instead of trying to test you on a broad range of topics, each of which you would learn only superficially. That is why the Final Exam will be so similar to the Midterm. If you did not do well on the Midterm and you pull your grade up substantially on the Final, this will be strong evidence that you have finally learned some important things. And that will be good all around. Some topics that you should pay special attention to are the following:

• You can include the data and functionality of a class B in a class A by extending A or by including an instance variable of type B in A.
• Casting can cause an object to be treated as a certain type. There are circumstances in which an item of apparent type Object can be cast to a more specific actual type or an object of multiple types (via inheritance and implementation) can be cast to one of its specific types.
• In a sequence diagram, remember that the diagrams are ordered strictly by the time of occurrence of events.
• Overriding and overloading are distinct concepts with distinct implementations.
• Important concepts in inheritance and implementation include interfaces, abstract implementations and concrete classes.
• Variables of a given class can be assigned values that are instances of subclasses of the variable type. You should understand why.
• "Exposing the rep" is usually not a good thing, which is why most APIs only mention methods and rarely mention instance variables.
• In main(), a static method, there is no "this". Why not? But you can create instances of objects and use them.

The Midterm Exam will be given Monday, July 29th. It will be very similar to the Midterm Exam Sampler available here (updated 7/27/2002). The Sampler has questions but not answers. You should work to understand the questions and practice answering the questions and similar ones that you and your classmates make up. The questions were discussed by Professor Futrelle in the classes in the week before the exam. I hope you were in class. But as I've always emphasized, listening to me explain the answers may lull you into thinking that you understand the answers so well that you'll be able to write them down without any practice. Nothing could be further from the truth. The only way to prepare yourself to understand questions is to work with questions yourself; making up some variations is especially helpful. And the only way to prepare yourself to write out answers is to write out answers.

Another very important way to learn this material is to write, compile and run simple code, to make sure your answers are correct, or to understand why certain answers are not. You won't have a machine in front of you during the exam, so keep that in mind and use your programming only for its value, not again to lull yourself you think you know what's going on because you fiddled some code around and it finally worked. You have to know why it worked and be able to explain why (or why not).

During this week there may be slight alterations of topics or emphasis for the Midterm. But simply coming to class will keep you apprised of any such changes.

The Final Exam will be given Thursday, August 29th at 1pm. Room TBA. A Sampler will be provided for it also. Many of the topics covered on the Final will be similar to those on the Midterm.

Additions describing more specifics of the Midterm, Sat. 7/27/2002

About 3/4 of the questions will require writing brief and simple source code, including class definitions and methods. I repeat: You might want to try writing out simple examples on paper, the proper way to prepare, and then, only after you've written them down, check them by trying to compile them with javac, and in some cases running them with java. For example, if you're wondering about the various cases in Question 8 of the sampler, just define two classes A and a subclass B, two trivial methods aMeth() and bMeth(), and do the tests yourself in a main() method in A.

Topics and concepts that may appear on the Midterm include:

• Abstract classes
• Interfaces and their implementation
• Class definitions
• Objects hold state and behavior
• Subclassing, assignment, and casting, e.g., for methods returning type Object
• Which errors are caught at compile time and which at run-time
• Polymorphism and its role in assignments and run-time dispatching
• Overloading as simple polymorphism and overriding as the important OO polymorphism
• Abstracting away from the details by not "exposing the rep" -- no direct access to instance variables
• CRC cards -- http://www.ccs.neu.edu/home/futrelle/teaching/com1204sm2002/uml/crc/crc.htm
• Sequence diagrams -- http://www.ccs.neu.edu/home/futrelle/teaching/com1204sm2002/uml/interaction/interactions.htm
• Use meaningful names for all classes, fields and methods
• Use of this, especially in assignments from arguments, e.g., this.n = n
• Factories and types in assignment statements for the products of a factory
• Creation of instances (objects) in main() for testing and running applications (cannot call an instance method without first creating an instance)
• Java syntax -- When you write code, get the syntax correct