The final exam for the course will take place at the time scheduled by the Registrar's office: Monday, May 11, 8:30--11:30 AM. The exam is in our regular classroom. The exam counts for 20% of the overall grade for the course. It will be five or six pages long and should take about one-and-a-half hours (but you can use the full three hours if you need it). The format will be the same as the two previous tests, including a mix of programming questions and essay-type questions. (If you don't expect to write an essay on the Model/View/Controller pattern and how it relates to events, you haven't been paying attention for the last couple of weeks.)
The final exam is cumulative, with some emphasis on the material that was covered since the second test. The material that has been covered since the second test includes topics from Chapters 11 (streams, files, and networking), from Chapter 12 (GUI programming), and from Section 8.5 (threads). We did not cover any of these sections of the book in their entirety. More specifically, here are some of the terms and ideas that you should understand for this test:
parallel programming and multiprocessor computers threads creating threads using a subclass of the Thread class the run() method of the Thread class starting a thread using its start() method the difference between starting a thread and calling its run() method the need for synchronization race conditions synchronized methods mutual exclusion deadlock streams character streams vs. byte streams streams as Abstract Data Types and the importance of the stream abstraction abstract stream classes: Reader, Writer, InputStream, OutputStream wrapping one stream in another, for example: new BufferedReader(new FileReader(file)) the PrintWriter class; the print and println methods the Scanner class; methods such as next(), nextLine(), hasNext(), nextInt()... files and the File class reading and writing files designing a file format for saving data to a file networking IP addresses host names, and translation of host names into IP addresses port numbers URLs the client/server model of network programming the ServerSocket class; the accept() method the constructor "new ServerSocket(portNumber)" the Socket class; the getInputStream() and getOuputStream() methods the constructor "new Socket(host,port)" using a socket to communicate over a network operations that block why threads are often needed in network programming the BufferedImage class the constructor "new BufferedImage(width,height,type)" the BufferedImage types BufferedImage.TYPE_INT_RGB and BufferedImage.TYPE_INT_ARGB copying a BufferedImage to a Graphics context with g.drawImage(image,x,y,null) getting a Graphics2D for drawing to a BufferedImage with the createGraphics() method resources (but not the details of loading resources) transparency and the alpha component of a color making translucent colors with the constructor "new Color(r,g,b,alpha)" radio buttons: JRadioButton and JRadioButtonMenuItem radio button groups and the ButtonGroup class; the add() method icons and ImageIcon using icons on buttons and menu items using HTML text on buttons and labels actions and the AbstractAction class programming an AbstractAction using an AbstractAction to construct a button or menu item, and why you might want to do it toolbars and the JToolBar class adding a toolbar to a window, and adding items to the toolbar the MVC (Model/View/Controller) pattern how events are used in the MVC pattern how using the MVC pattern can make complex GUIs easier to develop and more robust components that use the MVC pattern: JList, JTable, and text components how a JList uses a ListModel to hold its data
And here are some of the more important ideas from earlier in the semester that you will want to review:
exceptions checked exceptions and mandatory exception handling the try..catch..finally statement run-time analysis of programs "big-Θ" and "big-Oh" notation recursion and recursive methods base case and recursive case of a recursion maze-solving, blob-counting, and similar recursions pointers and linked data structures linked lists traversing a linked list; "runners" operations on linked lists; adding and deleting nodes ADTs (Abstract Data Types) stacks and queues, and the operations that define them as ADTs implementing a stack as a linked list or as an array binary trees, and how to implement them as linked data structures traversing a binary tree; preorder, inorder, and postorder traversals binary sort trees recursive processing of trees expression trees postfix expressions; using a stack to evaluate a postfix expression generic programming parameterized types wrapper classes for the primitive types: Integer, Double, etc. the JCF (Java Collection Framework) collections; lists and sets; maps iterators using "for-each" loops to traverse collections hash tables ArrayList<T> and LinkedList<T> TreeSet<T> and HashSet<T>; the add(), contains(), and remove() methods TreeMap<K,V> and HashMap<K,V>; the put() and get() get methods the Comparable<T> interface the hashCode() method in the Object class