SE450: Horstmann Chapter 6

Start with simple Employee class
public class Employee { public Employee(String aName) { name = aName; } public void setSalary(double aSalary) { salary = aSalary; } public String getName() { return name; } public double getSalary() { return salary; } private String name; private double salary; }
Manager is a subclass

Modeling Specialization [4/65]

Manager class adds new method: setBonus
Manager class overrides existing method: getSalary
Adds salary and bonus
public class Manager extends Employee { public Manager(String aName) { ... } public void setBonus(double aBonus) { bonus = aBonus; } // new method public double getSalary() { ... } // overrides Employee method private double bonus; // new field }

Modeling Specialization [5/65]

Manager Methods and Fields [6/65]

methods setSalary, getname (inherited from Employee)
method getSalary (overridden in Manager)
method setBonus (defined in Manager)
fields name and salary (defined in Employee)
field bonus (defined in Manager)

The Super/Sub Terminology [7/65]

Why is Manager a subclass?
Isn't a Manager superior?
Doesn't a Manager object have more fields?
The set of managers is a subset of the set of employees

The Super/Sub Terminology [8/65]

Inheritance Hierarchies [9/65]

Real world: Hierarchies describe general/specific relationships
- General concept at root of tree
- More specific concepts are children
Programming: Inheritance hierarchy
- General superclass at root of tree
- More specific subclasses are children

Inheritance Hierarchies [10/65]

The Substitution Principle [11/65]

Formulated by Barbara Liskov
You can use a subclass object whenever a superclass object is expected
Example:
Employee e; ... System.out.println("salary=" + e.getSalary());
Can set e to Manager reference
Polymorphism: Correct getSalary method is invoked

Invoking Superclass Methods [12/65]

Can't access private fields of superclass
public class Manager extends Employee
{
public double getSalary() { return salary + bonus; // ERROR--private field }
...
}
Be careful when calling superclass method
public double getSalary() { return getSalary() + bonus; // ERROR--recursive call }

Invoking Superclass Methods [13/65]

Use super keyword
public double getSalary() { return super.getSalary() + bonus; }
super is not a reference
super turns off polymorphic call mechanism

Invoking Superclass Constructors [14/65]

Use super keyword in subclass constructor:
public Manager(String aName) { super(aName); // calls superclass constructor bonus = 0; }
Call to super must be first statement in subclass constructor
If subclass constructor doesn't call super, superclass must have constructor without parameters

Preconditions [15/65]

Precondition of redefined method at most as strong

public class Employee
{
   /**
      Sets the employee salary to a given value. 
      @param aSalary the new salary 
      @precondition aSalary > 0 
   */ 
   public void setSalary(double aSalary) { ... }
}

Can we redefine Manager.setSalary with precondition
salary > 100000?

No--Could be defeated:

Manager m = new Manager();
Employee e = m;
e.setSalary(50000);

Postconditions, Visibility, Exceptions [16/65]

Postcondition of redefined method at least as strong
Example: Employee.setSalary promises not to decrease salary
Then Manager.setSalary must fulfill postcondition
Redefined method cannot be more private.
(Common error: omit public when redefining)
Redefined method cannot throw more checked exceptions

Graphic Programming with Inheritance [17/65]

Chapter 4: Create drawings by by implementing Icon interface type
Now: Form subclass of JComponent
public class MyComponent extends JComponent { public void paintComponent(Graphics g) { drawing instructions go here } ... }
Advantage: Inherit behavior from JComponent
Example: Can attach mouse listener to JComponent

Mouse Listeners [18/65]

Attach mouse listener to component

Can listen to mouse events (clicks) or mouse motion events

public interface MouseListener 
{ 
   void mouseClicked(MouseEvent event); 
   void mousePressed(MouseEvent event); 
   void mouseReleased(MouseEvent event); 
   void mouseEntered(MouseEvent event); 
   void mouseExited(MouseEvent event); 
}
 
public interface MouseMotionListener 
{ 
   void mouseMoved(MouseEvent event); 
   void mouseDragged(MouseEvent event); 
}

Mouse Adapters [19/65]

What if you just want to listen to mousePressed?

Extend MouseAdapter

public class MouseAdapter implements MouseListener
{ 
   public void mouseClicked(MouseEvent event) {} 
   public void mousePressed(MouseEvent event) {}
   public void mouseReleased(MouseEvent event) {}
   public void mouseEntered(MouseEvent event) {} 
   public void mouseExited(MouseEvent event) {} 
}

Component constructor adds listener:

addMouseListener(new
   MouseAdapter()
   {
      public void mousePressed(MouseEvent event) 
      {
         mouse action goes here 
} 
});

Car Mover Program [20/65]

Use the mouse to drag a car shape
Car panel has mouse + mouse motion listeners
mousePressed remembers point of mouse press
mouseDragged translates car shape

file:horstmann/ch06_car/CarComponent.java [source] [doc-public] [doc-private]

package horstmann.ch06_car;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;

import javax.swing.JComponent;

/**
   A component that shows a scene composed of items.
 */
@SuppressWarnings("serial")
public class CarComponent extends JComponent
{
  public CarComponent()
  {
    car = new CarShape(20, 20, 50);
    addMouseListener(new
        MouseAdapter()
    {
      public void mousePressed(MouseEvent event)
      {
        mousePoint = event.getPoint();
        if (!car.contains(mousePoint))
          mousePoint = null;
      }
    });

    addMouseMotionListener(new
        MouseMotionAdapter()
    {
      public void mouseDragged(MouseEvent event)
      {
        if (mousePoint == null) return;
        Point lastMousePoint = mousePoint;
        mousePoint = event.getPoint();

        double dx = mousePoint.getX() - lastMousePoint.getX();
        double dy = mousePoint.getY() - lastMousePoint.getY();
        car.translate((int) dx, (int) dy);
        repaint();
      }
    });
  }

  public void paintComponent(Graphics g)
  {
    Graphics2D g2 = (Graphics2D) g;
    car.draw(g2);
  }

  private CarShape car;
  private Point mousePoint;
}

file:horstmann/ch06_car/CarMover.java [source] [doc-public] [doc-private]

package horstmann.ch06_car;
import javax.swing.JFrame;

/**
   A program that allows users to move a car with the mouse.
 */
public class CarMover
{
  public static void main(String[] args)
  {
    JFrame frame = new JFrame();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    frame.add(new CarComponent());
    frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
    frame.setVisible(true);
  }

  private static final int FRAME_WIDTH = 400;
  private static final int FRAME_HEIGHT = 400;
}

file:horstmann/ch06_car/CarShape.java [source] [doc-public] [doc-private]

package horstmann.ch06_car;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;

/**
   A car shape.
 */
public class CarShape
{
  /**
      Constructs a car shape.
      @param x the left of the bounding rectangle
      @param y the top of the bounding rectangle
      @param width the width of the bounding rectangle
   */
  public CarShape(int x, int y, int width)
  {
    this.x = x;
    this.y = y;
    this.width = width;
  }

  public void draw(Graphics2D g2)
  {
    Rectangle2D.Double body
    = new Rectangle2D.Double(x, y + width / 6,
        width - 1, width / 6);
    Ellipse2D.Double frontTire
    = new Ellipse2D.Double(x + width / 6, y + width / 3,
        width / 6, width / 6);
    Ellipse2D.Double rearTire
    = new Ellipse2D.Double(x + width * 2 / 3,
        y + width / 3,
        width / 6, width / 6);

    // The bottom of the front windshield
    Point2D.Double r1
    = new Point2D.Double(x + width / 6, y + width / 6);
    // The front of the roof
    Point2D.Double r2
    = new Point2D.Double(x + width / 3, y);
    // The rear of the roof
    Point2D.Double r3
    = new Point2D.Double(x + width * 2 / 3, y);
    // The bottom of the rear windshield
    Point2D.Double r4
    = new Point2D.Double(x + width * 5 / 6, y + width / 6);
    Line2D.Double frontWindshield
    = new Line2D.Double(r1, r2);
    Line2D.Double roofTop
    = new Line2D.Double(r2, r3);
    Line2D.Double rearWindshield
    = new Line2D.Double(r3, r4);

    g2.draw(body);
    g2.draw(frontTire);
    g2.draw(rearTire);
    g2.draw(frontWindshield);
    g2.draw(roofTop);
    g2.draw(rearWindshield);
  }

  public boolean contains(Point2D p)
  {
    return x <= p.getX() && p.getX() <= x + width
        && y <= p.getY() && p.getY() <= y + width / 2;
  }

  public void translate(int dx, int dy)
  {
    x += dx;
    y += dy;
  }

  private int x;
  private int y;
  private int width;
}

Car Mover Program [21/65]

Scene Editor [22/65]

Draws various shapes
User can add, delete, move shapes
User selects shape with mouse
Selected shape is highlighted (filled in)

Scene Editor [23/65]

The SceneShape Interface Type [24/65]

keep track of selection state
draw plain or selected shape
move shape
hit testing: is a point (e.g. mouse position) inside?

The SceneShape Interface Type [25/65]

The SceneShape Interface Type [26/65]

public interface SceneShape { void setSelected(boolean b); boolean isSelected(); void draw(Graphics2D g2); void drawSelection(Graphics2D g2); void translate(int dx, int dy); boolean contains(Point2D aPoint); }

CarShape and HouseShape Classes [27/65]

public class CarShape implements SceneShape 
{ 
   ... 
   public void setSelected(boolean b) { selected = b; } 
   public boolean isSelected() { return selected; }
   private boolean selected; 
} 

public class HouseShape implements SceneShape
{ 
   ... 
   public void setSelected(boolean b) { selected = b; } 
   public boolean isSelected() { return selected; }
   private boolean selected; 
}

Abstract Classes [28/65]

Factor out common behavior
(setSelected, isSelected)
Subclasses inherit common behavior
Some methods still undefined
(draw, drawSelection, translate, contains)

public class SelectableShape implements Item 
{ 
   public void setSelected(boolean b) { selected = b; } 
   public boolean isSelected() { return selected; }
   private boolean selected; 
}

Abstract Classes [29/65]

Abstract Classes [30/65]

SelectableShape doesn't define all SceneShape methods
It's abstract
public abstract class SelectableShape implements SceneShape
HouseShape and CarShape are concrete

Can't instantiate abstract class:

SelectableShape s = new SelectableShape(); // NO

Ok to have variables of abstract class type:

SelectableShape s = new HouseShape(); // OK

Abstract Classes and Interface Types [31/65]

Abstract classes can have fields
Interface types can only have constants (public static final)
Abstract classes can define methods
Interface types can only declare methods
A class can implement any number of interface types
In Java, a class can extend only one other class

Scene Editor [32/65]

Mouse listener selects/unselects item
Mouse motion listener drags item
Remove button removes selected items

file:horstmann/ch06_scene1/SceneComponent.java [source] [doc-public] [doc-private]

package horstmann.ch06_scene1;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.util.ArrayList;

import javax.swing.JComponent;

/**
   A component that shows a scene composed of shapes.
 */
@SuppressWarnings("serial")
public class SceneComponent extends JComponent
{
  public SceneComponent()
  {
    shapes = new ArrayList<SceneShape>();

    addMouseListener(new
        MouseAdapter()
    {
      public void mousePressed(MouseEvent event)
      {
        mousePoint = event.getPoint();
        for (SceneShape s : shapes)
        {
          if (s.contains(mousePoint))
            s.setSelected(!s.isSelected());
        }
        repaint();
      }
    });

    addMouseMotionListener(new
        MouseMotionAdapter()
    {
      public void mouseDragged(MouseEvent event)
      {
        Point lastMousePoint = mousePoint;
        mousePoint = event.getPoint();
        for (SceneShape s : shapes)
        {
          if (s.isSelected())
          {
            double dx = mousePoint.getX() - lastMousePoint.getX();
            double dy = mousePoint.getY() - lastMousePoint.getY();
            s.translate((int) dx, (int) dy);
          }
        }
        repaint();
      }
    });
  }

  /**
      Adds a shape to the scene.
      @param s the shape to add
   */
  public void add(SceneShape s)
  {
    shapes.add(s);
    repaint();
  }

  /**
      Removes all selected shapes from the scene.
   */
  public void removeSelected()
  {
    for (int i = shapes.size() - 1; i >= 0; i--)
    {
      SceneShape s = shapes.get(i);
      if (s.isSelected()) shapes.remove(i);
    }
    repaint();
  }

  public void paintComponent(Graphics g)
  {
    super.paintComponent(g);
    Graphics2D g2 = (Graphics2D) g;
    for (SceneShape s : shapes)
    {
      s.draw(g2);
      if (s.isSelected())
        s.drawSelection(g2);
    }
  }

  private ArrayList<SceneShape> shapes;
  private Point mousePoint;
}

file:horstmann/ch06_scene1/SceneEditor.java [source] [doc-public] [doc-private]

package horstmann.ch06_scene1;
import java.awt.BorderLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
   A program that allows users to edit a scene composed
   of items.
 */
public class SceneEditor
{
  public static void main(String[] args)
  {
    JFrame frame = new JFrame();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    final SceneComponent scene = new SceneComponent();

    JButton houseButton = new JButton("House");
    houseButton.addActionListener(event -> scene.add(new HouseShape(20, 20, 50)));

    JButton carButton = new JButton("Car");
    carButton.addActionListener(event -> scene.add(new CarShape(20, 20, 50)));

    JButton removeButton = new JButton("Remove");
    removeButton.addActionListener(event -> scene.removeSelected());

    JPanel buttons = new JPanel();
    buttons.add(houseButton);
    buttons.add(carButton);
    buttons.add(removeButton);

    frame.add(scene, BorderLayout.CENTER);
    frame.add(buttons, BorderLayout.NORTH);
    frame.setSize(300, 300);
    frame.setVisible(true);
  }
}

file:horstmann/ch06_scene1/HouseShape.java [source] [doc-public] [doc-private]

package horstmann.ch06_scene1;
import java.awt.Graphics2D;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;

/**
   A house shape.
 */
public class HouseShape extends SelectableShape
{
  /**
      Constructs a house shape.
      @param x the left of the bounding rectangle
      @param y the top of the bounding rectangle
      @param width the width of the bounding rectangle
   */
  public HouseShape(int x, int y, int width)
  {
    this.x = x;
    this.y = y;
    this.width = width;
  }

  public void draw(Graphics2D g2)
  {
    Rectangle2D.Double base
    = new Rectangle2D.Double(x, y + width, width, width);

    // The left bottom of the roof
    Point2D.Double r1
    = new Point2D.Double(x, y + width);
    // The top of the roof
    Point2D.Double r2
    = new Point2D.Double(x + width / 2, y);
    // The right bottom of the roof
    Point2D.Double r3
    = new Point2D.Double(x + width, y + width);

    Line2D.Double roofLeft
    = new Line2D.Double(r1, r2);
    Line2D.Double roofRight
    = new Line2D.Double(r2, r3);

    g2.draw(base);
    g2.draw(roofLeft);
    g2.draw(roofRight);
  }

  public void drawSelection(Graphics2D g2)
  {
    Rectangle2D.Double base
    = new Rectangle2D.Double(x, y + width, width, width);
    g2.fill(base);
  }

  public boolean contains(Point2D p)
  {
    return x <= p.getX() && p.getX() <= x + width
        && y <= p.getY() && p.getY() <= y + 2 * width;
  }

  public void translate(int dx, int dy)
  {
    x += dx;
    y += dy;
  }

  private int x;
  private int y;
  private int width;
}

Uniform Highlighting Technique [33/65]

Old approach: each shape draws its selection state
Inconsistent
Better approach: shift, draw, shift, draw, restore to original position
Define in SelectableShape public void drawSelection(Graphics2D g2) { translate(1, 1); draw(g2); translate(1, 1); draw(g2); translate(-2, -2); }

Uniform Highlighting Technique [34/65]

Template Method [35/65]

drawSelection calls draw
Must declare draw in SelectableShape
No implementation at that level!
Declare as abstract methodpublic abstract void draw(Graphics2D g2)
Defined in CarShape, HouseShape
drawSelection method calls draw, translate
drawSelection doesn't know which methods--polymorphism
drawSelection is a template method

file:horstmann/ch06_scene2/SelectableShape.java [source] [doc-public] [doc-private]

package horstmann.ch06_scene2;
import java.awt.Graphics2D;

/**
   A shape that manages its selection state.
 */
public abstract class SelectableShape implements SceneShape
{
  public void setSelected(boolean b)
  {
    selected = b;
  }

  public boolean isSelected()
  {
    return selected;
  }

  public void drawSelection(Graphics2D g2)
  {
    translate(1, 1);
    draw(g2);
    translate(1, 1);
    draw(g2);
    translate(-2, -2);
  }

  private boolean selected;
}

file:horstmann/ch06_scene2/HouseShape.java [source] [doc-public] [doc-private]

package horstmann.ch06_scene2;
import java.awt.Graphics2D;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;

/**
   A house shape.
 */
public class HouseShape extends SelectableShape
{
  /**
      Constructs a house shape.
      @param x the left of the bounding rectangle
      @param y the top of the bounding rectangle
      @param width the width of the bounding rectangle
   */
  public HouseShape(int x, int y, int width)
  {
    this.x = x;
    this.y = y;
    this.width = width;
  }

  public void draw(Graphics2D g2)
  {
    Rectangle2D.Double base
    = new Rectangle2D.Double(x, y + width, width, width);

    // The left bottom of the roof
    Point2D.Double r1
    = new Point2D.Double(x, y + width);
    // The top of the roof
    Point2D.Double r2
    = new Point2D.Double(x + width / 2, y);
    // The right bottom of the roof
    Point2D.Double r3
    = new Point2D.Double(x + width, y + width);

    Line2D.Double roofLeft
    = new Line2D.Double(r1, r2);
    Line2D.Double roofRight
    = new Line2D.Double(r2, r3);

    g2.draw(base);
    g2.draw(roofLeft);
    g2.draw(roofRight);
  }

  public boolean contains(Point2D p)
  {
    return x <= p.getX() && p.getX() <= x + width
        && y <= p.getY() && p.getY() <= y + 2 * width;
  }

  public void translate(int dx, int dy)
  {
    x += dx;
    y += dy;
  }

  private int x;
  private int y;
  private int width;
}

TEMPLATE METHOD Pattern [36/65]

Context

An algorithm is applicable for multiple types.
The algorithm can be broken down into primitive operations. The primitive operations can be different for each type
The order of the primitive operations doesn't depend on the type

TEMPLATE METHOD Pattern [37/65]

Solution

Define a superclass that has a method for the algorithm and abstract methods for the primitive operations.
Implement the algorithm to call the primitive operations in the appropriate order.
Do not define the primitive operations in the superclass, or define them to have appropriate default behavior.
Each subclass defines the primitive operations but not the algorithm.

TEMPLATE METHOD Pattern [38/65]

TEMPLATE METHOD Pattern [39/65]

Name in Design Pattern	Actual Name (Selectable shapes)
AbstractClass	SelectableShape
ConcreteClass	CarShape, HouseShape
templateMethod()	drawSelection
primitiveOp1(), primitiveOp2()	translate, draw

Compound Shapes [40/65]

GeneralPath: sequence of shapes

GeneralPath path = new GeneralPath(); 
path.append(new Rectangle(...), false); 
path.append(new Triangle(...), false); 
g2.draw(path);

Advantage: Containment test is free
path.contains(aPoint);

file:horstmann/ch06_scene3/CompoundShape.java [source] [doc-public] [doc-private]

package horstmann.ch06_scene3;
import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.geom.AffineTransform;
import java.awt.geom.GeneralPath;
import java.awt.geom.Point2D;

/**
   A scene shape that is composed of multiple geometric shapes.
 */
public abstract class CompoundShape extends SelectableShape
{
  public CompoundShape()
  {
    path = new GeneralPath();
  }

  protected void add(Shape s)
  {
    path.append(s, false);
  }

  public boolean contains(Point2D aPoint)
  {
    return path.contains(aPoint);
  }

  public void translate(int dx, int dy)
  {
    path.transform(
        AffineTransform.getTranslateInstance(dx, dy));
  }

  public void draw(Graphics2D g2)
  {
    g2.draw(path);
  }

  private GeneralPath path;
}

file:horstmann/ch06_scene3/HouseShape.java [source] [doc-public] [doc-private]

package horstmann.ch06_scene3;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;

/**
   A house shape.
 */
public class HouseShape extends CompoundShape
{
  /**
      Constructs a house shape.
      @param x the left of the bounding rectangle
      @param y the top of the bounding rectangle
      @param width the width of the bounding rectangle
   */
  public HouseShape(int x, int y, int width)
  {
    Rectangle2D.Double base
    = new Rectangle2D.Double(x, y + width, width, width);

    // The left bottom of the roof
    Point2D.Double r1
    = new Point2D.Double(x, y + width);
    // The top of the roof
    Point2D.Double r2
    = new Point2D.Double(x + width / 2, y);
    // The right bottom of the roof
    Point2D.Double r3
    = new Point2D.Double(x + width, y + width);

    Line2D.Double roofLeft
    = new Line2D.Double(r1, r2);
    Line2D.Double roofRight
    = new Line2D.Double(r2, r3);

    add(base);
    add(roofLeft);
    add(roofRight);
  }
}

Compound Shapes [41/65]

Access to Superclass Features [42/65]

Why does the HouseShape constructor call add?

public HouseShape()
{
   add(new Rectangle(...));
   add(new Triangle(...));
}

Why not just
path.append(new Rectangle(...));
HouseShape inherits path field
HouseShape can't access path
path is private to superclass

Protected Access [43/65]

Make CompoundShape.add method protected
Protects HouseShape: other classes can't add graffiti
Protected features can be accessed by subclass methods...
...and by methods in the same package
Bad idea to make fields protected
protected GeneralPath path; // DON'T
Ok to make methods protected
protected void add(Shape s) // GOOD
Protected interface separate from public interface

Hierarchy of Swing Components [44/65]

Base of hierarchy: Component

Huge number of common methods:

int getWidth()
int getHeight()
Dimension getPreferredSize()
void setBackground(Color c)
. . .

Most important subclass: Container

Hierarchy of Swing Components [45/65]

Hierarchy of Swing Components [46/65]

History: First came AWT, Abstract Window Toolkit
Used native components
Subtle platform inconsistencies
Write once, run anywhere ->
Write once, debug everywhere
Swing paints components onto blank windows
Supports multiple look and feel implementations

Look and Feel [47/65]

Hierarchy of Swing Components [48/65]

Base of Swing components: JComponent
Subclass of Container
Some Swing components are containers
Java has no multiple inheritance
JLabel, JButton, ... are subclasses of JComponent
Intermediate classes AbstractButton, JTextComponent

Hierarchy of Geometrical Shapes [49/65]

First version of Java: few shapes, integer coordinates
```
Point
Rectangle
Polygon
```

Java 2: sophisticated shapes, floating-point coordinates

Point2D
Rectangle2D
RoundRectangle2D
Line2D
Ellipse2D
Arc2D
QuadCurve2D
CubicCurve2D
GeneralPath
Area

All but Point2D implement Shape interface type

Hierarchy of Geometrical Shapes [50/65]

Rectangular Shapes [51/65]

Subclasses of RectangularShape:

Rectangle2D
RoundRectangle2D
Ellipse2D
Arc2D

RectangularShape has useful methods

getCenterX/getCenterY
getMinX/getMinY
getMaxX/getMaxY
getWidth/getHeight
setFrameFromCenter/setFrameFromDiagonal

Float/Double Classes [52/65]

Each class has two subclasses, e.g.
```
Rectangle2D.Double
Rectangle2D.Float
```
Are also inner classes!
(Just to avoid even longer class names)
Implementations have double/float fields
Most methods have double parameters/return values

Float/Double Classes [53/65]

Float/Double Classes [54/65]

public class Rectangle2D 
{ 
   public static class Float extends Rectangle2D 
   { 
      public double getX() { return x; } 
      public double getY() { return y; }
      public double getWidth() { return width; }
      public double getHeight() { return height;} 
      public void setRect(float x, float y, float w, float h) 
      { 
         this.x = x; this.y = y; 
         this.width = w; this.height = h; 
      } 
      public void setRect(double x, double y, 
         double w, double h) 
      { 
         this.x = (float)x; this.y = (float)y; 
         this.width = (float)w; this.height = (float)h; 
      } 
      ... 
      public float x; 
      public float y; 
      public float width; 
      public float height; 
   } 
   . . .

Float/Double Classes [55/65]

   . . .
   public static class Double extends Rectangle2D 
      public double getX() { return x; } 
      public double getY() { return y; }
      public double getWidth() { return width; }
      public double getHeight() { return height;} 
      public void setRect(double x, double y, 
         double w, double h) 
      { 
         this.x = x; this.y = y; 
         this.width = w; this.height = h; 
      } 
      ... 
      public double x; 
      public double y; 
      public double width; 
      public double height; 
   }
   ...
}

Float/Double Classes [56/65]

Rectangle2D class has no instance variables

Template Method Pattern at work:

public boolean contains(double x, double y)
{
   double x0 = getX();
   double y0 = getY();
   return x >= x0 && y >= y0 &&
      x < x0 + getWidth() &&
      y < y0 + getHeight();
}

No need to use inner class after construction
Rectangle2D rect = new Rectangle2D.Double(5, 10, 20, 30);

TEMPLATE METHOD Pattern [57/65]

Name in Design Pattern	Actual Name (Rectangles)
AbstractClass	Rectangle
ConcreteClass	Rectangle2D.Double
templateMethod()	contains
primitiveOpn()	getX, getY, getWidth, getHeight

Hierarchy of Exception Classes [58/65]

Base of hierarchy: Throwable
Two subclasses: Error, Exception
Subclasses of Error: fatal
(out of memory, assertion failure)
Subclasses of Exception:
- Lots of checked exceptions
  (I/O, class not found)
- RuntimeException--its subclasses are unchecked
  (null pointer, index out of bounds)

Hierarchy of Exception Classes [59/65]

Catching Exceptions [60/65]

Can have multiple catch clauses:

try
{
   code that may throw exceptions
}
 catch (ExceptionType1 exception1)
{
   handler for ExceptionType1
}
catch (ExceptionType2 exception1)
{
   handler for ExceptionType2
}

Can catch by superclass:
catch (IOException exception) catches FileNotFoundException

Defining Exception Classes [61/65]

Decide exception should be checked
Subclass Exception or RuntimeException

Provide two constructors

public class IllegalFormatException extends Exception
{ 
   public IllegalFormatException() {} 
   public IllegalFormatException(String reason) 
   { super(reason); } 
}

Throw exception when needed:
throw new IllegalFormatException("number expected");

When Not to Use Inheritance [62/65]

From a tutorial for a C++ compiler:

public class Point 
{ 
   public Point(int anX, int aY) { ... } 
   public void translate(int dx, int dy) { ... } 
   private int x; 
   private int y; 
} 

public class Circle extends Point // DON'T 
{ 
   public Circle(Point center, int radius) { ... } 
   public void draw(Graphics g) { ... } 
   private int radius; 
}

When Not to Use Inheritance [63/65]

Huh? A circle isn't a point.
By accident, inherited translate works for circles

Same tutorial makes Rectangle a subclass of Point:

public class Rectangle extends Point // DON'T 
{ 
   public Rectangle(Point corner1, Point corner2) { ... } 
   public void draw(Graphics g) { ... } 
   public void translate(int dx, int dy) { ... } 
   private Point other; 
}

When Not to Use Inheritance [64/65]

That's even weirder:

public void translate(int dx, int dy)
{
   super.translate(dx, dy);
   other.translate(dx, dy);
}

Why did they do that?
Wanted to avoid abstract class Shape
Remedy: Use aggregation.
Circle, Rectangle classes have points

When Not to Use Inheritance [65/65]

Java standard library:

public class Stack<T> extends Vector<T> // DON'T
{
   T pop() { ... }
   void push(T item) { ... }
   ...
}

Bad idea: Inherit all Vector methods
Can insert/remove in the middle of the stack

Remedy: Use aggregation

public class Stack<T>
{
   ...
   private ArrayList<T> elements;
}

Revised: 2007/09/11 16:28