SE450: Horstmann Chapter 7

Type: set of values and the operations that can be applied to the values
Strongly typed language: compiler and run-time system check that no operation can execute that violates type system rules
Compile-time check
Employee e = new Employee(); e.clear(); // ERROR
Run-time check:
e = null; e.setSalary(20000); // ERROR

Java Types [4/86]

Primitive types:
int short long byte char float double boolean
Class types
Interface types
Array types
The null type
Note: void is not a type

Exercise: What kind of type? [5/86]

int
Rectangle
Shape
String[]
double[][]

Java Values [6/86]

value of primitive type
reference to object of class type
reference to array
null
Note: Can't have value of interface type

Exercise: What kind of value? [7/86]

13
new Rectangle(5, 10, 20, 30);
"Hello"
new int[] { 2, 3, 5, 7, 11, 13 }
null

Subtype Relationship [8/86]

S is a subtype of T if

S and T are the same type
S and T are both class types, and T is a direct or indirect superclass of S
S is a class type, T is an interface type, and S or one of its superclasses implements T
S and T are both interface types, and T is a direct or indirect superinterface of S
S and T are both array types, and the component type of S is a subtype of the component type of T
S is not a primitive type and T is the type Object
S is an array type and T is Cloneable or Serializable
S is the null type and T is not a primitive type

Subtype Examples [9/86]

Container is a subtype of Component
JButton is a subtype of Component
FlowLayout is a subtype of LayoutManager
ListIterator is a subtype of Iterator
Rectangle[] is a subtype of Shape[]
int[] is a subtype of Object
int is not a subtype of long
long is not a subtype of int
int[] is not a subtype of Object[]

Subtype Examples [10/86]

The ArrayStoreException [11/86]

Rectangle[] is a subtype of Shape[]

Can assign Rectangle[] value to Shape[] variable:

Rectangle[] r = new Rectangle[10];
Shape[] s = r;

Both r and s are references to the same array
That array holds rectangles
The assignment
s[0] = new Polygon();
compiles
Throws an ArrayStoreException at runtime
Each array remembers its component type

Array References [12/86]

Wrapper Classes [13/86]

Primitive types aren't classes
Use wrappers when objects are expected

Wrapper for each type:

Integer Short Long Byte
Character Float Double Boolean

Auto-boxing and auto-unboxing

ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(13); // calls new Integer(13)
int n = numbers.get(0); // calls intValue();

Enumerated Types [14/86]

Finite set of values
Example: enum Size { SMALL, MEDIUM, LARGE }
Typical use:
Size imageSize = Size.MEDIUM;
if (imageSize == Size.SMALL) . . .
Safer than integer constants
public static final int SMALL = 1; public static final int MEDIUM = 2; public static final int LARGE = 3;

Typesafe Enumerations [15/86]

enum equivalent to class with fixed number of instances

public class Size
{
  private /* ! */ Size() { }
  public static final Size SMALL = new Size();
  public static final Size MEDIUM = new Size();
  public static final Size LARGE = new Size();
}

enum types are classes; can add methods, fields, constructors

Type Inquiry [16/86]

Test whether e is a Shape:
if (e instanceof Shape) . . .
Common before casts:
Shape s = (Shape) e;
Don't know exact type of e
Could be any class implementing Shape
If e is null, test returns false (no exception)

The Class Class [17/86]

getClass method gets class of any object
Returns object of type Class

Class object describes a type

Object e = new Rectangle();
Class c = e.getClass();
System.out.println(c.getName()); // prints java.awt.Rectangle

Class.forName method yields Class object:
Class c = Class.forName("java.awt.Rectangle");
.class suffix yields Class object:
Class c = Rectangle.class; // java.awt prefix not needed
Class is a misnomer: int.class, void.class,Shape.class

An Employee Object vs. the Employee.class Object [18/86]

Type Inquiry [19/86]

Test whether e is a Rectangle:
if (e.getClass() == Rectangle.class) . . .
Ok to use ==
A unique Class object for every class
Test fails for subclasses
Use instanceof to test for subtypes:
if (e instanceof Rectangle) . . .

Array Types [20/86]

Can apply getClass to an array

Returned object describes an array type

