Review the difference between abstract classes and interfaces

1
Lecture 18

• Review the difference between abstract classes
  and interfaces
• The Cloneable interface
• Shallow and deep copies
• The ActionListener interface, revisited
• Event adapters
• Inner classes

2
Abstract classes

• Abstract classes are ones for which the
  implementation details must be filled in later,
  in subclasses

3
Interfaces

• Unlike C, Java does not allow multiple
  inheritance. A class can only have one
  superclass.
• Interfaces are a way to provide a kind of
  multiple inheritance without the complexity of
  C.
• When a class implements Comparable, we know we
  can use the compareTo method
• A class can implement several interfaces.

4
The Cloneable interface

• This interface is empty! It does not specify any
  methods or constants.
• It is called a tag interface or marker interface.
• A class must implement the Cloneable interface if
  it overrides the clone() method in the Object
  class.
• When clone() is called at run time, an exception
  occurs if the implicit parameter object is of a
  class that does not implement the Cloneable
  interface.

5
Overriding clone() in the Date class

• First, Date must specify that it implements the
  Cloneable interface
• Then, Date must provide the clone() method.
• Simplest way is to construct a new Date and copy
  the contents of the fields explicitly.
• Alternatively, can invoke super.clone() but
• then need to catch the CloneNotSupported
  exception skip for now
• Anyway, how does the super method in the Object
  class know about the fields in Date()? How can
  it make a cloned copy?
• Answer the Object clone method is a native
  method. It is not written in Java, but is
  implemented in the JVM for the native platform
  (machine). It works by simply copying chunks of
  memory.

6
Shallow and deep copies

• Suppose Date has another field which is actually
  an object reference
• If Dates implementation of clone() just copies
  the object reference, the cloned copy will
  reference the same object, not a copy
• This is called a shallow copy
• If this object is immutable, such as a String,
  this is fine
• But if its mutable, it means that if the object
  is later changed in the cloned copy, it will also
  change in the original copy.
• In this situation, its better to make a deep
  copy by also cloning the object field.
• Since the Object clone() does not do this, this
  must be done in the overriding method

7
ActionListener interface

• extends EventListener interface, which is a tag
  interface
• specifies only one method
• public void actionPerformed(ActionEvent e)

8
Event handling 3 ingredients

• The event class, such as ActionEvent, provided by
  Java library
• The listener class, such as our class YesListener
  that implements the ActionListener interface in
  the Java library
• The event source, such as a JButton object where
  the user clicks on the mouse YesListener must be
  added to (registered with) the button by calling
  the method addActionListener

9
Inner classes

• If the listener wants to do anything interesting,
  it needs to access the instance variables of the
  class that calls it - but these are typically
  private (or local variables, as in our FrameDemo
  example from last time)
• Therefore, we put the listener in an inner class.
• Anonymous inner classes we dont need to give
  the name YesListener to the inner class, but add
  it directly to the button anonymously (see p.471)
• advantage shorter to write
• disadvantage potentially confusing

10
Returning to FrameDemo

• Lets change it so that the listener writes in
  the JTextField associated with the button that
  was clicked, instead of calling
  System.out.println
• Should be possible since each yes button has its
  own listener
• But how, since the body of actionPerformed cannot
  distinguish which button invoked it?
• What can actionPerformed access?
• It cannot access local variables
• It can access data fields of the class that it is
  inside
• Thus, lets introduce a class YesNoSet, with data
  fields yesButton, noButton and text, that
  contains YesListener as an inner class
• Then we can construct YesNoSet objects inside the
  double loop and, for each one, add its buttons
  and text field object to the frame window

11
The MouseListener interface

• This specifies five abstract methods
• mouseClicked
• mouseEntered
• mouseExited
• mousePressed
• mouseReleased
• Each returns void and has an explicit parameter
  of type MouseEvent
• MouseEvent and ActionEvent are both descended
  from AWTEvent, but MouseEvent is much further
  down the inheritance tree

12
Event adapters

• Suppose we want to write a listener that
  implements mouseEntered but none of the other
  methods
• Any class that implements the MouseListener
  interface must implement all the methods
• However, there is a MouseAdapter class in the
  library that already implements all the methods
  as do-nothing methods
• We can then extend this class by overriding only
  the methods that we want to do something
• For example, we can write a class
  MouseEnteredListener that extends MouseAdapter
  and overrides only mouseEntered

13
Panels

• JPanel panel new JPanel()
• Good for organizing can add buttons, etc., to a
  panel and panels to a frame window
• Also good for graphics

14
Graphics

• Chapter 13
• Easiest way is to draw on panels
• class drawPanel extends JPanel
• protected void paintComponent(Graphics g)
• super.paintComponent(g)
• g.drawLine(0,0,50,50)
• count
• System.out.println("drawing, count is " count)
• We dont call paintComponent the system does
  when it needs to redraw the graphics window

15
HW 7

• Please write something that challenges you but is
  also fun
• Details completely up to you
• Dont forget about making sure user interface is
  clear, and there are plenty of comments