• 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.

• 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

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

• 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

• 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