• Restrictions:
  • Must start with a letter
  • Can contain letters, digits, and '_'
  • Are case-sensitive
• Common Style Specification:
  • Must start with a lowercase letter
  • Must be descriptive

• Line Based:
  • Any text between a // and the end of the line is a comment
• Block:
  • Any text between a /* and a */ is a comment

• Syntax:
  • type variable [, variable]... ;
• Examples:
  • boolean done;
  • double expenses, income;
  • int numberOfChecks, styleNumber;

• Assignment:
  • Placing a value into the space identified by a variable/constant
• Syntax:
  • variable = literal|expression ;
• A Detail:
  • Implicit loss of precision is not allowed

• Purpose:
  • Indicate that a value can only be assigned to a variable once
• Syntax:
  • final type variable [, variable]... ;
• Examples:
  • final boolean CORRECT;
  • final double BUDGET;
  • final int CAPACITY;

• Syntax:
  • if (boolean_expression) statement [else statement]
• Note:
  • statement can be a simple or block statement

• Syntax:
  • while (boolean_expression) statement
• Note:
  • statement can be a simple or block statement

• Syntax:
  • do statement while (boolean_expression);
• Note:
  • statement can be a simple or block statement

• Syntax:
  • for (initialization; boolean_expression; update) statement
• Note:
  • statement can be a simple or block statement

• Declaration:
  • Syntax: BaseType[] ArrayName;
  • Example: int[] income;
• Memory Allocation:
  • Syntax: ArrayName = new BaseType[Length];
  • Example: income = new int[20];
• Accessing Elements:
  • Syntax: ArrayName[Index]
  • Example: income[5] = 250000;

The Arrays class (in the java.util package) contains several static methods that are very convenient when working with arrays.

    import java.util.Arrays;

    int     target;
    int[]   a;

    a = new int[100];

    Arrays.fill(a, 0);        // Fill a with zeroes
    Arrays.fill(a, 1, 10, 99) // Fill a[10] thru a[99] with ones

    ...

    Arrays.sort(a);           // Sort a in ascending order


    //  Searches for 5 in a and returns 5 if found
    //  The array must be sorted
    //
    target = Arrays.binarySearch(a,5);
    

• Classes:
  • accessibility class name { [attributes]... [methods]... }
• Details:
  • The name of the file containing a class must be exactly the same as the name of the class (with .java appended)
  • The accessibility of a class is most frequently public

• public:
  • Accessible to all objects in all classes
• protected:
  • Accessible to all objects in the containing class and specializations
• private:
  • Accessible to all objects in the containing class

• Syntax:
  • accessibility [static] type name([type parameter], ...)
• Examples:
  • public static double circleArea(double diameter)
  • public void update()

• Definition:
  • Attributes or methods that belong to a class (or all of its instances) rather than individual instances of a class
• Implication:
  • They can be used without instantiating an object
• Declaration:
  • Must be declared static

javaexamples/oopbasics/pictureframe/overloadedmethods/PictureFrame.java

        /**
 * An encapsulation of a picture frame.
 *
 * This version has overloaded methods.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 6.0
 */
public class PictureFrame
{
    private static final double DOLLARS_PER_IN_OF_FRAME    = 0.15;
    private static final double DOLLARS_PER_SQ_IN_OF_GLASS = 0.05;    

    private boolean    stand;    
    private double     height, matte, width;

    /**
     * Construct a PictureFrame object.
     *
     * Note: Negative values are converted to positive values 
     * and the width and height are put in canonical form 
     * (i.e., a portrait orientation).
     *
     * @param width   The width (in inches)
     * @param height  The height (in inches)
     * @param matte   The size of the matte (in inches) on all 4 sides
     * @param stand   true if there is a built-in stand
     */
    public PictureFrame(double width, double height, double matte, 
                        boolean stand)
    {
        double     h, w;
        
        h = Math.abs(height);
        w = Math.abs(width);

        this.width  = Math.min(w, h);
        this.height = Math.max(w, h);
        this.matte  = Math.abs(matte);
        this.stand  = stand;
    }
    
    /**
     * Construct a PictureFrame object with no matte and no stand.
     *
     * @param width   The width (in inches)
     * @param height  The height (in inches)
     */
    public PictureFrame(double width, double height)
    {
        this(width, height, 0.0, false);
    }