double[] a = new double[10];
Class c = a.getClass();
if (c.isArray())
   System.out.println(c.getComponentType()); 
      // prints double

getName produces strange names for array types

[D for double[])
[[java.lang.String; for String[][]

Object: The Cosmic Superclass [21/86]

All classes extend Object
Most useful methods:
- String toString()
- boolean equals(Object otherObject)
- Object clone()
- int hashCode()

The toString Method [22/86]

Returns a string representation of the object
Useful for debugging
Example: Rectangle.toString returns something like
java.awt.Rectangle[x=5,y=10,width=20,height=30]
toString used by concatenation operator
aString + anObject
means
aString + anObject.toString()
Object.toString prints class name and object address
System.out.println(System.out) yields
java.io.PrintStream@d2460bf
Implementor of PrintStream didn't override toString:

Overriding the toString Method [23/86]

Format all fields:

public class Employee 
{ 
   public String toString() 
   { 
      return getClass().getName() 
         + "[name=" + name 
         + ",salary=" + salary 
         + "]"; 
   } 
   ... 
}

Typical string:

Employee[name=Harry Hacker,salary=35000]

Overriding toString in Subclass [24/86]

Format superclass first

public class Manager extends Employee 
{ 
   public String toString() 
   {  
      return super.toString()  + "[department=" + department + "]"; 
}
}

Typical string

Manager[name=Dolly Dollar,salary=100000][department=Finance]

Note that superclass reports actual class name

The equals Method [25/86]

equals tests for equal contents
== tests for equal location
Used in many standard library methods

Example: ArrayList.indexOf

/** 
   Searches for the first occurrence of the given argument, 
   testing for equality using the equals method. 
   @param elem an object. 
   @return the index of the first occurrence 
   of the argument in this list; returns -1 if 
   the object is not found. 
*/ 
public int indexOf(Object elem) 
{ 
   if (elem == null) 
   { 
      for (int i = 0; i < size; i++) 
         if (elementData[i] == null) return i; 
   } 
   else 
   { 
      for (int i = 0; i < size; i++) 
         if (elem.equals(elementData[i])) return i; 
   } 
   return -1; 
}

Overriding the equals Method [26/86]

Notion of equality depends on class

Common definition: compare all fields

public class Employee 
{ 
   public boolean equals(Object otherObject) 
      // not complete--see below 
   { 
      Employee other = (Employee)otherObject; 
      return name.equals(other.name) 
         && salary == other.salary; 
   } 
   ... 
}

Must cast the Object parameter to subclass
Use == for primitive types, equals for object fields

Overriding equals in Subclass [27/86]

Call equals on superclass

public class Manager 
{ 
   public boolean equals(Object otherObject) 
   { 
      Manager other = (Manager)otherObject; 
      return super.equals(other) 
         && department.equals(other.department); 
   } 
}

Not all equals Methods are Simple [28/86]

Two sets are equal if they have the same elements in some order

public boolean equals(Object o) 
{ 
   if (o == this) return true; 
   if (!(o instanceof Set)) return false; 
   Collection c = (Collection) o; 
   if (c.size() != size()) return false; 
   return containsAll(c); 
}

The Object.equals Method [29/86]

Object.equals tests for identity:

public class Object 
{ 
   public boolean equals(Object obj) 
   { 
      return this == obj; 
   } 
   ... 
}

Override equals if you don't want to inherit that behavior

Requirements for equals Method [30/86]

reflexive: x.equals(x)
symmetric: x.equals(y) if and only if y.equals(x)
transitive: if x.equals(y) and y.equals(z), then x.equals(z)
x.equals(null) must return false

Fixing Employee.equals [31/86]

Violates two rules
Add test for null:
if (otherObject == null) return false
What happens if otherObject not an Employee
Should return false (because of symmetry)
Common error: use of instanceof if (!(otherObject instanceof Employee)) return false; // don't do this for non-final classes
Violates symmetry: Suppose e, m have same name, salary
e.equals(m) is true (because m instanceof Employee)
m.equals(e) is false (because e isn't an instance of Manager)
Remedy: Test for class equality
if (getClass() != otherObject.getClass()) return false;

The Perfect equals Method [32/86]

Start with these three tests:

public boolean equals(Object otherObject) 
{ 
   if (this == otherObject) return true; 
   if (otherObject == null) return false; 
   if (getClass() != otherObject.getClass()) return false; 
   ... 
}

First test is an optimization

Hashing [33/86]

hashCode method used in HashMap, HashSet
Computes an int from an object
Example: hash code of String int h = 0; for (int i = 0; i < s.length(); i++) h = 31 * h + s.charAt(i);
Hash code of "eat" is 100184
Hash code of "tea" is 114704

Hashing [34/86]

Must be compatible with equals:
if x.equals(y), then x.hashCode() == y.hashCode()
Object.hashCode hashes memory address
NOT compatible with redefined equals

Remedy: Hash all fields and combine codes:

public class Employee 
{ 
   public int hashCode() 
   { 
      return name.hashCode() 
         + new Double(salary).hashCode(); 
   } 
   ... 
}

Shallow and Deep Copy [35/86]

Assignment (copy = e) makes shallow copy
Clone to make deep copy
Employee cloned = (Employee)e.clone();

Cloning [36/86]

Cloning [37/86]

Object.clone makes new object and copies all fields
Cloning is subtle
Object.clone is protected

Subclass must redefine clone to be public

public class Employee 
{ 
   public Object clone() 
   { 
      return super.clone(); // not complete 
   } 
   ... 
}

The Cloneable Interface [38/86]

Object.clone is nervous about cloning
Will only clone objects that implement Cloneable interface
```
public interface Cloneable
{
}
```
Interface has no methods!
Tagging interface--used in test
if x implements Cloneable
Object.clone throws CloneNotSupportedException
A checked exception

The clone Method [39/86]

public class Employee 
  implements Cloneable 
{ 
   public Object clone() 
   { 
      try 
      { 
         return super.clone(); 
      } 
      catch(CloneNotSupportedException e) 
      { 
         return null; // won't happen 
      }
   } 
   ... 
}

Shallow Cloning [40/86]

clone makes a shallow copy
Instance fields aren't cloned

Deep Cloning [41/86]

Why doesn't clone make a deep copy?
Wouldn't work for cyclic data structures
Not a problem for immutable fields
You must clone mutable fields

public class Employee 
  implements Cloneable 
{ 
   public Object clone() 
   { 
      try 
      { 
         Employee cloned = (Employee)super.clone();
         cloned.hireDate = (Date)hiredate.clone();
         return cloned; 
      } 
      catch(CloneNotSupportedException e) 
      { 
         return null; // won't happen 
      }
   } 
   ... 
}

Deep Cloning [42/86]

Cloning and Inheritance [43/86]

Object.clone is paranoid
- clone is protected
- clone only clones Cloneable objects
- clone throws checked exception
You don't have that luxury
Manager.clone must be defined if Manager adds mutable fields
Rule of thumb: if you extend a class that defines clone, redefine clone
Lesson to learn: Tagging interfaces are inherited. Use them only to tag properties that inherit

Serialization [44/86]

Save collection of objects to stream

Employee[] staff = new Employee[2]; 
staff.add(new Employee(...)); 
staff.add(new Employee(...));

Construct ObjectOutputStream:

ObjectOutputStream out 
   = new ObjectOutputStream( 
      new FileOutputStream("staff.dat"));

Save the array and close the stream
```
out.writeObject(staff); 
out.close(); 
```

Serialization [45/86]

The array and all of its objects and their dependent objects are saved
Employee doesn't have to define any method
Needs to implement the Serializable interface
Another tagging interface with no methods

How Serialization Works [46/86]

Each newly encountered object is saved
Each object gets a serial number in the stream
No object is saved twice
Reference to already encountered object saved as "reference to #"

How Serialization Works [47/86]

Serialing Unserializable Classes [48/86]

Some classes are not serializable
Security? Anonymous classes? Programmer cluelessness?
Example: Ellipse2D.Double
How can we serialize Car?
Suppress default serialization to avoid exception
Mark with transient:
private transient Ellipse2D frontTire;
Supply private (!) methods
private void writeObject(ObjectOutputStream out) private void readObject(ObjectInputStream in)
In these methods
- Call writeDefaultObject/readDefaultObject
- Manually save other data

file:horstmann/ch07_serial2/Car.java [source] [doc-public] [doc-private]

package horstmann.ch07_serial2;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.geom.Ellipse2D;
import java.awt.geom.RectangularShape;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
   A serializable car shape.
 */
public class Car implements Serializable
{
  private static final long serialVersionUID = 2008L;
  /**
      Constructs a car.
      @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 Car(int x, int y, int width)
  {
    body = new Rectangle(x, y + width / 6,
        width - 1, width / 6);
    roof = new Rectangle(x + width / 3, y,
        width / 3, width / 6);
    frontTire = new Ellipse2D.Double(x + width / 6, y + width / 3,
        width / 6, width / 6);
    rearTire = new Ellipse2D.Double(x + width * 2 / 3, y + width / 3,
        width / 6, width / 6);
  }

  private void writeObject(ObjectOutputStream out)
      throws IOException
  {
    out.defaultWriteObject();
    writeRectangularShape(out, frontTire);
    writeRectangularShape(out, rearTire);
  }

  /**
      A helper method to write a rectangular shape.
      @param out the stream onto which to write the shape
      @param s the shape to write
   */
  private static void writeRectangularShape(ObjectOutputStream out,
      RectangularShape s)
          throws IOException
  {
    out.writeDouble(s.getX());
    out.writeDouble(s.getY());
    out.writeDouble(s.getWidth());
    out.writeDouble(s.getHeight());
  }

  private void readObject(ObjectInputStream in)
      throws IOException, ClassNotFoundException
  {
    in.defaultReadObject();
    frontTire = new Ellipse2D.Double();
    readRectangularShape(in, frontTire);
    rearTire = new Ellipse2D.Double();
    readRectangularShape(in, rearTire);
  }

  /**
      A helper method to read a rectangular shape.
      @param in the stream from which to read the shape
      @param s the shape to read. The method sets the frame
      of this rectangular shape.
   */
  private static void readRectangularShape(ObjectInputStream in,
      RectangularShape s)
          throws IOException
  {
    double x = in.readDouble();
    double y = in.readDouble();
    double width = in.readDouble();
    double height = in.readDouble();
    s.setFrame(x, y, width, height);
  }

  /**
      Draws the car.
      @param g2 the graphics context
   */
  public void draw(Graphics2D g2)
  {
    g2.draw(body);
    g2.draw(roof);
    g2.draw(frontTire);
    g2.draw(rearTire);
  }

  public String toString()
  {
    return getClass().getName()
        + "[body=" + body
        + ",roof=" + roof
        + ",frontTire=" + formatRectangularShape(frontTire)
        + ",rearTire=" + formatRectangularShape(rearTire)
        + "]";
  }

  /**
      A helper method to format a rectangular shape.
      @param s the shape to format
      @return a formatted representation of the given shape
   */
  private static String formatRectangularShape(RectangularShape s)
  {
    return RectangularShape.class.getName()
        + "[x=" + s.getX()
        + ",y=" + s.getY()
        + ",width=" + s.getWidth()
        + ",height=" + s.getHeight()
        + "]";
  }


  private Rectangle body;
  private Rectangle roof;
  private transient Ellipse2D.Double frontTire;
  private transient Ellipse2D.Double rearTire;
}

Reflection [49/86]

Ability of running program to find out about its objects and classes
Class object reveals
- superclass
- interfaces
- package
- names and types of fields
- names, parameter types, return types of methods
- parameter types of constructors

Reflection [50/86]

Class getSuperclass()
Class[] getInterfaces()
Package getPackage()
Field[] getDeclaredFields()
Constructor[] getDeclaredConstructors()
Method[] getDeclaredMethods()

Enumerating Fields [51/86]

Print the names of all static fields of the Math class:

Field[] fields = Math.class.getDeclaredFields(); 
for (Field f : fields) 
   if (Modifier.isStatic(f.getModifiers())) 
      System.out.println(f.getName());

Enumerating Constructors [52/86]

Print the names and parameter types of all Rectangle
constructors:

for (Constructor c : cons) 
{ 
   Class[] params = cc.getParameterTypes(); 
   System.out.print("Rectangle(");
   boolean first = true; 
   for (Class p : params) 
   { 
      if (first) first = false; else System.out.print(", "); 
      System.out.print(p.getName()); 
   } 
   System.out.println(")"); 
}

Yields

Rectangle() 
Rectangle(java.awt.Rectangle) 
Rectangle(int, int, int, int) 
Rectangle(int, int) 
Rectangle(java.awt.Point, java.awt.Dimension) 
Rectangle(java.awt.Point) 
Rectangle(java.awt.Dimension)

Getting A Single Method Descriptor [53/86]

Supply method name
Supply array of parameter types

Example: Get Rectangle.contains(int, int):

Method m = Rectangle.class.getDeclaredMethod(
   "contains", int.class, int.class);

Example: Get default Rectangle constructor:

Constructor c = Rectangle.class.getDeclaredConstructor();

getDeclaredMethod, getDeclaredConstructor are varargs methods

Invoking a Method [54/86]

Supply implicit parameter (null for static methods)
Supply array of explicit parameter values
Wrap primitive types
Unwrap primitive return value

Example: Call System.out.println("Hello, World") the hard way.

Method m = PrintStream.class.getDeclaredMethod(
   "println", String.class);
m.invoke(System.out, "Hello, World!");

invoke is a varargs method

Inspecting Objects [55/86]

Can obtain object contents at runtime
Useful for generic debugging tools

Need to gain access to private fields

Class c = obj.getClass(); 
Field f = c.getDeclaredField(name); 
f.setAccessible(true);

Throws exception if security manager disallows access

Access field value:

Object value = f.get(obj); 
f.set(obj, value);

Use wrappers for primitive types

Inspecting Objects [56/86]

Example: Peek inside string tokenizer

Output

int currentPosition=0 
int newPosition=-1 
int maxPosition=13 
java.lang.String str=Hello, World! 
java.lang.String delimiters=, 
boolean retDelims=false 
boolean delimsChanged=false 
char maxDelimChar=, 
--- 
int currentPosition=5 
. . .

file:horstmann/ch07_reflect2/FieldTester.java [source] [doc-public] [doc-private]

package horstmann.ch07_reflect2;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Random;

/**
   This program shows how to use reflection to print
   the names and values of all nonstatic fields of an object.
 */
public class FieldTester
{
  public static void main(String[] args)
      throws IllegalAccessException
  {
    Random r = new Random();
    System.out.print(spyFields(r));
    r.nextInt();
    System.out.println("\nAfter calling nextInt:\n");
    System.out.print(spyFields(r));
  }

  /**
      Spies on the field names and values of an object.
      @param obj the object whose fields to format
      @return a string containing the names and values of
      all fields of obj
   */
  public static String spyFields(Object obj)
      throws IllegalAccessException
  {
    StringBuilder buffer = new StringBuilder();
    Field[] fields = obj.getClass().getDeclaredFields();
    for (Field f : fields)
    {
      if (!Modifier.isStatic(f.getModifiers()))
      {
        f.setAccessible(true);
        Object value = f.get(obj);
        buffer.append(f.getType().getName());
        buffer.append(" ");
        buffer.append(f.getName());
        buffer.append("=");
        buffer.append("" + value);
        buffer.append("\n");
      }
    }
    return buffer.toString();
  }
}

Inspecting Array Elements [57/86]

Use static methods of Array class

Object value = Array.get(a, i);
Array.set(a, i, value);

```
int n = Array.getLength(a);
```

Construct new array:

Object a = Array.newInstance(type, length);

Generic Types [58/86]

A generic type has one or more type variables
Type variables are instantiated with class or interface types
Cannot use primitive types, e.g. no ArrayList<int>

When defining generic classes, use type variables in definition:

public class ArrayList<E>
{
   public E get(int i) { . . . }
   public E set(int i, E newValue) { . . . }
   . . .
   private E[] elementData;
}

NOTE: If S a subtyoe of T, ArrayList<S> is not a subtype of ArrayList<T>.

Generic Methods [59/86]

Generic method = method with type parameter(s)

public class Utils
{
   public static <E> void fill(ArrayList<E> a, E value, int count)
   {
      for (int i = 0; i < count; i++)
         a.add(value);
   }  
}

A generic method in an ordinary (non-generic) class

Type parameters are inferred in call

ArrayList<String> ids = new ArrayList<String>();
Utils.fill(ids, "default", 10); // calls Utils.<String>fill

Type Bounds [60/86]

Type variables can be constrained with type bounds
Constraints can make a method more useful

The following method is limited:

public static <E> void append(ArrayList<E> a, ArrayList<E> b, int count)
{
   for (int i = 0; i < count && i < b.size(); i++)
      a.add(b.get(i));
}

Cannot append an ArrayList<Rectangle> to an ArrayList<Shape>

Type Bounds [61/86]

Overcome limitation with type bound:

public static <E, F extends E> void append(
   ArrayList<E> a, ArrayList<F> b, int count)
{
   for (int i = 0; i < count && i < b.size(); i++)
      a.add(b.get(i));
}

extends means "subtype", i.e. extends or implements
Can specify multiple bounds:
E extends Cloneable & Serializable

Wildcards [62/86]

Definition of append never uses type F. Can simplify with wildcard:

public static <E> void append(
   ArrayList<E> a, ArrayList<? extends E> b, int count)
{
   for (int i = 0; i < count && i < b.size(); i++)
      a.add(b.get(i));
}

Wildcards [63/86]

Wildcards restrict methods that can be called:
ArrayList<? extendsE>.set method has the form
? extends E add(? extends E newElement)
You cannot call this method!
No value matches ? extends E because ? is unknown
Ok to call get:
? extends E get(int i)
Can assign return value to an element of type E

Wildcards [64/86]

Wildcards can be bounded in opposite direction
? super F matches any supertype of F
public static <F> void append( ArrayList<? super F> a, ArrayList<F> b, int count) { for (int i = 0; i < count && i < b.size(); i++) a.add(b.get(i)); }
Safe to call ArrayList<? super F>.add:
boolean add(? super F newElement)
Can pass any element of type F (but not a supertype!)

Wildcards [65/86]

Typical example--start with

public static <E extends Comparable<E>> E getMax(ArrayList<E> a)
{
   E max = a.get(0);
   for (int i = 1; i < a.size(); i++)
      if (a.get(i).compareTo(max) > 0) max = a.get(i);
   return max;
}

E extends Comparable<E> so that we can call compareTo
Too restrictive--can't call with ArrayList<GregorianCalendar>
GregorianCalendar does not implement Comparable<GregorianCalendar>, only Comparable<Calendar>

Wildcards to the rescue:

public static <E extends Comparable<? super E>> E getMax(ArrayList<E> a)

Type Erasure [66/86]

Virtual machine does not know about generic types
Type variables are erased--replaced by type bound or Object if unbounded

Ex. ArrayList<E> becomes

public class ArrayList
{
   public Object get(int i) { . . . }
   public Object set(int i, Object newValue) { . . . }
   . . .
   private Object[] elementData;
}

Ex. getmax becomes

public static Comparable getMax(ArrayList a)
   // E extends Comparable<? super E> erased to Comparable

Erasure necessary to interoperate with legacy (pre-JDK 5.0) code

Limitations of Generics [67/86]

Cannot replace type variables with primitive types
Cannot construct new objects of generic type
a.add(new E()); // Error--would erase to new Object()

Workaround: Use class literals

public static <E> void fillWithDefaults(ArrayList<E>,
   Class<? extends E> cl, int count)
   throws InstantiationException, IllegalAccessException
{
   for (int i = 0; i < count; i++)
      a.add(cl.newInstance());
}

Call as fillWithDefaults(a, Rectangle.class, count)

Limitations of Generics [68/86]

Cannot form arrays of parameterized types
Comparable<E>[] is illegal. Remedy: ArrayList<Comparable<E>>
Cannot reference type parameters in a static context (static fields, methods, inner classes)
Cannot throw or catch generic types
Cannot have type clashes after erasure. Ex. GregorianCalendar cannot implement Comparable<GregorianCalendar> since it already implements Comparable<Calendar>, and both erase to Comparable

Components [69/86]

More functionality than a single class
Reuse and customize in multiple contexts
"Plug components together" to form applications
Successful model: Visual Basic controls
- calendar
- graph
- database
- link to robot or instrument
Componens composed into program inside builder environment

A Builder Environment [70/86]

Java Beans [71/86]

Java component model
Bean has
- methods (just like classes)
- properties
- events

Java Beans [72/86]

A Calendar Bean [73/86]

A Property Sheet [74/86]

Edit properties with property sheet

Facade Class [75/86]

Bean usually composed of multiple classes
One class nominated as facade class
Clients use only facade class methods

Facade Pattern [76/86]

Context

A subsystem consists of multiple classes, making it complicated for clients to use
Implementor may want to change subsystem classes
Want to give a coherent entry point

Solution

Define a facade class that exposes all capabilities of the subsystem as methods
The facade methods delegate requests to the subsystem classes
The subsystem classes do not know about the facade class

Facade Pattern [77/86]

Facade Pattern [78/86]

Name in Design Pattern	Actual Name (Beans)
Client	Builder tool
Facade	Main bean class with which the tool interacts
SubsystemClass	Class used to implement bean functionality

Bean Properties [79/86]

Property = value that you can get and/or set
Most properties are get-and-set
Can also have get-only and set-only
Property not the same as instance field
Setter can set fields, then call repaint
Getter can query database

Property Syntax [80/86]

Not Java :-(
C#, JavaScript, Visual Basic
b.propertyName = value calls setter
variable = b.propertyName calls getter

Java Naming Conventions [81/86]

property = pair of methods
public X getPropertyName() public void setPropertyName(X newValue)
Replace propertyName with actual name
(e.g. getColor/setColor)
Exception for boolean properties:
public boolean isPropertyName()
Decapitalization hokus-pokus:
getColor -> color getURL -> URL

Editing Beans in a Builder Tool [82/86]

Use wizard to make empty frame

Editing Beans in a Builder Tool [83/86]

Add button to frame
Edit button with property sheet

Packaging a Bean [84/86]

Compile bean classes
Create manifest file
Run JAR tool:
jar cvfm CarBean.jar CarBean.mf *.class
Import JAR file into builder environment

file:horstmann/ch07_carbean/CarBean.java [source] [doc-public] [doc-private]

package horstmann.ch07_carbean;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;

import javax.swing.JComponent;

/**
   A component that draws a car shape.
 */
@SuppressWarnings("serial")
public class CarBean extends JComponent
{
  /**
      Constructs a default car bean.
   */
  public CarBean()
  {
    x = 0;
    y = 0;
    width = DEFAULT_CAR_WIDTH;
    height = DEFAULT_CAR_HEIGHT;
  }

  /**
      Sets the x property.
      @param newValue the new x position
   */
  public void setX(int newValue)
  {
    x = newValue;
    repaint();
  }

  /**
      Gets the x property.
      @return the x position
   */
  public int getX()
  {
    return x;
  }

  /**
      Sets the y property.
      @param newValue the new y position
   */
  public void setY(int newValue)
  {
    y = newValue;
    repaint();
  }

  /**
      Gets the y property.
      @return the y position
   */
  public int getY()
  {
    return y;
  }

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

    // The bottom of the front windshield
    Point2D.Double r1
    = new Point2D.Double(x + width / 6, y + height / 3);
    // 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 + height / 3);

    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 Dimension getPreferredSize()
  {
    return new Dimension(DEFAULT_PANEL_WIDTH,
        DEFAULT_PANEL_HEIGHT);
  }

  private int x;
  private int y;
  private int width;
  private int height;

  private static final int DEFAULT_CAR_WIDTH = 60;
  private static final int DEFAULT_CAR_HEIGHT = 30;
  private static final int DEFAULT_PANEL_WIDTH = 160;
  private static final int DEFAULT_PANEL_HEIGHT = 130;
}

file:horstmann/ch07_carbean/CarBean.mf

Composing Beans [85/86]

Make new frame
Add car bean, slider to frame
Edit stateChanged event of slider
Add handler code
carBean1.setX(jSlider1.getValue());
Compile and run
Move slider: the car moves

Composing Beans [86/86]

Revised: 2007/11/02 18:30