CPSC 225 Fall 2007
Final Exam and End-of-term Info

The final exam for this course is at 1:30 PM on Tuesday, December 11. The exam is cumulative with some emphasis on the material that has been covered since the second test. You should review the information sheets for the first and second tests, as well as this information sheet. The exam will be approximately six pages long, and most people will not need the entire three-hour exam period to finish the test.

On the last day of classes, December 7, you should be prepared to present your final project to the rest of the class. (Note: Do not miss this class!) You should make every effort to complete your final project by that time, but you can continue working on it if necessary. The absolute final deadline for turning in your project is noon on Thursday, December 13. Send me an email to tell me where to find your project. The final project is worth 15% of your total grade for the course. Grading for the final project will be as follows: I will start with a basic grade of 12 out of 15 (80%) for a working program. I will add points for

I will deduct points for

My office hours for the remainder of the semester are as follows:

        Tuesday, December 4:       1:30 -- 3:30
        Wednesday, December 5:    11:15 -- 1:45
        Thursday, December 6:     10:00 -- 3:00
        Friday, December 7:       11:15 -- 1:45
        Saturday, December 8:      1:00 -- 3:00

        Monday, December 10:      12:00 -- 2:30
        Tuesday, December 11:     11:00 -- 1:20  [CPSC 225 exam at 1:30]
        Wednesday, December 12:   11:00 -- 1:20  [CPSC 229 exam at 1:30]
        Thursday, December 13:    10:00 -- Noon

Here are some terms and ideas that were covered after the second test:

client-server model for TCP/IP
writing a server program using a ServerSocket
writing a client program using a Socket
why a server should be multi-threaded
basics of the HTTP protocol and how web servers and browsers communicate

generic programming
what is the point of having generic classes?
parameterized types (like "class Bag<T>") and type parameters (like "Bag<String> items")
wrapper classes such as Integer, Double, Boolean, and Character
the Java Collection Framework
for-each loops
why interators are necessary
hash tables (their structure, how put and get are implemented, how hash codes are used)
the equals() method in class Object
the hashCode() method in class Object, and its relation to the equals() method
the Comparable interface and its relation to TreeSets and TreeMaps
the difference between TreeSet and HashSet
the difference between TreeMap and HashMap
the difference between ArrayList and LinkedList
writing simple generic classes such as Bag<T>

images and BufferedImage
using a BufferedImage to keep a copy of the on-screen image
drawing an image:  g.drawImage(image, x, y, observer)  [observer = null for BufferedImage]
drawing a scaled image:  g.drawImage(image, x, y, observer)
drawing ON an image
reading an image:  ImageIO.read( file_or_url )
resources and class loaders
locating a resource:   URL resourceURL = classLoader.getResource( path_to_resource )
what are resources used for?
transparency and the alpha component of a color
ActionListeners, Actions, and AbstractAction
creating an action using an anonymous subclass of AbstractAction
using Actions to make buttons and menu items
why do Actions exist?
JRadioButtons, JRadioButtonMenuItems, and ButtonGroups
the MVC (Model/View/Controller) design pattern
how MVC is used in Java
how MVC relates to Actions and listeners
basic ideas of JList, JTable, and JEditPane and how they use the MVC pattern

The ServerSocket class
       constructor:   public ServerSocket(int listening_port_number)
       method:        public Socket accept()

The Socket class
       constructor:   public Socket(String host_name_or_ip, int port_number)
       methods:       public InputStream getInputStream()
                      public OutputStream getOutputStream()
                      public void close()

The Collection<T> interface
       methods:       public add( T item )
                      public boolean contains( Object item )
                      public void remove( Object item )
                      public int size()
                      public void clear()

The Set<T> inteface
       extends Collection<T>, so has methods add(x), contains(x), remove(x), size(), clear()
       implemented by class TreeSet<T> and class HashSet<T>

The List<T> interface
       methods:      public T get( int index )
                     public void set( int index, T item )
                     public void add( int index, T item )
                     public void remove( int index )
       extends Collection<T>, so has all the Collection methods
       implemented by class ArrayList<T> and class LinkedList<T>

The Map<K,V> interface
      methods:       public V get( K key )
                     public void put( K key, V value )
                     public int size()
                     public void clear()
                     public Set<K> keySet()
     implemented by class TreeMap<K,V> and class HashMap<K,V>

The BufferedImage class
     constructor:   public BufferedImage(int width, int height, int type)
                       [type can be BufferedImage.TYPE_INT_RGB, BufferedImage.TYPE_INT_ARGB]
     methods:       public Graphics getGraphics()
                    public Graphics2D createGraphics()
                    public int getRGB( int x, int y )
                    public void setRGB( int x, int y, int rgb )

The Action interface
     methods:      public void actionPerformed(ActionEvent e)
                   public void put( String key, Object value )
                   public Object get( String key )
                      [key is Action.NAME, Action.ACCELERATOR_KEY, Action.SHORT_DESCRIPTION, etc.]
                   public void setEnabled( boolean enabled )
    implemented by AbstractAction (leaving actionPerformed() as an undefined abstract method)

David Eck