    /**
     * Calculate the area of this PictureFrame.
     *
     * @return  The area (in square inches)
     */
    private double area()
    {
        return width * height;
    }

    /**
     * Calculate the area of the matte.
     *
     * @return  The area (in square inches)
     */
    private double matteArea()
    {
               // Top and Bottom   + Sides (not including the top and bottom)
        return 2.0*(matte * width) + 2.0*(matte * (height - 2.0*matte));
    }

    /**
     * Calculate the perimeter of this PictureFrame.
     *
     * @return  The area (in inches)
     */
    private double perimeter()
    {
        return 2.0*width + 2.0*height;
    }

    /**
     * Return true if the owning PictureFrame and the given PictureFrame
     * have the same attributes.
     *
     * @return  true if the attributes are the same; false otherwise
     */
    public boolean equals(PictureFrame other)
    {
        return (this.width == other.width) && (this.height == other.height)
            && (this.matte == other.matte) && (this.stand == other.stand);
    }

    /**
     * Return the cost of this PictureFrame (which is a function
     * of the perimeter and the area) in dollars.
     *
     * @return   The cost
     */
    public double getCost()
    {
        double     frame, glass;
        
        frame = perimeter() * DOLLARS_PER_IN_OF_FRAME;
        glass = area() * DOLLARS_PER_SQ_IN_OF_GLASS;

        return frame+glass;
    }

    /**
     * Get the height of this PictureFrame.
     *
     * @return   The height
     */
    public double getHeight()
    {
        return height;
    }

    /**
     * Get the size of the matte.
     *
     * @return   The size of the matte
     */
    public double getMatte()
    {
        return matte;
    }

    /**
     * Get the width of this PictureFrame.
     *
     * @return   The width
     */
    public double getWidth()
    {
        return width;
    }
    /**
     * Return the visible area (in square inches) of the content
     * contained in this PictureFrame.
     *
     * @param    max   true for the maximum possible (i.e., unmatted) area 
     * @return   The visible area
     */
    public double getVisibleArea(boolean max)
    {
        double   result;
        
        result = area();
        if (!max) result -= matteArea();

        return result;
    }

    /**
     * Return the visible area (in square inches) of the content
     * contained in this PictureFrame.
     *
     * @return   The visible area
     */
    public double getVisibleArea()
    {
        return getVisibleArea(false);
    }

    /**
     * Return a human-readable String representation of this PictureFrame.
     *
     * @param   terse  true for a terse representation
     * @return         The String representation
     */
    public String toString(boolean terse)
    {
        String      result;

        if (terse)
        {
            result = ""+width+"x"+height;
        }
        else
        {
            result = ""+width+"in. x "+height+"in.";
            if (matte > 0.0) result += " with a "+matte+"in. matte";
            if (stand)       result += " (w/ stand)";
        }
        
        return result;
    }

    /**
     * Return a human-readable String representation of this PictureFrame.
     *
     * @return         The String representation
     */
    public String toString()
    {
        return toString(false);
    }
}
        

• enums:
  • accessibility enum name { instances, [attributes]... [methods]... }
• Details:
  • Are generally the same as for classes

javaexamples/oopbasics/months/v2/Month.java

        /**
 * An enumerated type for the months of the year
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 2.0
 */
public enum Month
{
   JANUARY   ("January",  31),
   FEBRUARY  ("February", 28),
   MARCH     ("March",    31), 
   APRIL     ("April",    30),
   MAY       ("May",      31),
   JUNE      ("June",     30), 
   JULY      ("July",     31),
   AUGUST    ("August",   31),
   SEPTEMBER ("September",30),
   OCTOBER   ("October",  31),
   NOVEMBER  ("November", 30),
   DECEMBER  ("December", 31);

   private final int    days;
   private final String name;

   /**
    * Explicit Value Constructor.
    *
    * @param name   The name of the Month
    * @param days   The number of days in the Month
    */
   private Month(String name, int days)
   {
      this.name = name;
      this.days = days;
   }

   /**
    * Get the 3-letter abbreviation for this Month.
    *
    * @return  The 3-letter abbreviation
    */
   public String getAbbreviation()
   {
      String       result;
      
      if (name.length() > 3) result = name.substring(0,3)+".";
      else                   result = name;

      return result;      
   }

   /**
    * Get the numeric value of this Month (in the interval [1,12]).
    *
    * @return  The numeric value of this Month
    */
   public int getNumber()
   {
      return ordinal()+1; // ordinal() returns the position in the declaration
   }

   /**
    * Get the (normal) number of days in this Month.
    *
    * @return  The normal number of days in this Month.
    */
   public int getLength()
   {
      return days;      
   }
   
   /**
    * Return the Month that corresponds to a given String.
    *
    * @param s   The String representation
    * @return    The corresponding Month (or null)
    */
   public static Month parseMonth(String s)
   {
       Month[] all;
       all = Month.values();
       for (int i=0; i<all.length; i++)
       {
          if (s.equalsIgnoreCase(all[i].name) 
              || s.equalsIgnoreCase(all[i].getAbbreviation()))
          {
              return all[i];
          }
       }
       return null;
   }
   
   /**
    * Get a String representation of this Month
    *
    * @return   The String representation (i.e., the name)
    */
   public String toString()
   {
      return name;      
   }
}
        

• Declaring a Subclass:
  • Use extends in the declaration of the class
• Accessing Members in a Superclass from a Subclass:
  • Use super as the left-side operand of the . operator
• Calling the Constructor in a Superclass from a Subclass:
  • Call super() (which must be in the first statement in a constructor of the subclass)

• A Particular Method:
  • A method that is declared to be final can't be overridden by a subclass
• An Entire Class:
  • A class that is declared to be final can't be specialized (i.e., a class that extends a final class will not compile)

• The Object Class:
  • All classes that don't explicitly extend a class implicitly extend the Object class
• Implication:
  • All objects have clone(), equals() and toString() methods, though they don't always do what you want

• Syntax of an Abstract Class:
  • accessibility abstract class name { body }
• Syntax of an Abstract Method:
  • accessibility abstract type name([parameter...]);

• Syntax:
  • accessibility interface name { body }
• Contents of the body:
  • Only method signatures (i.e., only abstract methods)
• Concrete Classes that Realize an Interface:
  • Declaration: accessibility class name implements iface1[, iface2]...
  • Implementation: Must implement all methods (in all interfaces)

• Parameterized Types in the Class Definition:
  • Class declarations can be parameterized
  • The parameters of the class are listed in angle brackets
  • Example: public class Identified<T>
• Parameterized Types in Attributes and Methods:
  • Attributes and methods can use the parameterized type as if it were an actual type

javaexamples/parameterized/Identified.java

        /**
 * A parameterized (i.e., type-safe) encapsulation of an Identified entity.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
public class Identified<T>
{
    private int       id;
    private T         entity;
    
    /**
     * Explicit Value Constructor.
     *
     * @param id      The unique identifier for the entity
     * @param entity  The entity
     */
    public Identified(int id, T entity)
    {
        this.id     = id;
        this.entity = entity;
    }
    
    /**
     * Get the ID of this Identified entity.
     *
     * @return   The ID
     */
    public int getID()
    {
        return id;
    }

    /**
     * Get the entity.
     *
     * @return   The entity
     */
    public T getEntity()
    {
        return entity;
    }
}
        

javaexamples/parameterized/Driver.java (Fragment: 0)

                Identified<Person>   person;
        Identified<Product>  product;
        
        
        person  = new Identified<Person>(   10, new Person());
        product = new Identified<Product>(3415, new Product());


        Person fred;
        fred   = person.getEntity();  // This will compile

        Person barney;
        barney = product.getEntity(); // This will not compile
        

• The Situation:
  • When constructing the parameterized class, you want to restrict the types that can be used as type arguments (i.e., the classes that can be bound to)
• The Solution:
  • List the parameter name followed by extends, followed by the bounding type
• A Note:
  • The term extends was probably a bad choice since any class that either extends the bounding type or implements the bounding type can be used

javaexamples/parameterized/bounded/Identified.java

        /**
 * A bounded parameterized encapsulation of an Identified entity.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
public class Identified<T extends Person>
{
    private int       id;
    private T         entity;
    
    /**
     * Explicit Value Constructor.
     *
     * @param id      The unique identifier for the entity
     * @param entity  The entity
     */
    public Identified(int id, T entity)
    {
        this.id     = id;
        this.entity = entity;
    }
    
    /**
     * Get the ID of this Identified entity.
     *
     * @return   The ID
     */
    public int getID()
    {
        return id;
    }

    /**
     * Get the entity.
     *
     * @return   The entity
     */
    public T getEntity()
    {
        return entity;
    }
}